add an outer_bound_only option to solve_one (#802)

* add an outer_bound_only option to solve_one

* Have the Lagrangian spokes ask only for an outer bound

Thread the new solve_one outer_bound_only option through solve_loop
(SPOpt and PHBase) and switch the Lagrangian spokes onto it, so their
solves skip loading a solution they never look at.

Whether a solution is needed is a property of the spoke rather than of
each call, so it is an `outer_bound_only` attribute on _LagrangianMixin
rather than an argument on lagrangian(). Three cases opt out:

- ReducedCostsSpoke reads x and the rc suffix off the solved
  subproblems (class attribute).
- subgradient_while_waiting makes Compute_Xbar read the x values left
  behind by the previous solve (set in LagrangianOuterBound.main).
- lagranger, until the first nonants arrive from the hub: it computes
  xbar from its own x until it has the hub's.

Also in solve_one's outer_bound_only branch: mark solution_available
False (no solution was loaded, so the Vars hold pre-solve values, and
the staleness check and PRIOR_SOLUTION warmstart must not treat them as
a solution), re-raise a solver exception instead of letting it surface
as an AttributeError on the missing results object, and fix the assert,
which asserted a tuple and so could never fire.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Fix invalid outer bounds and the cgbase positional solve_loop call

Two bugs, both caught by CI on the previous commit.

Gate the outer_bound_only bound extraction behind the existing
not_good_enough_results check instead of running ahead of it. Without
prox, a Lagrangian subproblem is routinely unbounded, and the results
object then carries no usable bound: gurobi leaves Lower_bound None (so
Ebound died on prob * None) while other solvers return garbage, which
was published as a valid outer bound -- test_cvar_lagrangian_outer_bound
saw 1.9e9 against a true optimum of -220700. A bad solve now takes the
path it took before this option existed: gripe, no solution, and
outer_bound left at its previous value, which is still a valid outer
bound since any Lagrangian dual value bounds the original problem.
The remaining None check can only fire on an otherwise usable solve.

Pass solve_loop's arguments by keyword in cgbase. It called super()
positionally, so inserting outer_bound_only ahead of warmstart in the
signature slid warmstart=True into the outer_bound_only slot, tripping
the assert. cgbase was the only positional caller.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Test outer_bound_only first, gated on bound rather than solution

not_good_enough_results asks whether there is a usable *solution*, which
is the wrong question for a bound-only solve: a subproblem stopped by a
time limit or a gap can carry no incumbent at all and still report the
outer bound the caller is there for. Gating the bound-only path behind
it threw those bounds away.

So test outer_bound_only first, with its own gate. no_outer_bound_results
is the bound-shaped analog of not_good_enough_results: same disqualifying
terminations (infeasible, unbounded, error), minus the two clauses about
solution presence and solution status. When it does disqualify a solve
there is no meaningful bound to report -- solvers variously return None,
a sentinel, or garbage -- so outer_bound keeps its previous value, which
is still a valid outer bound.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Guard the outer bound extraction with a try block

The helper rules on the routine, condition-detectable outcomes; the try
block catches what it cannot foresee (an empty results.Problem, say) and
re-raises with the scenario and status attached. Raising is right there:
no_outer_bound_results has already accounted for the bound-less solves,
so anything still throwing is a surprise rather than a routine outcome.

Note this try block is not what catches an unbounded subproblem. Pyomo
assigns None (gurobi) or the last iterate's objective (cplex) to
Problem[0].Lower_bound rather than raising, so nothing propagates out of
the attribute access; the termination condition is the only signal that
survives both plugins, and the None check backstops the rest.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Address the Copilot review: raise instead of assert, cgbase signature

Raise a ValueError rather than assert on outer_bound_only with
need_solution. python -O strips asserts, and this guard earns its keep
precisely there: it is what caught cgbase passing warmstart into the
outer_bound_only slot, whose silent form is bound-only solves in code
that builds columns from the solutions. Verified it now fires under both
python and python -O. This matches the convention already spelled out in
reduced_costs_spoke.py.

Accept and forward outer_bound_only in CGBase.solve_loop, which had
drifted from the base signature -- that drift is what made the
positional call break in the first place. Column generation needs the
solutions, so the option is not useful there; it is accepted to keep the
override honest, and a caller who asks for it raises out of solve_one
because need_solution defaults True. xhat_eval is deliberately left
alone: its signature is a different shape and it defaults
need_solution=False, so the guard would not catch misuse there.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Stop screening TerminationCondition.error out of the outer bound

xpress reports a MIP that ran out of time with no incumbent as
status=aborted, TerminationCondition=error (mip_no_sol_found in
xpress_direct.py), and then hands over xprob_attrs.bestbound anyway --
a perfectly good outer bound. Screening on error threw it away and the
Lagrangian spoke died in Ebound with no bound to report, which is the
case outer_bound_only exists to serve.

Screen as little as possible here: a bound from a solve that went badly
is the whole point of asking for a bound only. Infeasible and unbounded
stay screened, because there the danger is not a missing value but a
misleading one -- cplex fills in the last iterate's objective for an
unbounded LP, a plausible finite number that is not a bound.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Start subproblems at the vacuous outer bound instead of no attribute

Only solve_one ever wrote outer_bound, so until it did there was nothing
to read, and Ebound died with "'ScalarBlock' object has no attribute
'outer_bound'" whenever a first solve reported no bound. Give every
subproblem the bound it actually holds before its first solve: -inf
minimizing, +inf maximizing. That is what is known at that point, it
keeps Ebound arithmetic, and being the worst bound there is it never
wins a comparison at the hub. This predates outer_bound_only -- the old
not_good_enough_results path left the attribute unset the same way.

cgbase reads outer_bound as a reduced cost and tested hasattr to decide
whether one existed, which is now always true, so it tests the value
instead: it sums these into sum_redcosts, where an infinity would
quietly poison the total rather than fail loudly as None did.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Address Copilot review: keyword-only outer_bound_only, docstrings, traceback, tests

- Make outer_bound_only keyword-only and restore warmstart to its
  original positional slot in solve_one and the three solve_loop
  overrides, so existing positional calls can't land on it.
- Correct the docstrings: a bound-only solve that reports no bound keeps
  the previous (possibly vacuous) outer bound rather than raising.
- Use a bare raise when an unexpected bound-extraction error surfaces so
  the original traceback is preserved.
- Add mpisppy/tests/test_outer_bound_only.py covering the bound-only
  path, the need_solution guard, the normal solve, and the keyword-only
  contract; wire it into run_coverage.bash and test_pr_and_main.yml.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* Use None, not +/-inf, for a not-yet-computed subproblem bound

Addresses bknueven's review: a subproblem that has not been solved (or whose
bound-only solve reported no bound) has not *computed* a bound, so it should
hold None rather than a vacuous +/-inf dressed up as a real number.

