cons_logicor.c
Go to the documentation of this file.
33/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
73#define CONSHDLR_ENFOPRIORITY -2000000 /**< priority of the constraint handler for constraint enforcing */
74#define CONSHDLR_CHECKPRIORITY -2000000 /**< priority of the constraint handler for checking feasibility */
75#define CONSHDLR_SEPAFREQ 0 /**< frequency for separating cuts; zero means to separate only in the root node */
76#define CONSHDLR_PROPFREQ 1 /**< frequency for propagating domains; zero means only preprocessing propagation */
77#define CONSHDLR_EAGERFREQ 100 /**< frequency for using all instead of only the useful constraints in separation,
79#define CONSHDLR_MAXPREROUNDS -1 /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
80#define CONSHDLR_DELAYSEPA FALSE /**< should separation method be delayed, if other separators found cuts? */
81#define CONSHDLR_DELAYPROP FALSE /**< should propagation method be delayed, if other propagators found reductions? */
82#define CONSHDLR_NEEDSCONS TRUE /**< should the constraint handler be skipped, if no constraints are available? */
87#define LINCONSUPGD_PRIORITY +800000 /**< priority of the constraint handler for upgrading of linear constraints */
96#define DEFAULT_PRESOLPAIRWISE TRUE /**< should pairwise constraint comparison be performed in presolving? */
97#define DEFAULT_STRENGTHEN TRUE /**< should pairwise constraint comparison try to strengthen constraints by removing superflous non-zeros? */
100#define DEFAULT_PRESOLUSEHASHING TRUE /**< should hash table be used for detecting redundant constraints in advance */
102#define DEFAULT_NEGATEDCLIQUE TRUE /**< should negated clique information be used in presolving */
103#define DEFAULT_IMPLICATIONS TRUE /**< should we try to shrink the variables and derive global boundchanges by
114/* @todo maybe use event SCIP_EVENTTYPE_VARUNLOCKED to decide for another dual-presolving run on a constraint */
124 SCIP_CONSHDLR* conshdlrlinear; /**< pointer to linear constraint handler or NULL if not included */
125 SCIP_CONSHDLR* conshdlrsetppc; /**< pointer to setppc constraint handler or NULL if not included */
126 SCIP_Bool presolpairwise; /**< should pairwise constraint comparison be performed in presolving? */
127 SCIP_Bool presolusehashing; /**< should hash table be used for detecting redundant constraints in
131 SCIP_Bool useimplications; /**< should we try to shrink the variables and derive global boundchanges
133 SCIP_Bool usestrengthening; /**< should pairwise constraint comparison try to strengthen constraints by
141/* @todo it might speed up exit-presolve to remember all positions for variables when catching the varfixed event, or we
142 * change catching and dropping the events like it is done in cons_setppc, which probably makes the code more
159 unsigned int presolved:1; /**< flag indicates if we have some fixed, aggregated or multi-aggregated
162 unsigned int impladded:1; /**< was the 2-variable logic or constraint already added as implication? */
164 unsigned int changed:1; /**< was constraint changed since last redundancy round in preprocessing? */
308 SCIP_CALL( SCIPgetTransformedVars(scip, (*consdata)->nvars, (*consdata)->vars, (*consdata)->vars) );
315 (*consdata)->existmultaggr = (*consdata)->existmultaggr || (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR);
490 if( !consdata->existmultaggr && SCIPvarGetStatus(SCIPvarGetProbvar(var)) == SCIP_VARSTATUS_MULTAGGR )
504 if( SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING || SCIPgetStage(scip) == SCIP_STAGE_INITPRESOLVE )
558 if( SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING || SCIPgetStage(scip) == SCIP_STAGE_INITPRESOLVE )
604/** in case a part (more than one variable) in the logic or constraint is independent of every else, we can perform dual
606 * - fix the variable with the smallest object coefficient to one if the constraint is not modifiable and all
611 * also added the special case were exactly one variable is locked by this constraint and another variable without any
615 * Moreover, if there exists a variable that is only locked by a constraint with two variables, one can aggregate variables.
617 * Note: the following dual reduction for logic or constraints is already performed by the presolver "dualfix"
618 * - if a variable in a set covering constraint is only locked by that constraint and has negative or zero
630 SCIP_RESULT* result /**< pointer to store the result SCIP_SUCCESS, if presolving was performed */
659 /* constraints for which the check flag is set to FALSE, did not contribute to the lock numbers; therefore, we cannot
660 * use the locks to decide for a dual reduction using this constraint; for example after a restart the cuts which are
673 /* we don't want to consider small constraints (note that the constraints can be modifiable, so we can't delete this
687 /* check if we can apply the dual reduction; therefore count the number of variables where the logic or has the only
695 /* variables with varstatus not equal to SCIP_VARSTATUS_FIXED can also have fixed bounds, but were not removed yet */
731 /* remember best variable with no uplocks, this variable dominates all other with exactly one downlock */
745 /* in case an other constraints has also locks on that variable we cannot perform a dual reduction on these
777 /* In the special case of two variables, where one variable is independent and is minimized, we can aggregate variables:
778 * We have var1 + var2 >= 1 and var1 is independent with positive objective. Then var1 + var2 == 1 holds. */
788 SCIP_CALL( SCIPaggregateVars(scip, vars[indepidx], vars[idx2], 1.0, 1.0, 1.0, &infeasible, &redundant, &aggregated) );
854 /* in case an other constraints has also locks on that variable we cannot perform a dual reduction on these
889 /* if all variable have our appreciated number of locks and the constraint is not modifiable, or if the bestobjval is
890 * less than or equal to zero, we can fix the variable with the smallest objective coefficient to one and the
910/** deletes all zero-fixed variables, checks for variables fixed to one, replace all variables which are not active or
984 /* renew all variables, important that we do a backwards loop because deletion only affect rear items */
990 if( SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR || (SCIPvarGetStatus(var) == SCIP_VARSTATUS_NEGATED && SCIPvarGetStatus(SCIPvarGetNegatedVar(var)) == SCIP_VARSTATUS_MULTAGGR) )
1007 SCIP_CALL( SCIPgetProbvarLinearSum(scip, consvars, consvals, &nconsvars, nconsvars, &constant, &requiredsize, TRUE) );
1014 SCIP_CALL( SCIPgetProbvarLinearSum(scip, consvars, consvals, &nconsvars, requiredsize, &constant, &requiredsize, TRUE) );
1047 assert(SCIPvarIsActive(consvars[v2]) || (SCIPvarGetStatus(consvars[v2]) == SCIP_VARSTATUS_NEGATED && SCIPvarIsActive(SCIPvarGetNegationVar(consvars[v2]))));
1063 /* it might happen that there are more than one multi-aggregated variable, so we need to get the whole probvar sum over all variables */
1067 /* memory needed is at least old number of variables - 1 + number of variables in first multi-aggregation */
1083 SCIP_CALL( SCIPgetProbvarLinearSum(scip, consvars, consvals, &nconsvars, size, &constant, &requiredsize, TRUE) );
1085 /* if space was not enough(we found another multi-aggregation), we need to resize the buffers */
1091 SCIP_CALL( SCIPgetProbvarLinearSum(scip, consvars, consvals, &nconsvars, requiredsize, &constant, &requiredsize, TRUE) );
1134 SCIPwarningMessage(scip, "logicor constraint <%s> has a multi-aggregated variable, which was not resolved and therefore could lead to aborts\n", SCIPconsGetName(cons));
1183/** analyzes conflicting assignment on given constraint, and adds conflict constraint to problem */
1194 if( (SCIPgetStage(scip) != SCIP_STAGE_SOLVING && !SCIPinProbing(scip)) || !SCIPisConflictAnalysisApplicable(scip) )
1200 /* initialize conflict analysis, and add all variables of infeasible constraint to conflict candidate queue */
1223 /* in case the logic or constraint is satisfied in the depth where it is also valid, we can delete it */
1230 SCIPdebugMsg(scip, "disabling constraint cons <%s> at depth %d\n", SCIPconsGetName(cons), SCIPgetDepth(scip));
1238/** find sets of equal variables in constraint: multiple entries of variable can be replaced by single entry */
1244 unsigned char** entries, /**< array to store whether two positions in constraints represent the same variable */
1295 /* all variables should be active or negative active variables, otherwise something went wrong with applyFixings()
1309 /* all variables should be active or negative active variables, otherwise something went wrong with applyFixings()
1313 (SCIPvarGetStatus(vars[v]) == SCIP_VARSTATUS_NEGATED && SCIPvarIsActive(SCIPvarGetNegationVar(vars[v]))));
1320 /* check variable type, either pure binary or an integer/implicit integer variable with 0/1 bounds */
1323 ((pos >= nbinvars && pos < nbinvars + nintvars && SCIPvarGetType(var) == SCIP_VARTYPE_INTEGER) ||
1331 /* check all vars for multiple entries, do necessary backwards loop because deletion only affect rear items */
1347 SCIPdebugMsg(scip, "logicor constraint <%s> redundant: variable <%s> and its negation are present\n",
1364 SCIPdebugMsg(scip, "logicor constraint <%s> redundant: variable <%s> and its negation are present\n",
1387/** checks constraint for violation only looking at the watched variables, applies fixings if possible */
1396 SCIP_Bool* mustcheck /**< pointer to store whether this constraint must be checked for feasibility */
1422 SCIPdebugMsg(scip, "processing watched variables of constraint <%s>\n", SCIPconsGetName(cons));
1432 SCIPdebugMsg(scip, " -> disabling constraint <%s> (watchedvar1 fixed to 1.0)\n", SCIPconsGetName(cons));
1439 SCIPdebugMsg(scip, " -> disabling constraint <%s> (watchedvar2 fixed to 1.0)\n", SCIPconsGetName(cons));
1536 * - a modifiable constraint must be added as a cut and further pricing must be performed in the LP solving loop
1559 * - an unmodifiable constraint is feasible and can be disabled after the remaining variable is fixed to one
1570 /* fixed remaining variable to one and disable constraint; make sure, the fixed-to-one variable is watched */
1586 SCIPdebugMsg(scip, " -> new watched variables <%s> and <%s> of constraint <%s> are still unfixed\n",
1661 SCIP_CALL( SCIPcreateEmptyRowCons(scip, &consdata->row, cons, SCIPconsGetName(cons), 1.0, SCIPinfinity(scip),
1664 SCIP_CALL( SCIPaddVarsToRowSameCoef(scip, consdata->row, consdata->nvars, consdata->vars, 1.0) );
1680 /* skip deactivated, redundant, or local constraints (the NLP does not allow for local rows at the moment) */
1697 0.0, consdata->nvars, consdata->vars, coefs, NULL, 1.0, SCIPinfinity(scip), SCIP_EXPRCURV_LINEAR) );
1772 SCIP_CALL( processWatchedVars(scip, cons, eventhdlr, cutoff, reduceddom, &addcut, &mustcheck) );
1848 SCIP_CALL( processWatchedVars(scip, cons, eventhdlr, cutoff, reduceddom, &addcut, &mustcheck) );
1922 found = SCIPsortedvecFindPtr((void**)consdata->vars, SCIPvarComp, (void*)var1, consdata->nvars, &pos);
1925 (void) SCIPsortedvecFindPtr((void**)consdata->vars, SCIPvarComp, (void*)var1, consdata->nvars, &pos);
1933 found = SCIPsortedvecFindPtr((void**)consdata->vars, SCIPvarComp, (void*)var2, consdata->nvars, &pos);
1936 (void) SCIPsortedvecFindPtr((void**)consdata->vars, SCIPvarComp, (void*)var2, consdata->nvars, &pos);
1966/** returns TRUE iff both keys are equal; two constraints are equal if they have the same variables */
2034/** compares each constraint with all other constraints for a possible duplication and removes duplicates using a hash
2098 /* update flags of constraint which caused the redundancy s.t. nonredundant information doesn't get lost */
2167 signature |= ((unsigned int)1 << ((unsigned int)SCIPvarGetIndex(vars[v]) % (sizeof(unsigned int) * 8)));
2173/** compute the constraint signature which is used to detect constraints, that contain potentially the same set of
2194 int* noccurlistentries, /**< arrray with number of constraints for each variable in the occurlist */
2255 int* noccurlistentries, /**< arrray with number of constraints for each variable in the occurlist */
2282 /* it might be that a variable is not yet put into the occurlist, then this constraint cannot cover another */
2303/** run a pairwise comparison for detecting subset-constraints of other constraint while using a signature */
2310 int* noccurlistentries, /**< arrray with number of constraints for each variable in the occurlist */
2343 findShortestOccurlist(vars, consdata->nvars, varstopos, occurlist, noccurlistentries, occurlistlength, &nentries, &shortestlist);
2447 int* noccurlistentries, /**< arrray with number of constraints for each variable in the occurlist */
2480 assert(SCIPvarIsActive(var) || (SCIPvarGetNegatedVar(var) != NULL && SCIPvarIsActive(SCIPvarGetNegatedVar(var))));
2496 SCIP_CALL( SCIPallocBufferArray(scip, &(occurlist[pos]), occurlistsizes[pos]) ); /*lint !e866*/
2524 SCIP_CALL( SCIPreallocBufferArray(scip, &(occurlist[pos]), occurlistsizes[pos]) ); /*lint !e866*/
2537/** run a pairwise comparison for the given variables against all constraits to detect redundant non-zeros in these
2599 findShortestOccurlist(vars, nvars, varstopos, occurlist, noccurlistentries, occurlistlength, &nentries, &shortestlist);
2693 /* cons1 is might be covered by the changed constraints cons, meaning that we might remove the artvar from
2700 /* if the artificial variable was not yet found, search over the rear variables in constraint cons1 */
2723 SCIPdebugMsg(scip, "variable %s in logicor constraint <%s> is redundant and will be removed (used constraint %s)\n",
2754 SCIPdebugMsg(scip, "logicor constraint <%s> is redundant due to constraint <%s> after removing variable <%s>\n",
2851 /* @todo: improve this algorithm by using the information that a constraint variables does not appaer in any
2852 * other constraint, which means that only this variable needs to be negated to check for redundant
2856 SCIP_CALL( removeRedundantNonZeros(scip, cons, artvar, v, varstopos, occurlist, noccurlistentries,
2881 unsigned char** entries, /**< array to store whether two positions in constraints represent the same variable */
2913 /* remove all variables that are fixed to zero, check redundancy due to fixed-to-one variable */
2970 * @see "Effective Preprocessing in SAT through Variable and Clause Elimination" by Niklas En and Armin Biere
2977 unsigned char** entries, /**< array to store whether two positions in constraints represent the same
2981 SCIP_Bool usestrengthening, /**< should we try to strengthen constraints by removing superflous
3022 SCIPdebugMsg(scip, "starting removeRedundantConssAndNonzeros(), pairwise comparison to detect covered logicor constraints\n");
3046 SCIP_CALL( prepareCons(scip, cons, eventhdlr, entries, nentries, &redundant, nfixedvars, nchgcoefs, ndelconss, cutoff) );
3080 /* we can stop if strengthening is disabled and all constraints have the same amount of variables */
3081 if( !usestrengthening && SCIPconsGetData(myconss[0])->nvars == SCIPconsGetData(myconss[nmyconss - 1])->nvars )
3088 /* @note: in the following we have at least number of nonzeros in logicor constraints + three times two the number of
3089 * binary variables memory consumption + a map for variables to positions, we need this to get a column base
3120 /* determine all constraints with the maximal number of variables and add them to the column representation */
3130 SCIP_CALL( addConsToOccurList(scip, cons, varstopos, occurlist, noccurlistentries, occurlistsizes, &occurlistlength, occurlistsize) );
3167 SCIP_CALL( removeRedundantConss(scip, cons, varstopos, occurlist, noccurlistentries, occurlistlength, ndelconss) );
3175 SCIP_CALL( addConsToOccurList(scip, cons, varstopos, occurlist, noccurlistentries, occurlistsizes, &occurlistlength, occurlistsize) );
3195 SCIP_CALL( strengthenConss(scip, myconss, nmyconss, varstopos, occurlist, noccurlistentries, occurlistlength, eventhdlr, ndelconss, nchgcoefs) );
3216/** try to tighten constraints by reducing the number of variables in the constraints using implications and cliques,
3226 unsigned char** entries, /**< array to store whether two positions in constraints represent the same
3289 /* prepare constraint by removing fixings and merge it; we invalidate the presolved flag, because the calls to
3290 * SCIPcleanupCliques() in this loop may have lead to fixed variables that are not yet removed */
3292 SCIP_CALL( prepareCons(scip, cons, eventhdlr, entries, nentries, &redundant, nfixedvars, nchgcoefs, ndelconss, cutoff) );
3314 assert(SCIPvarIsActive(var) || (SCIPvarGetStatus(var) == SCIP_VARSTATUS_NEGATED && SCIPvarIsActive(SCIPvarGetNegationVar(var))));
3335 /* use implications and cliques to derive global fixings and to shrink the number of variables in this constraints */
3336 SCIP_CALL( SCIPshrinkDisjunctiveVarSet(scip, probvars, bounds, boundtypes, redundants, consdata->nvars, &nredvars,
3392 /* invalidate the presolved flags, because the calls to SCIPcleanupCliques() may have lead to fixed variables that
3419/** try to find a negated clique in a constraint which makes this constraint redundant but we need to keep the negated
3430 unsigned char** entries, /**< array to store whether two positions in constraints represent the same
3471 if( SCIPgetNCliques(scip) == conshdlrdata->nlastcliquesneg && SCIPgetNImplications(scip) == conshdlrdata->nlastimplsneg )
3500 SCIP_CALL( prepareCons(scip, cons, eventhdlr, entries, nentries, &redundant, nfixedvars, nchgcoefs, ndelconss, cutoff) );
3528 /* all variables should be active or negative active variables, otherwise something went wrong with applyFixings()
3533 assert(SCIPvarIsActive(repvars[v]) || (SCIPvarGetStatus(repvars[v]) == SCIP_VARSTATUS_NEGATED && SCIPvarIsActive(SCIPvarGetNegationVar(repvars[v]))));
3600 SCIPdebugMsg(scip, "logicor constraint <%s> is redundant, because variable <%s> and its negation <%s> exist\n",
3612 SCIPdebugMsg(scip, "in logicor constraint <%s>, active variable of <%s> and active variable of <%s> are the same, removing the first\n",
3619 /* delCoefPos replaces the variable on position v with the last one, so w also need to correct the
3620 * negated array the same way, and because of deletion the number of variables is already decreased
3635 /* this negated clique information could be created out of this logicor constraint even if there are more
3636 * than two variables left (, for example by probing), we need to keep this information by creating a
3662 SCIPdebugMsg(scip, "logicor constraint <%s> is redundant due to negated clique information and will be replaced by a setppc constraint \n",
3664 SCIPdebugMsg(scip, "variable <%s> and variable <%s> are in a negated clique\n", SCIPvarGetName(consdata->vars[v]), SCIPvarGetName(consdata->vars[w]));
3694 * in case a constraint has two variables left, we will add the implication and upgrade it to a set-packing constraint
3735 /* if an unmodifiable logicor constraint has only two variables, we can add an implication and we will upgrade this
3749 /* a two-variable logicor constraint x + y >= 1 yields the implication x == 0 -> y == 1, and is represented
3752 SCIP_CALL( SCIPaddClique(scip, consdata->vars, values, consdata->nvars, FALSE, &implinfeasible, &nimplbdchgs) );
3760 /* adding the above implication could lead to fixings, which render the constraint redundant */
3765 /* remove all variables that are fixed to zero, check redundancy due to fixed-to-one variable */
3803 SCIPdebugMsg(scip, "logicor constraint <%s> was upgraded to a set-packing constraint\n", SCIPconsGetName(cons));
3811 * if unmodifiable constraint has only one variable, this one can be fixed and the constraint deleted
3851 SCIPdebugMsg(scip, " -> variable is multi-aggregated, upgrade to linear constraint <%s> == 1 \n",
3855 (void) SCIPsnprintf(consname, SCIP_MAXSTRLEN, "fixmaggr_%s_%s", SCIPconsGetName(cons),SCIPvarGetName(consdata->vars[0]) );
3856 SCIP_CALL( SCIPcreateConsLinear(scip, &conslinear, consname, 1, consdata->vars, &coef, 1.0, 1.0,
3908 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
3910 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
3939 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode) );
3960 * - logic or constraints have left hand side of +1.0, and right hand side of +infinity: x(S) >= 1.0
3963 if( nvars > 2 && nposbin + nnegbin + nposimplbin + nnegimplbin == nvars && ncoeffspone + ncoeffsnone == nvars
3969 SCIPdebugMsg(scip, "upgrading constraint <%s> to logic or constraint\n", SCIPconsGetName(cons));
3971 /* check, if we have to multiply with -1 (negate the positive vars) or with +1 (negate the negative vars) */
3974 /* create the logic or constraint (an automatically upgraded constraint is always unmodifiable) */
3976 SCIP_CALL( createNormalizedLogicor(scip, upgdcons, SCIPconsGetName(cons), nvars, vars, vals, mult,
4009 SCIPdebugMsg(scip, "Enforcing %d logic or constraints for %s solution\n", nconss, sol == NULL ? "LP" : "relaxation");
4023 SCIP_CALL( separateCons(scip, conss[c], sol, conshdlrdata->eventhdlr, &cutoff, &separated, &reduceddom) );
4029 SCIP_CALL( separateCons(scip, conss[c], sol, conshdlrdata->eventhdlr, &cutoff, &separated, &reduceddom) );
4084 SCIP_CALL( SCIPgetSymActiveVariables(scip, symtype, &vars, &vals, &nlocvars, &constant, SCIPisTransformed(scip)) );
4115/** destructor of constraint handler to free constraint handler data (called when SCIP is exiting) */
4137/** presolving initialization method of constraint handler (called when presolving is about to begin) */
4163 SCIP_CALL( SCIPcatchVarEvent(scip, consdata->vars[v], SCIP_EVENTTYPE_VARFIXED, conshdlrdata->eventhdlr,
4170/** presolving deinitialization method of constraint handler (called after presolving has been finished) */
4192 SCIP_CALL( SCIPdropVarEvent(scip, consdata->vars[v], SCIP_EVENTTYPE_VARFIXED, conshdlrdata->eventhdlr,
4201 SCIP_CALL( applyFixings(scip, conss[c], conshdlrdata->eventhdlr, &redundant, &nchgcoefs, NULL, NULL) );
4203 /* it may happen that a constraint still contains variables that are fixed to one; for example, this happens
4204 * when variable fixings have been detected in the last presolving round by some other plugins (see #2941)
4208 SCIPdebugMsg(scip, "logic or constraint <%s> is redundant (detected during EXITPRE)\n", SCIPconsGetName(conss[c]));
4216 /* we set the presolved flag to FALSE since not all fixing are removed if redundancy is detected */
4243/** solving process deinitialization method of constraint handler (called before branch and bound process data is freed) */
4280 if( SCIPgetStage(scip) == SCIP_STAGE_PRESOLVING || SCIPgetStage(scip) == SCIP_STAGE_INITPRESOLVE )
4290 SCIP_CALL( SCIPdropVarEvent(scip, (*consdata)->vars[v], SCIP_EVENTTYPE_VARFIXED, conshdlrdata->eventhdlr,
4326 SCIPconsIsInitial(sourcecons), SCIPconsIsSeparated(sourcecons), SCIPconsIsEnforced(sourcecons),
4329 SCIPconsIsDynamic(sourcecons), SCIPconsIsRemovable(sourcecons), SCIPconsIsStickingAtNode(sourcecons)) );
4335/** LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved) */
4380 SCIP_CALL( separateCons(scip, conss[c], NULL, conshdlrdata->eventhdlr, &cutoff, &separated, &reduceddom) );
4427 SCIP_CALL( separateCons(scip, conss[c], sol, conshdlrdata->eventhdlr, &cutoff, &separated, &reduceddom) );
4498 SCIP_CALL( enforcePseudo(scip, conss[c], conshdlrdata->eventhdlr, &cutoff, &infeasible, &reduceddom, &solvelp) );
4596 SCIP_CALL( processWatchedVars(scip, conss[c], conshdlrdata->eventhdlr, &cutoff, &reduceddom, &addcut, &mustcheck) );
4669 /* remove all variables that are fixed to zero, check redundancy due to fixed-to-one variable */
4670 SCIP_CALL( applyFixings(scip, cons, conshdlrdata->eventhdlr, &redundant, nchgcoefs, naddconss, ndelconss) );
4677 /* find sets of equal variables in constraint: multiple entries of variable can be replaced by single entry */
4680 SCIP_CALL( mergeMultiples(scip, cons, conshdlrdata->eventhdlr, &entries, &nentries, &redundant, nchgcoefs) );
4698 SCIP_CALL( fixDeleteOrUpgradeCons(scip, cons, conshdlrdata->eventhdlr, conshdlrdata->conshdlrlinear,
4699 conshdlrdata->conshdlrsetppc, nfixedvars, nchgbds, nchgcoefs, ndelconss, naddconss, nupgdconss, &cutoff) );
4718 SCIP_CALL( dualPresolving(scip, cons, conshdlrdata->eventhdlr, nfixedvars, ndelconss, nchgcoefs, naggrvars, result) );
4724 /* in dualpresolving we may have removed variables, so we need to take care of special cases */
4730 SCIP_CALL( fixDeleteOrUpgradeCons(scip, cons, conshdlrdata->eventhdlr, conshdlrdata->conshdlrlinear,
4731 conshdlrdata->conshdlrsetppc, nfixedvars, nchgbds, nchgcoefs, ndelconss, naddconss, nupgdconss, &cutoff) );
4759 /* detect redundant constraints; fast version with hash table instead of pairwise comparison */
4760 SCIP_CALL( detectRedundantConstraints(scip, SCIPblkmem(scip), conss, nconss, &firstchange, ndelconss) );
4771 SCIP_CALL( removeRedundantConssAndNonzeros(scip, conss, nconss, &entries, &nentries, conshdlrdata->eventhdlr,
4783 /* try to tighten constraints by reducing the number of variables in the constraints using implications and
4843 /* the only deductions are variables inferred to 1.0 on logic or constraints where all other variables
4846 assert(SCIPgetVarLbAtIndex(scip, infervar, bdchgidx, TRUE) > 0.5); /* the inference variable must be assigned to one */
4913 SCIPdebugMsg(scip, "activating information for logic or constraint <%s>\n", SCIPconsGetName(cons));
4920 SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED, conshdlrdata->eventhdlr, (SCIP_EVENTDATA*)cons,
4926 SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED, conshdlrdata->eventhdlr, (SCIP_EVENTDATA*)cons,
4957 SCIPdebugMsg(scip, "deactivating information for logic or constraint <%s>\n", SCIPconsGetName(cons));
4965 SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED, conshdlrdata->eventhdlr, (SCIP_EVENTDATA*)cons,
4974 SCIP_EVENTTYPE_UBTIGHTENED | SCIP_EVENTTYPE_LBRELAXED, conshdlrdata->eventhdlr, (SCIP_EVENTDATA*)cons,
5025 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, global, valid) );
5071 /* copy string for parsing; note that SCIPskipSpace() in SCIPparseVarsList() requires that strcopy ends with '\0' */
5081 SCIP_CALL( SCIPparseVarsList(scip, strcopy, vars, &nvars, varssize, &requiredsize, &endptr, ',', success) );
5093 SCIP_CALL( SCIPparseVarsList(scip, strcopy, vars, &nvars, varssize, &requiredsize, &endptr, ',', success) );
5101 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode) );
5118 initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode) );
5148/** constraint method of constraint handler which returns the number of variables (if possible) */
5163/** constraint handler method which returns the permutation symmetry detection graph of a constraint */
5172/** constraint handler method which returns the signed permutation symmetry detection graph of a constraint */
5197 SCIPdebugMsg(scip, "enabling constraint cons <%s> at depth %d\n", SCIPconsGetName((SCIP_CONS*)eventdata), SCIPgetDepth(scip));
5265 /* if the conflict consists of only two (binary) variables, it will be handled by the setppc conflict handler */
5297 (void) SCIPsnprintf(consname, SCIP_MAXSTRLEN, "cf%d_%" SCIP_LONGINT_FORMAT, SCIPgetNRuns(scip), SCIPgetNConflictConssApplied(scip));
5333 SCIP_CALL( SCIPincludeConflicthdlrBasic(scip, &conflicthdlr, CONFLICTHDLR_NAME, CONFLICTHDLR_DESC, CONFLICTHDLR_PRIORITY,
5360 SCIP_CALL( SCIPsetConshdlrPresol(scip, conshdlr, consPresolLogicor,CONSHDLR_MAXPREROUNDS, CONSHDLR_PRESOLTIMING) );
5362 SCIP_CALL( SCIPsetConshdlrProp(scip, conshdlr, consPropLogicor, CONSHDLR_PROPFREQ, CONSHDLR_DELAYPROP,
5365 SCIP_CALL( SCIPsetConshdlrSepa(scip, conshdlr, consSepalpLogicor, consSepasolLogicor, CONSHDLR_SEPAFREQ,
5370 SCIP_CALL( SCIPsetConshdlrGetSignedPermsymGraph(scip, conshdlr, consGetSignedPermsymGraphLogicor) );
5377 /* include the linear constraint to logicor constraint upgrade in the linear constraint handler */
5378 SCIP_CALL( SCIPincludeLinconsUpgrade(scip, linconsUpgdLogicor, LINCONSUPGD_PRIORITY, CONSHDLR_NAME) );
5404 "should pairwise constraint comparison try to strengthen constraints by removing superflous non-zeros?",
5413 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
5439 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
5441 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
<