1    	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2    	/*                                                                           */
3    	/*                  This file is part of the program and library             */
4    	/*         SCIP --- Solving Constraint Integer Programs                      */
5    	/*                                                                           */
6    	/*  Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB)                      */
7    	/*                                                                           */
8    	/*  Licensed under the Apache License, Version 2.0 (the "License");          */
9    	/*  you may not use this file except in compliance with the License.         */
10   	/*  You may obtain a copy of the License at                                  */
11   	/*                                                                           */
12   	/*      http://www.apache.org/licenses/LICENSE-2.0                           */
13   	/*                                                                           */
14   	/*  Unless required by applicable law or agreed to in writing, software      */
15   	/*  distributed under the License is distributed on an "AS IS" BASIS,        */
16   	/*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17   	/*  See the License for the specific language governing permissions and      */
18   	/*  limitations under the License.                                           */
19   	/*                                                                           */
20   	/*  You should have received a copy of the Apache-2.0 license                */
21   	/*  along with SCIP; see the file LICENSE. If not visit scipopt.org.         */
22   	/*                                                                           */
23   	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24   	
25   	/**@file   scip_conflict.h
26   	 * @ingroup PUBLICCOREAPI
27   	 * @brief  public methods for conflict handler plugins and conflict analysis
28   	 * @author Tobias Achterberg
29   	 * @author Timo Berthold
30   	 * @author Thorsten Koch
31   	 * @author Alexander Martin
32   	 * @author Marc Pfetsch
33   	 * @author Kati Wolter
34   	 * @author Gregor Hendel
35   	 * @author Leona Gottwald
36   	 */
37   	
38   	/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
39   	
40   	#ifndef __SCIP_SCIP_CONFLICT_H__
41   	#define __SCIP_SCIP_CONFLICT_H__
42   	
43   	
44   	#include "scip/def.h"
45   	#include "scip/type_conflict.h"
46   	#include "scip/type_cons.h"
47   	#include "scip/type_lp.h"
48   	
49   	#ifdef __cplusplus
50   	extern "C" {
51   	#endif
52   	
53   	/**@addtogroup PublicConflicthdlrMethods
54   	 *
55   	 * @{
56   	 */
57   	
58   	/** creates a conflict handler and includes it in SCIP
59   	 *
60   	 *  @note method has all conflict handler callbacks as arguments and is thus changed every time a new
61   	 *        callback is added
62   	 *        in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
63   	 *        if you seek for a method which is less likely to change in future releases
64   	 */
65   	SCIP_EXPORT
66   	SCIP_RETCODE SCIPincludeConflicthdlr(
67   	   SCIP*                 scip,               /**< SCIP data structure */
68   	   const char*           name,               /**< name of conflict handler */
69   	   const char*           desc,               /**< description of conflict handler */
70   	   int                   priority,           /**< priority of the conflict handler */
71   	   SCIP_DECL_CONFLICTCOPY((*conflictcopy)),  /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
72   	   SCIP_DECL_CONFLICTFREE((*conflictfree)),  /**< destructor of conflict handler */
73   	   SCIP_DECL_CONFLICTINIT((*conflictinit)),  /**< initialize conflict handler */
74   	   SCIP_DECL_CONFLICTEXIT((*conflictexit)),  /**< deinitialize conflict handler */
75   	   SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
76   	   SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
77   	   SCIP_DECL_CONFLICTEXEC((*conflictexec)),  /**< conflict processing method of conflict handler */
78   	   SCIP_CONFLICTHDLRDATA* conflicthdlrdata   /**< conflict handler data */
79   	   );
80   	
81   	/** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
82   	 *  (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
83   	 *  Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
84   	 *  SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
85   	 *  and SCIPsetConflicthdlrExitsol()
86   	 *
87   	 *  @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
88   	 */
89   	SCIP_EXPORT
90   	SCIP_RETCODE SCIPincludeConflicthdlrBasic(
91   	   SCIP*                 scip,               /**< SCIP data structure */
92   	   SCIP_CONFLICTHDLR**   conflicthdlrptr,    /**< reference to a conflict handler pointer, or NULL */
93   	   const char*           name,               /**< name of conflict handler */
94   	   const char*           desc,               /**< description of conflict handler */
95   	   int                   priority,           /**< priority of the conflict handler */
96   	   SCIP_DECL_CONFLICTEXEC((*conflictexec)),  /**< conflict processing method of conflict handler */
97   	   SCIP_CONFLICTHDLRDATA* conflicthdlrdata   /**< conflict handler data */
98   	   );
99   	
100  	/** set copy method of conflict handler */
101  	SCIP_EXPORT
102  	SCIP_RETCODE SCIPsetConflicthdlrCopy(
103  	   SCIP*                 scip,               /**< SCIP data structure */
104  	   SCIP_CONFLICTHDLR*    conflicthdlr,       /**< conflict handler */
105  	   SCIP_DECL_CONFLICTCOPY((*conflictcopy))   /**< copy method of conflict handler */
106  	   );
107  	
108  	/** set destructor of conflict handler */
109  	SCIP_EXPORT
110  	SCIP_RETCODE SCIPsetConflicthdlrFree(
111  	   SCIP*                 scip,               /**< SCIP data structure */
112  	   SCIP_CONFLICTHDLR*    conflicthdlr,       /**< conflict handler */
113  	   SCIP_DECL_CONFLICTFREE((*conflictfree))   /**< destructor of conflict handler */
114  	   );
115  	
116  	/** set initialization method of conflict handler */
117  	SCIP_EXPORT
118  	SCIP_RETCODE SCIPsetConflicthdlrInit(
119  	   SCIP*                 scip,               /**< SCIP data structure */
120  	   SCIP_CONFLICTHDLR*    conflicthdlr,       /**< conflict handler */
121  	   SCIP_DECL_CONFLICTINIT((*conflictinit))   /**< initialize conflict handler */
122  	   );
123  	
124  	/** set deinitialization method of conflict handler */
125  	SCIP_EXPORT
126  	SCIP_RETCODE SCIPsetConflicthdlrExit(
127  	   SCIP*                 scip,               /**< SCIP data structure */
128  	   SCIP_CONFLICTHDLR*    conflicthdlr,       /**< conflict handler */
129  	   SCIP_DECL_CONFLICTEXIT((*conflictexit))   /**< deinitialize conflict handler */
130  	   );
131  	
132  	/** set solving process initialization method of conflict handler */
133  	SCIP_EXPORT
134  	SCIP_RETCODE SCIPsetConflicthdlrInitsol(
135  	   SCIP*                 scip,               /**< SCIP data structure */
136  	   SCIP_CONFLICTHDLR*    conflicthdlr,       /**< conflict handler */
137  	   SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
138  	   );
139  	
140  	/** set solving process deinitialization method of conflict handler */
141  	SCIP_EXPORT
142  	SCIP_RETCODE SCIPsetConflicthdlrExitsol(
143  	   SCIP*                 scip,               /**< SCIP data structure */
144  	   SCIP_CONFLICTHDLR*    conflicthdlr,       /**< conflict handler */
145  	   SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
146  	   );
147  	
148  	/** returns the conflict handler of the given name, or NULL if not existing */
149  	SCIP_EXPORT
150  	SCIP_CONFLICTHDLR* SCIPfindConflicthdlr(
151  	   SCIP*                 scip,               /**< SCIP data structure */
152  	   const char*           name                /**< name of conflict handler */
153  	   );
154  	
155  	/** returns the array of currently available conflict handlers */
156  	SCIP_EXPORT
157  	SCIP_CONFLICTHDLR** SCIPgetConflicthdlrs(
158  	   SCIP*                 scip                /**< SCIP data structure */
159  	   );
160  	
161  	/** returns the number of currently available conflict handlers */
162  	SCIP_EXPORT
163  	int SCIPgetNConflicthdlrs(
164  	   SCIP*                 scip                /**< SCIP data structure */
165  	   );
166  	
167  	/** sets the priority of a conflict handler */
168  	SCIP_EXPORT
169  	SCIP_RETCODE SCIPsetConflicthdlrPriority(
170  	   SCIP*                 scip,               /**< SCIP data structure */
171  	   SCIP_CONFLICTHDLR*    conflicthdlr,       /**< conflict handler */
172  	   int                   priority            /**< new priority of the conflict handler */
173  	   );
174  	
175  	/** @} */
176  	
177  	/**@addtogroup PublicConflictMethods
178  	 *
179  	 * @{
180  	 */
181  	
182  	/** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
183  	 *  conflict analysis since it will not be applied
184  	 *
185  	 *  @return return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
186  	 *          conflict analysis since it will not be applied
187  	 *
188  	 *  @pre This method can be called if SCIP is in one of the following stages:
189  	 *       - \ref SCIP_STAGE_INITPRESOLVE
190  	 *       - \ref SCIP_STAGE_PRESOLVING
191  	 *       - \ref SCIP_STAGE_EXITPRESOLVE
192  	 *       - \ref SCIP_STAGE_SOLVING
193  	 *
194  	 *  @note SCIP stage does not get changed
195  	 */
196  	SCIP_EXPORT
197  	SCIP_Bool SCIPisConflictAnalysisApplicable(
198  	   SCIP*                 scip                /**< SCIP data structure */
199  	   );
200  	
201  	/** initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you
202  	 *  enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
203  	 *  SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
204  	 *
205  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
206  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
207  	 *
208  	 *  @pre This method can be called if SCIP is in one of the following stages:
209  	 *       - \ref SCIP_STAGE_PRESOLVING
210  	 *       - \ref SCIP_STAGE_SOLVING
211  	 *
212  	 *  @note SCIP stage does not get changed
213  	 */
214  	SCIP_EXPORT
215  	SCIP_RETCODE SCIPinitConflictAnalysis(
216  	   SCIP*                 scip,               /**< SCIP data structure */
217  	   SCIP_CONFTYPE         conftype,           /**< type of conflict */
218  	   SCIP_Bool             iscutoffinvolved    /**< is the current cutoff bound involved? */
219  	   );
220  	
221  	/** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
222  	 *  this method should be called in one of the following two cases:
223  	 *   1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound
224  	 *      that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
225  	 *   2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called
226  	 *      for each lower bound, whose current assignment led to the deduction of the given conflict bound.
227  	 *
228  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
229  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
230  	 *
231  	 *  @pre This method can be called if SCIP is in one of the following stages:
232  	 *       - \ref SCIP_STAGE_PRESOLVING
233  	 *       - \ref SCIP_STAGE_SOLVING
234  	 *
235  	 *  @note SCIP stage does not get changed
236  	 */
237  	SCIP_EXPORT
238  	SCIP_RETCODE SCIPaddConflictLb(
239  	   SCIP*                 scip,               /**< SCIP data structure */
240  	   SCIP_VAR*             var,                /**< variable whose lower bound should be added to conflict candidate queue */
241  	   SCIP_BDCHGIDX*        bdchgidx            /**< bound change index representing time on path to current node, when the
242  	                                              *   conflicting bound was valid, NULL for current local bound */
243  	   );
244  	
245  	/** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
246  	 *  with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough
247  	 *  to explain a certain bound change;
248  	 *  this method should be called in one of the following two cases:
249  	 *   1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound
250  	 *      that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
251  	 *   2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called
252  	 *      for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.
253  	 *
254  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
255  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
256  	 *
257  	 *  @pre This method can be called if SCIP is in one of the following stages:
258  	 *       - \ref SCIP_STAGE_PRESOLVING
259  	 *       - \ref SCIP_STAGE_SOLVING
260  	 *
261  	 *  @note SCIP stage does not get changed
262  	 */
263  	SCIP_EXPORT
264  	SCIP_RETCODE SCIPaddConflictRelaxedLb(
265  	   SCIP*                 scip,               /**< SCIP data structure */
266  	   SCIP_VAR*             var,                /**< variable whose lower bound should be added to conflict candidate queue */
267  	   SCIP_BDCHGIDX*        bdchgidx,           /**< bound change index representing time on path to current node, when the
268  	                                              *   conflicting bound was valid, NULL for current local bound */
269  	   SCIP_Real             relaxedlb           /**< the relaxed lower bound */
270  	   );
271  	
272  	/** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
273  	 *  this method should be called in one of the following two cases:
274  	 *   1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that
275  	 *      led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
276  	 *   2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for
277  	 *      each upper bound, whose current assignment led to the deduction of the given conflict bound.
278  	 *
279  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
280  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
281  	 *
282  	 *  @pre This method can be called if SCIP is in one of the following stages:
283  	 *       - \ref SCIP_STAGE_PRESOLVING
284  	 *       - \ref SCIP_STAGE_SOLVING
285  	 *
286  	 *  @note SCIP stage does not get changed
287  	 */
288  	SCIP_EXPORT
289  	SCIP_RETCODE SCIPaddConflictUb(
290  	   SCIP*                 scip,               /**< SCIP data structure */
291  	   SCIP_VAR*             var,                /**< variable whose upper bound should be added to conflict candidate queue */
292  	   SCIP_BDCHGIDX*        bdchgidx            /**< bound change index representing time on path to current node, when the
293  	                                              *   conflicting bound was valid, NULL for current local bound */
294  	   );
295  	
296  	/** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
297  	 *  with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough
298  	 *  to explain a certain bound change;
299  	 *  this method should be called in one of the following two cases:
300  	 *   1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper
301  	 *      bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
302  	 *   2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be
303  	 *      called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict
304  	 *      bound.
305  	 *
306  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
307  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
308  	 *
309  	 *  @pre This method can be called if SCIP is in one of the following stages:
310  	 *       - \ref SCIP_STAGE_PRESOLVING
311  	 *       - \ref SCIP_STAGE_SOLVING
312  	 *
313  	 *  @note SCIP stage does not get changed
314  	 */
315  	SCIP_EXPORT
316  	SCIP_RETCODE SCIPaddConflictRelaxedUb(
317  	   SCIP*                 scip,               /**< SCIP data structure */
318  	   SCIP_VAR*             var,                /**< variable whose upper bound should be added to conflict candidate queue */
319  	   SCIP_BDCHGIDX*        bdchgidx,           /**< bound change index representing time on path to current node, when the
320  	                                              *   conflicting bound was valid, NULL for current local bound */
321  	   SCIP_Real             relaxedub           /**< the relaxed upper bound */
322  	   );
323  	
324  	/** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate
325  	 *  storage; this method should be called in one of the following two cases:
326  	 *   1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound
327  	 *      that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
328  	 *   2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called
329  	 *      for each bound, whose current assignment led to the deduction of the given conflict bound.
330  	 *
331  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
332  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
333  	 *
334  	 *  @pre This method can be called if SCIP is in one of the following stages:
335  	 *       - \ref SCIP_STAGE_PRESOLVING
336  	 *       - \ref SCIP_STAGE_SOLVING
337  	 *
338  	 *  @note SCIP stage does not get changed
339  	 */
340  	SCIP_EXPORT
341  	SCIP_RETCODE SCIPaddConflictBd(
342  	   SCIP*                 scip,               /**< SCIP data structure */
343  	   SCIP_VAR*             var,                /**< variable whose upper bound should be added to conflict candidate queue */
344  	   SCIP_BOUNDTYPE        boundtype,          /**< the type of the conflicting bound (lower or upper bound) */
345  	   SCIP_BDCHGIDX*        bdchgidx            /**< bound change index representing time on path to current node, when the
346  	                                              *   conflicting bound was valid, NULL for current local bound */
347  	   );
348  	
349  	/** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis'
350  	 *  candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one
351  	 *  which would be enough to explain a certain bound change;
352  	 *  this method should be called in one of the following two cases:
353  	 *   1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed)
354  	 *      bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
355  	 *   2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be
356  	 *      called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.
357  	 *
358  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
359  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
360  	 *
361  	 *  @pre This method can be called if SCIP is in one of the following stages:
362  	 *       - \ref SCIP_STAGE_PRESOLVING
363  	 *       - \ref SCIP_STAGE_SOLVING
364  	 *
365  	 *  @note SCIP stage does not get changed
366  	 */
367  	SCIP_EXPORT
368  	SCIP_RETCODE SCIPaddConflictRelaxedBd(
369  	   SCIP*                 scip,               /**< SCIP data structure */
370  	   SCIP_VAR*             var,                /**< variable whose upper bound should be added to conflict candidate queue */
371  	   SCIP_BOUNDTYPE        boundtype,          /**< the type of the conflicting bound (lower or upper bound) */
372  	   SCIP_BDCHGIDX*        bdchgidx,           /**< bound change index representing time on path to current node, when the
373  	                                              *   conflicting bound was valid, NULL for current local bound */
374  	   SCIP_Real             relaxedbd           /**< the relaxed bound */
375  	   );
376  	
377  	/** adds changed bound of fixed binary variable to the conflict analysis' candidate storage;
378  	 *  this method should be called in one of the following two cases:
379  	 *   1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary
380  	 *      variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
381  	 *   2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called
382  	 *      for each binary variable, whose current fixing led to the deduction of the given conflict bound.
383  	 *
384  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
385  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
386  	 *
387  	 *  @pre This method can be called if SCIP is in one of the following stages:
388  	 *       - \ref SCIP_STAGE_PRESOLVING
389  	 *       - \ref SCIP_STAGE_SOLVING
390  	 *
391  	 *  @note SCIP stage does not get changed
392  	 */
393  	SCIP_EXPORT
394  	SCIP_RETCODE SCIPaddConflictBinvar(
395  	   SCIP*                 scip,               /**< SCIP data structure */
396  	   SCIP_VAR*             var                 /**< binary variable whose changed bound should be added to conflict queue */
397  	   );
398  	
399  	/** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
400  	 *  even stronger bound
401  	 *
402  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
403  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
404  	 *
405  	 *  @pre This method can be called if SCIP is in one of the following stages:
406  	 *       - \ref SCIP_STAGE_PRESOLVING
407  	 *       - \ref SCIP_STAGE_SOLVING
408  	 *
409  	 *  @note SCIP stage does not get changed
410  	 */
411  	SCIP_EXPORT
412  	SCIP_RETCODE SCIPisConflictVarUsed(
413  	   SCIP*                 scip,               /**< SCIP data structure */
414  	   SCIP_VAR*             var,                /**< variable whose upper bound should be added to conflict candidate queue */
415  	   SCIP_BOUNDTYPE        boundtype,          /**< the type of the conflicting bound (lower or upper bound) */
416  	   SCIP_BDCHGIDX*        bdchgidx,           /**< bound change index representing time on path to current node, when the
417  	                                              *   conflicting bound was valid, NULL for current local bound */
418  	   SCIP_Bool*            used                /**< pointer to store if the variable is already used */
419  	   );
420  	
421  	/** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
422  	 *  bound
423  	 *
424  	 *  @return returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
425  	 *          bound
426  	 *
427  	 *  @pre This method can be called if SCIP is in one of the following stages:
428  	 *       - \ref SCIP_STAGE_PRESOLVING
429  	 *       - \ref SCIP_STAGE_SOLVING
430  	 *
431  	 *  @note SCIP stage does not get changed
432  	 */
433  	SCIP_EXPORT
434  	SCIP_Real SCIPgetConflictVarLb(
435  	   SCIP*                 scip,               /**< SCIP data structure */
436  	   SCIP_VAR*             var                 /**< problem variable */
437  	   );
438  	
439  	/** returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
440  	 *  upper bound
441  	 *
442  	 *  @return returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
443  	 *          upper bound
444  	 *
445  	 *  @pre This method can be called if SCIP is in one of the following stages:
446  	 *       - \ref SCIP_STAGE_PRESOLVING
447  	 *       - \ref SCIP_STAGE_SOLVING
448  	 *
449  	 *  @note SCIP stage does not get changed
450  	 */
451  	SCIP_EXPORT
452  	SCIP_Real SCIPgetConflictVarUb(
453  	   SCIP*                 scip,               /**< SCIP data structure */
454  	   SCIP_VAR*             var                 /**< problem variable */
455  	   );
456  	
457  	/** analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to
458  	 *  SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
459  	 *  SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict
460  	 *  handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth
461  	 *  level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
462  	 *  SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is
463  	 *  valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons()
464  	 *  instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
465  	 *
466  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
467  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
468  	 *
469  	 *  @pre This method can be called if SCIP is in one of the following stages:
470  	 *       - \ref SCIP_STAGE_PRESOLVING
471  	 *       - \ref SCIP_STAGE_SOLVING
472  	 *
473  	 *  @note SCIP stage does not get changed
474  	 */
475  	SCIP_EXPORT
476  	SCIP_RETCODE SCIPanalyzeConflict(
477  	   SCIP*                 scip,               /**< SCIP data structure */
478  	   int                   validdepth,         /**< minimal depth level at which the initial conflict set is valid */
479  	   SCIP_Bool*            success             /**< pointer to store whether a conflict constraint was created, or NULL */
480  	   );
481  	
482  	/** analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(),
483  	 *  SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or
484  	 *  SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the
485  	 *  resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint
486  	 *  that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(),
487  	 *  SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(),
488  	 *  SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
489  	 *
490  	 *  @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
491  	 *          SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
492  	 *
493  	 *  @pre This method can be called if SCIP is in one of the following stages:
494  	 *       - \ref SCIP_STAGE_PRESOLVING
495  	 *       - \ref SCIP_STAGE_SOLVING
496  	 *
497  	 *  @note SCIP stage does not get changed
498  	 */
499  	SCIP_EXPORT
500  	SCIP_RETCODE SCIPanalyzeConflictCons(
501  	   SCIP*                 scip,               /**< SCIP data structure */
502  	   SCIP_CONS*            cons,               /**< constraint that detected the conflict */
503  	   SCIP_Bool*            success             /**< pointer to store whether a conflict constraint was created, or NULL */
504  	   );
505  	
506  	/**@} */
507  	
508  	#ifdef __cplusplus
509  	}
510  	#endif
511  	
512  	#endif
513