- _set_initial_bounds: seed outer_bound/inner_bound with None.
- Ebound: return None if any scenario (collectively, across ranks) is missing
  its outer bound, since the expectation cannot then be formed; the missing
  check is Allreduce'd so every rank agrees before the sum reduction.
- Teach the consumers to treat None as 'no bound to offer': the Lagrangian and
  Lagranger spokes skip send_bound; PHBase.Iter0 and Subgradient keep the prior
  best bound; post_solve_bound prints 'not available'; the cross-scenario cut
  extension folds None to the weakest bound for its max/min aggregation.
- Extend test_outer_bound_only with solver-free coverage of the None path:
  initial bounds are None, Ebound is None when any bound is missing and the
  weighted sum when all are present, and is a finite number after a successful
  bound-only solve.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: DLWoodruff

.github/workflows/test_pr_and_main.yml

@@ -98,6 +98,10 @@ jobs:
         run: |
           coverage run $COV_ARGS -m pytest mpisppy/tests/test_cvar.py -v
 
+      - name: Test outer_bound_only
+        run: |
+          coverage run $COV_ARGS -m pytest mpisppy/tests/test_outer_bound_only.py -v
+
       - name: Test chance_constraint
         run: |
           coverage run $COV_ARGS -m pytest mpisppy/tests/test_chance_constraint.py -v

mpisppy/cgbase.py

@@ -7,6 +7,7 @@
 # full copyright and license information.
 ###############################################################################
 
+import math
 import time
 import pyomo.environ as pyo
 
@@ -411,8 +412,13 @@ def build_columns_from_subproblem_solutions(self, sname, scenario):
         red_cost=None
         if hasattr(model, "base_obj_expr"):
             scen_cost = pyo.value(model.base_obj_expr)
-        if hasattr(model._mpisppy_data, "outer_bound"):
-            red_cost = model._mpisppy_data.outer_bound
+        # Subproblems now start life holding the vacuous outer bound rather
+        # than no attribute at all, so test the value: an infinite bound means
+        # the solve reported none, and the caller sums these into
+        # sum_redcosts, where an infinity would quietly poison the total.
+        outer_bound = getattr(model._mpisppy_data, "outer_bound", None)
+        if outer_bound is not None and math.isfinite(outer_bound):
+            red_cost = outer_bound
         x_vec = {ndn_i: pyo.value(xvar) for ndn_i, xvar in scenario._mpisppy_data.nonant_indices.items()}
         return sname, red_cost, scen_cost,x_vec
 
@@ -478,7 +484,9 @@ def solve_loop(self, solver_options=None,
                    tee=False,
                    verbose=False,
                    need_solution=True,
-                   warmstart=sputils.WarmstartStatus.FALSE):
+                   warmstart=sputils.WarmstartStatus.FALSE,
+                   *,
+                   outer_bound_only=False):
         """ Loop over `local_subproblems` and solve them in a manner
         dicated by the arguments.
 
@@ -506,6 +514,13 @@ def solve_loop(self, solver_options=None,
                 Default True
             warmstart (bool, optional):
                 If True, warmstart the subproblem solves. Default False.
+            outer_bound_only (boolean, optional):
+                If True, populate outer_bound *only*; no solution is loaded, so
+                need_solution must be False. Column generation builds its
+                columns from the subproblem solutions, so this is here to keep
+                the signature honest with the base class rather than because
+                it is useful: asking for it (with the default need_solution)
+                raises out of solve_one. Keyword-only. Default False.
         """
 
         """ Developer notes:
@@ -519,14 +534,15 @@ def solve_loop(self, solver_options=None,
         self.update_subproblem_duals_from_mp(self.pi_values, self.mu_values)
 
         super().solve_loop(
-            solver_options,
-            dtiming,
-            gripe,
-            disable_pyomo_signal_handling,
-            tee,
-            verbose,
-            need_solution,
-            warmstart,
+            solver_options=solver_options,
+            dtiming=dtiming,
+            gripe=gripe,
+            disable_pyomo_signal_handling=disable_pyomo_signal_handling,
+            tee=tee,
+            verbose=verbose,
+            need_solution=need_solution,
+            outer_bound_only=outer_bound_only,
+            warmstart=warmstart,
         )
 
 

mpisppy/cylinders/lagranger_bounder.py

@@ -40,6 +40,11 @@ def _lagrangian(self, iternum):
         if self.rho_rescale_factors is not None\
            and iternum in self.rho_rescale_factors:
             self._rescale_rho(self.rho_rescale_factors[iternum])
+        # Until the first nonants arrive, _update_weights_and_solve computes
+        # xbar from the x values left behind by this solve, so we cannot skip
+        # loading the solution. Once they have arrived they never go back to
+        # nan, and xbar comes from the hub's nonants instead.
+        self.outer_bound_only = not np.isnan(self.localnonants[0])
         return self.lagrangian()
 
     def _rescale_rho(self,rf):
@@ -105,7 +110,10 @@ def main(self):
             self.opt.extobject.post_iter0()
         self.opt._PHIter = 1
 
-        self.send_bound(self.trivial_bound)
+        # trivial_bound is None if the iter0 solve produced no outer bound;
+        # there is nothing to send in that case.
+        if self.trivial_bound is not None:
+            self.send_bound(self.trivial_bound)
         if extensions:
             self.opt.extobject.post_iter0_after_sync()
 

mpisppy/cylinders/lagrangian_bounder.py

@@ -12,6 +12,12 @@
 
 class _LagrangianMixin:
 
+    # A Lagrangian solve is only ever asked for its outer bound, so by default
+    # we don't pay to load a solution. Spokes that also need the x (or rc)
+    # values off the solved subproblems set this to False; see
+    # ReducedCostsSpoke and the subgradient_while_waiting option.
+    outer_bound_only = True
+
     def lagrangian_prep(self):
         # Split up PH_Prep? Prox option is important for APH.
         # Seems like we shouldn't need the Lagrangian stuff, so attach_prox=False
@@ -24,7 +30,7 @@ def lagrangian_prep(self):
         self.opt._reenable_W()
         self.opt._create_solvers()
 
-    def lagrangian(self, need_solution=True, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION):
+    def lagrangian(self, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION):
         # update the nonant bounds, if possible, for a tighter relaxation
         self.receive_nonant_bounds()
         verbose = self.opt.options['verbose']
@@ -41,7 +47,8 @@ def lagrangian(self, need_solution=True, warmstart=sputils.WarmstartStatus.PRIOR
             gripe=True,
             tee=teeme,
             verbose=verbose,
-            need_solution=need_solution,
+            need_solution=not self.outer_bound_only,
+            outer_bound_only=self.outer_bound_only,
             warmstart=warmstart,
         )
         ''' DTM (dlw edits): This is where PHBase Iter0 checks for scenario
@@ -63,23 +70,28 @@ class LagrangianOuterBound(_PreLoopXhatMixin, _LagrangianMixin, mpisppy.cylinder
 
     converger_spoke_char = 'L'
 
-    def _set_weights_and_solve(self, need_solution, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION):
+    def _set_weights_and_solve(self, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION):
         self.opt.W_from_flat_list(self.localWs) # Sets the weights
-        return self.lagrangian(need_solution=need_solution, warmstart=warmstart)
+        return self.lagrangian(warmstart=warmstart)
 
-    def do_while_waiting_for_new_Ws(self, need_solution, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION):
+    def do_while_waiting_for_new_Ws(self, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION):
         if self.opt.options.get("subgradient_while_waiting", False):
             # compute a subgradient step
             self.opt.Compute_Xbar(self.verbose)
             self.opt.Update_W(self.verbose)
-            bound = self.lagrangian(need_solution=need_solution, warmstart=warmstart)
+            bound = self.lagrangian(warmstart=warmstart)
             if bound is not None:
                 self.send_bound(bound)
 
-    def main(self, need_solution=False):
+    def main(self):
         self.verbose = self.opt.options['verbose']
         extensions = self.opt.extensions is not None
 
+        if self.opt.options.get("subgradient_while_waiting", False):
+            # Compute_Xbar reads the x values left behind by the previous
+            # solve, so every solve has to load its solution.
+            self.outer_bound_only = False
+
         self.lagrangian_prep()
 
         if self._jensens_enabled():
@@ -93,7 +105,7 @@ def main(self, need_solution=False):
 
         # setting this for PH extensions used by this Spoke
         self.opt._PHIter = 0
-        self.trivial_bound = self.lagrangian(need_solution=need_solution, warmstart=sputils.WarmstartStatus.USER_SOLUTION)
+        self.trivial_bound = self.lagrangian(warmstart=sputils.WarmstartStatus.USER_SOLUTION)
 
         if extensions:
             self.opt.extobject.post_iter0()
@@ -103,15 +115,18 @@ def main(self, need_solution=False):
         # transition; static iterk options come from the layer fold.
         self.opt.current_solver_options = {}
 
-        self.send_bound(self.trivial_bound)
+        # trivial_bound is None if the iter0 solve produced no outer bound;
+        # there is nothing to send in that case.
+        if self.trivial_bound is not None:
+            self.send_bound(self.trivial_bound)
         if extensions:
             self.opt.extobject.post_iter0_after_sync()
 
         while not self.got_kill_signal():
             if self.update_Ws():
                 if extensions:
                     self.opt.extobject.miditer()
-                bound = self._set_weights_and_solve(need_solution=need_solution, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION)
+                bound = self._set_weights_and_solve(warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION)
                 if extensions:
                     self.opt.extobject.enditer()
                 if bound is not None:
@@ -120,4 +135,4 @@ def main(self, need_solution=False):
                     self.opt.extobject.enditer_after_sync()
                 self.opt._PHIter += 1
             else:
-                self.do_while_waiting_for_new_Ws(need_solution=need_solution, warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION)
+                self.do_while_waiting_for_new_Ws(warmstart=sputils.WarmstartStatus.PRIOR_SOLUTION)

mpisppy/cylinders/reduced_costs_spoke.py

@@ -89,6 +89,10 @@ class ReducedCostsSpoke(LagrangianOuterBound):
 
     converger_spoke_char = 'R'
 
+    # unlike a plain Lagrangian spoke, this one reads the x values and the rc
+    # suffix off the solved subproblems, so the solves have to load a solution
+    outer_bound_only = False
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.bound_tol = self.opt.options['rc_bound_tol']
@@ -201,10 +205,8 @@ def lagrangian_prep(self):
             s.rc = pyo.Suffix(direction=pyo.Suffix.IMPORT)
         super().lagrangian_prep()
 
-    def lagrangian(self, need_solution=True, warmstart=False):
-        if not need_solution:
-            raise RuntimeError("ReducedCostsSpoke always needs a solution to work")
-        bound = super().lagrangian(need_solution=need_solution, warmstart=False)
+    def lagrangian(self, warmstart=False):
+        bound = super().lagrangian(warmstart=False)
         if bound is not None:
             self.extract_and_store_reduced_costs()
             self.update_bounding_functions(bound)
@@ -436,16 +438,12 @@ def update_nonant_bounds(self):
         if bounds_modified > 0:
             global_toc(f"{self.__class__.__name__}: tightened {int(bounds_modified)} variable bounds", self.cylinder_rank == 0)
 
-    def do_while_waiting_for_new_Ws(self, need_solution, warmstart=False):
+    def do_while_waiting_for_new_Ws(self, warmstart=False):
         # RC is an LP, should not need a warmstart with _value
-        super().do_while_waiting_for_new_Ws(need_solution=need_solution, warmstart=False)
+        super().do_while_waiting_for_new_Ws(warmstart=False)
         # might as well see if a tighter upper bound has come along
         self.extract_and_store_updated_nonant_bounds(new_dual=False)
 
-    def main(self):
-        # need the solution for ReducedCostsSpoke
-        super().main(need_solution=True)
-
 
 def _lb_generator(var_iterable):
     for v in var_iterable:

mpisppy/extensions/cross_scen_extension.py

@@ -102,8 +102,15 @@ def _check_bound(self):
                 need_solution=False,
         )
 
-        local_obs = np.fromiter((s._mpisppy_data.outer_bound for s in opt.local_scenarios.values()),
-                                dtype="d", count=len(opt.local_scenarios))
+        # A subproblem that produced no outer bound holds None; for the max/min
+        # aggregation it should be the weakest possible bound (so it is ignored),
+        # which is the vacuous bound: -inf when minimizing, +inf when maximizing.
+        vacuous_ob = -np.inf if opt.is_minimizing else np.inf
+        local_obs = np.fromiter(
+            (vacuous_ob if s._mpisppy_data.outer_bound is None
+             else s._mpisppy_data.outer_bound
+             for s in opt.local_scenarios.values()),
+            dtype="d", count=len(opt.local_scenarios))
 
         local_ob = np.empty(1)
         if opt.is_minimizing:

mpisppy/opt/subgradient.py

@@ -102,8 +102,11 @@ def solve_loop(self,
         )
 
         # set self.best_bound_obj_val if we don't have any additional fixed variables
-        if self._can_update_best_bound():
-            self.best_bound_obj_val = self.Ebound(verbose)
+        # (Ebound is None if a subproblem produced no outer bound; keep the prior
+        # best bound in that case rather than overwriting it with nothing)
+        bound = self.Ebound(verbose)
+        if bound is not None and self._can_update_best_bound():
+            self.best_bound_obj_val = bound
 
     def _can_update_best_bound(self):
         # TODO: is our class hierarchy wrong?

mpisppy/phbase.py

@@ -586,7 +586,9 @@ def post_solve_bound(self, solver_options=None, verbose=False):
         self._reenable_prox()
 
         if (verbose and self.cylinder_rank == 0):
-            print(f'Post-solve Lagrangian bound: {bound:.4f}')
+            # bound is None if any subproblem produced no outer bound.
+            shown = "not available" if bound is None else f"{bound:.4f}"
+            print(f'Post-solve Lagrangian bound: {shown}')
         return bound
 
 
@@ -599,7 +601,9 @@ def solve_loop(self, solver_options=None,
                    tee=False,
                    verbose=False,
                    need_solution=True,
-                   warmstart=sputils.WarmstartStatus.FALSE):
+                   warmstart=sputils.WarmstartStatus.FALSE,
+                   *,
+                   outer_bound_only=False):
         """ Loop over `local_scenarios` and solve them in a manner
         dictated by the arguments.
 
@@ -632,6 +636,11 @@ def solve_loop(self, solver_options=None,
                 Default True
             warmstart (bool, optional):
                 If True, warmstart the subproblem solves. Default False.
+            outer_bound_only (boolean, optional):
+                If True, populate outer_bound *only*; no solution is loaded, so
+                need_solution must be False. If the solve reports no bound, the
+                previous outer bound is kept (a valid, if vacuous, outer bound).
+                Keyword-only. Default False.
         """
 
         """ Developer notes:
@@ -662,6 +671,7 @@ def solve_loop(self, solver_options=None,
             tee=tee,
             verbose=verbose,
             need_solution=need_solution,
+            outer_bound_only=outer_bound_only,
             warmstart=warmstart,
         )
 
@@ -1224,7 +1234,7 @@ def _vb(msg):
             self.extobject.post_iter0()
 
         self.trivial_bound = self.Ebound(verbose)
-        if self._can_update_best_bound():
+        if self.trivial_bound is not None and self._can_update_best_bound():
             self.best_bound_obj_val = self.trivial_bound
 
         if hasattr(self.spcomm, "sync_nonants"):

mpisppy/spbase.py

@@ -129,6 +129,7 @@ def __init__(
         self._set_sense()
         self._use_variable_probability_setter()
         self._set_solution_cache()
+        self._set_initial_bounds()   # None until the first solve writes a bound
 
         ## SPCommunicator object
         self._spcomm = None
@@ -575,6 +576,24 @@ def _set_solution_cache(self):
             s._mpisppy_data.best_solution_cache = None
             s._mpisppy_data.latest_nonant_solution_cache = np.full(len(s._mpisppy_data.nonant_indices), np.nan)
 
+    def _set_initial_bounds(self):
+        """Give every subproblem the "not computed yet" bounds it holds before
+        its first solve.
+
+        Only solve_one ever writes these, so until it does there is nothing to
+        read: Ebound would die with "'ScalarBlock' object has no attribute
+        'outer_bound'" whenever a first solve reports no bound (a subproblem
+        that times out with no bound to show for it, say). None says exactly
+        that -- the bound has not been computed -- rather than dressing the
+        absence up as a number. Ebound propagates the None (the expected bound
+        is unavailable if any scenario is missing its bound) and the bound
+        spokes decline to send it, so a missing bound is never mistaken for a
+        real one at the hub.
+        """
+        for k,s in self.local_scenarios.items():
+            s._mpisppy_data.outer_bound = None
+            s._mpisppy_data.inner_bound = None
+
     def update_best_solution_if_improving(self, obj_val):
         """ Call if the variable values have a nonanticipative solution
             with associated obj_val. Will update the best_solution_cache