java.lang.Object

com.google.protobuf.AbstractMessageLite.Builder

com.google.protobuf.AbstractMessage.Builder<BuilderType>

com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>

com.google.ortools.sat.SatParameters.Builder

All Implemented Interfaces:: SatParametersOrBuilder, com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, java.lang.Cloneable

Enclosing class:: SatParameters

public static final class SatParameters.Builder
extends com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
implements SatParametersOrBuilder

 Contains the definitions for all the sat algorithm parameters and their
 default values.
 NEXT TAG: 188

Protobuf type operations_research.sat.SatParameters

Method Summary

Modifier and Type	Method	Description
`SatParameters.Builder`	`addAllRestartAlgorithms(java.lang.Iterable<? extends SatParameters.RestartAlgorithm> values)`	The restart strategies will change each time the strategy_counter is increased.
`SatParameters.Builder`	`addRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)`
`SatParameters.Builder`	`addRestartAlgorithms(SatParameters.RestartAlgorithm value)`	The restart strategies will change each time the strategy_counter is increased.
`SatParameters`	`build()`
`SatParameters`	`buildPartial()`
`SatParameters.Builder`	`clear()`
`SatParameters.Builder`	`clearAbsoluteGapLimit()`	Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit.
`SatParameters.Builder`	`clearAddCgCuts()`	Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
`SatParameters.Builder`	`clearAddCliqueCuts()`	Whether we generate clique cuts from the binary implication graph.
`SatParameters.Builder`	`clearAddKnapsackCuts()`	Whether we generate knapsack cuts.
`SatParameters.Builder`	`clearAddLinMaxCuts()`	For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et.
`SatParameters.Builder`	`clearAddLpConstraintsLazily()`	If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch.
`SatParameters.Builder`	`clearAddMirCuts()`	Whether we generate MIR cuts at root node.
`SatParameters.Builder`	`clearAddZeroHalfCuts()`	Whether we generate Zero-Half cuts at root node.
`SatParameters.Builder`	`clearAlsoBumpVariablesInConflictReasons()`	When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped.
`SatParameters.Builder`	`clearAutoDetectGreaterThanAtLeastOneOf()`	If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present.
`SatParameters.Builder`	`clearBinaryMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];`
`SatParameters.Builder`	`clearBinarySearchNumConflicts()`	If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict.
`SatParameters.Builder`	`clearBlockingRestartMultiplier()`	`optional double blocking_restart_multiplier = 66 [default = 1.4];`
`SatParameters.Builder`	`clearBlockingRestartWindowSize()`	`optional int32 blocking_restart_window_size = 65 [default = 5000];`
`SatParameters.Builder`	`clearBooleanEncodingLevel()`	A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
`SatParameters.Builder`	`clearCatchSigintSignal()`	Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve.
`SatParameters.Builder`	`clearClauseActivityDecay()`	Clause activity parameters (same effect as the one on the variables).
`SatParameters.Builder`	`clearClauseCleanupLbdBound()`	All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
`SatParameters.Builder`	`clearClauseCleanupOrdering()`	`optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];`
`SatParameters.Builder`	`clearClauseCleanupPeriod()`	Trigger a cleanup when this number of "deletable" clauses is learned.
`SatParameters.Builder`	`clearClauseCleanupProtection()`	`optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];`
`SatParameters.Builder`	`clearClauseCleanupTarget()`	During a cleanup, we will always keep that number of "deletable" clauses.
`SatParameters.Builder`	`clearConvertIntervals()`	Temporary flag util the feature is more mature.
`SatParameters.Builder`	`clearCountAssumptionLevelsInLbd()`	Whether or not the assumption levels are taken into account during the LBD computation.
`SatParameters.Builder`	`clearCoverOptimization()`	If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
`SatParameters.Builder`	`clearCpModelMaxNumPresolveOperations()`	If positive, try to stop just after that many presolve rules have been applied.
`SatParameters.Builder`	`clearCpModelPostsolveWithFullSolver()`	Advanced usage.
`SatParameters.Builder`	`clearCpModelPresolve()`	Whether we presolve the cp_model before solving it.
`SatParameters.Builder`	`clearCpModelProbingLevel()`	How much effort do we spend on probing.
`SatParameters.Builder`	`clearCpModelUseSatPresolve()`	Whether we also use the sat presolve when cp_model_presolve is true.
`SatParameters.Builder`	`clearCutActiveCountDecay()`	`optional double cut_active_count_decay = 156 [default = 0.8];`
`SatParameters.Builder`	`clearCutCleanupTarget()`	Target number of constraints to remove during cleanup.
`SatParameters.Builder`	`clearCutMaxActiveCountValue()`	These parameters are similar to sat clause management activity parameters.
`SatParameters.Builder`	`clearDefaultRestartAlgorithms()`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`SatParameters.Builder`	`clearDisableConstraintExpansion()`	If true, it disable all constraint expansion.
`SatParameters.Builder`	`clearDiversifyLnsParams()`	If true, registers more lns subsolvers with different parameters.
`SatParameters.Builder`	`clearEnumerateAllSolutions()`	Whether we enumerate all solutions of a problem without objective.
`SatParameters.Builder`	`clearExpandAlldiffConstraints()`	If true, expand all_different constraints that are not permutations.
`SatParameters.Builder`	`clearExpandAutomatonConstraints()`	If true, the automaton constraints are expanded.
`SatParameters.Builder`	`clearExpandElementConstraints()`	If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
`SatParameters.Builder`	`clearExpandReservoirConstraints()`	If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`SatParameters.Builder`	`clearExpandTableConstraints()`	If true, the positive table constraints are expanded.
`SatParameters.Builder`	`clearExploitAllLpSolution()`	If true and the Lp relaxation of the problem has a solution, try to exploit it.
`SatParameters.Builder`	`clearExploitBestSolution()`	When branching on a variable, follow the last best solution value.
`SatParameters.Builder`	`clearExploitIntegerLpSolution()`	If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it.
`SatParameters.Builder`	`clearExploitObjective()`	When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
`SatParameters.Builder`	`clearExploitRelaxationSolution()`	When branching on a variable, follow the last best relaxation solution value.
`SatParameters.Builder`	`clearField(com.google.protobuf.Descriptors.FieldDescriptor field)`
`SatParameters.Builder`	`clearFillTightenedDomainsInResponse()`	If true, add information about the derived variable domains to the CpSolverResponse.
`SatParameters.Builder`	`clearFindMultipleCores()`	Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`SatParameters.Builder`	`clearFpRounding()`	`optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];`
`SatParameters.Builder`	`clearGlucoseDecayIncrement()`	`optional double glucose_decay_increment = 23 [default = 0.01];`
`SatParameters.Builder`	`clearGlucoseDecayIncrementPeriod()`	`optional int32 glucose_decay_increment_period = 24 [default = 5000];`
`SatParameters.Builder`	`clearGlucoseMaxDecay()`	The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95.
`SatParameters.Builder`	`clearHintConflictLimit()`	Conflict limit used in the phase that exploit the solution hint.
`SatParameters.Builder`	`clearInitialPolarity()`	`optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`SatParameters.Builder`	`clearInitialVariablesActivity()`	The initial value of the variables activity.
`SatParameters.Builder`	`clearInstantiateAllVariables()`	If true, the solver will add a default integer branching strategy to the already defined search strategy.
`SatParameters.Builder`	`clearInterleaveBatchSize()`	`optional int32 interleave_batch_size = 134 [default = 1];`
`SatParameters.Builder`	`clearInterleaveSearch()`	Experimental.
`SatParameters.Builder`	`clearKeepAllFeasibleSolutionsInPresolve()`	If true, we disable the presolve reductions that remove feasible solutions from the search space.
`SatParameters.Builder`	`clearLinearizationLevel()`	A non-negative level indicating the type of constraints we consider in the LP relaxation.
`SatParameters.Builder`	`clearLnsExpandIntervalsInConstraintGraph()`	`optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];`
`SatParameters.Builder`	`clearLnsFocusOnDecisionVariables()`	`optional bool lns_focus_on_decision_variables = 105 [default = false];`
`SatParameters.Builder`	`clearLogPrefix()`	Add a prefix to all logs.
`SatParameters.Builder`	`clearLogSearchProgress()`	Whether the solver should log the search progress.
`SatParameters.Builder`	`clearLogToResponse()`	Log to response proto.
`SatParameters.Builder`	`clearLogToStdout()`	Log to stdout.
`SatParameters.Builder`	`clearMaxAllDiffCutSize()`	Cut generator for all diffs can add too many cuts for large all_diff constraints.
`SatParameters.Builder`	`clearMaxClauseActivityValue()`	`optional double max_clause_activity_value = 18 [default = 1e+20];`
`SatParameters.Builder`	`clearMaxConsecutiveInactiveCount()`	If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP.
`SatParameters.Builder`	`clearMaxCutRoundsAtLevelZero()`	Max number of time we perform cut generation and resolve the LP at level 0.
`SatParameters.Builder`	`clearMaxDeterministicTime()`	Maximum time allowed in deterministic time to solve a problem.
`SatParameters.Builder`	`clearMaxIntegerRoundingScaling()`	In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`SatParameters.Builder`	`clearMaxMemoryInMb()`	Maximum memory allowed for the whole thread containing the solver.
`SatParameters.Builder`	`clearMaxNumberOfConflicts()`	Maximum number of conflicts allowed to solve a problem.
`SatParameters.Builder`	`clearMaxNumCuts()`	The limit on the number of cuts in our cut pool.
`SatParameters.Builder`	`clearMaxPresolveIterations()`	In case of large reduction in a presolve iteration, we perform multiple presolve iterations.
`SatParameters.Builder`	`clearMaxSatAssumptionOrder()`	`optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];`
`SatParameters.Builder`	`clearMaxSatReverseAssumptionOrder()`	If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
`SatParameters.Builder`	`clearMaxSatStratification()`	`optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];`
`SatParameters.Builder`	`clearMaxTimeInSeconds()`	Maximum time allowed in seconds to solve a problem.
`SatParameters.Builder`	`clearMaxVariableActivityValue()`	`optional double max_variable_activity_value = 16 [default = 1e+100];`
`SatParameters.Builder`	`clearMergeAtMostOneWorkLimit()`	`optional double merge_at_most_one_work_limit = 146 [default = 100000000];`
`SatParameters.Builder`	`clearMergeNoOverlapWorkLimit()`	During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints.
`SatParameters.Builder`	`clearMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];`
`SatParameters.Builder`	`clearMinimizeCore()`	Whether we use a simple heuristic to try to minimize an UNSAT core.
`SatParameters.Builder`	`clearMinimizeReductionDuringPbResolution()`	A different algorithm during PB resolution.
`SatParameters.Builder`	`clearMinimizeWithPropagationNumDecisions()`	`optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];`
`SatParameters.Builder`	`clearMinimizeWithPropagationRestartPeriod()`	Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization.
`SatParameters.Builder`	`clearMinOrthogonalityForLpConstraints()`	While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call.
`SatParameters.Builder`	`clearMipAutomaticallyScaleVariables()`	If true, some continuous variable might be automatially scaled.
`SatParameters.Builder`	`clearMipCheckPrecision()`	As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`SatParameters.Builder`	`clearMipMaxActivityExponent()`	To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power.
`SatParameters.Builder`	`clearMipMaxBound()`	We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use.
`SatParameters.Builder`	`clearMipVarScaling()`	All continuous variable of the problem will be multiplied by this factor.
`SatParameters.Builder`	`clearMipWantedPrecision()`	When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients.
`SatParameters.Builder`	`clearName()`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`SatParameters.Builder`	`clearNewConstraintsBatchSize()`	Add that many lazy constraints (or cuts) at once in the LP.
`SatParameters.Builder`	`clearNumConflictsBeforeStrategyChanges()`	After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
`SatParameters.Builder`	`clearNumSearchWorkers()`	Specify the number of parallel workers to use during search.
`SatParameters.Builder`	`clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof)`
`SatParameters.Builder`	`clearOnlyAddCutsAtLevelZero()`	For the cut that can be generated at any level, this control if we only try to generate them at the root node.
`SatParameters.Builder`	`clearOptimizeWithCore()`	The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`SatParameters.Builder`	`clearOptimizeWithMaxHs()`	This has no effect if optimize_with_core is false.
`SatParameters.Builder`	`clearPbCleanupIncrement()`	Same as for the clauses, but for the learned pseudo-Boolean constraints.
`SatParameters.Builder`	`clearPbCleanupRatio()`	`optional double pb_cleanup_ratio = 47 [default = 0.5];`
`SatParameters.Builder`	`clearPermutePresolveConstraintOrder()`	`optional bool permute_presolve_constraint_order = 179 [default = false];`
`SatParameters.Builder`	`clearPermuteVariableRandomly()`	This is mainly here to test the solver variability.
`SatParameters.Builder`	`clearPolarityRephaseIncrement()`	If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion.
`SatParameters.Builder`	`clearPolishLpSolution()`	Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis.
`SatParameters.Builder`	`clearPreferredVariableOrder()`	`optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];`
`SatParameters.Builder`	`clearPresolveBlockedClause()`	Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
`SatParameters.Builder`	`clearPresolveBvaThreshold()`	Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold.
`SatParameters.Builder`	`clearPresolveBveClauseWeight()`	During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
`SatParameters.Builder`	`clearPresolveBveThreshold()`	During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
`SatParameters.Builder`	`clearPresolveExtractIntegerEnforcement()`	If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint".
`SatParameters.Builder`	`clearPresolveProbingDeterministicTimeLimit()`	The maximum "deterministic" time limit to spend in probing.
`SatParameters.Builder`	`clearPresolveSubstitutionLevel()`	How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve.
`SatParameters.Builder`	`clearPresolveUseBva()`	Whether or not we use Bounded Variable Addition (BVA) in the presolve.
`SatParameters.Builder`	`clearProbingPeriodAtRoot()`	If set at zero (the default), it is disabled.
`SatParameters.Builder`	`clearPseudoCostReliabilityThreshold()`	The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`SatParameters.Builder`	`clearRandomBranchesRatio()`	A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
`SatParameters.Builder`	`clearRandomizeSearch()`	Randomize fixed search.
`SatParameters.Builder`	`clearRandomPolarityRatio()`	The proportion of polarity chosen at random.
`SatParameters.Builder`	`clearRandomSeed()`	At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed.
`SatParameters.Builder`	`clearReduceMemoryUsageInInterleaveMode()`	Temporary parameter until the memory usage is more optimized.
`SatParameters.Builder`	`clearRelativeGapLimit()`	`optional double relative_gap_limit = 160 [default = 0];`
`SatParameters.Builder`	`clearRepairHint()`	If true, the solver tries to repair the solution given in the hint.
`SatParameters.Builder`	`clearRestartAlgorithms()`	The restart strategies will change each time the strategy_counter is increased.
`SatParameters.Builder`	`clearRestartDlAverageRatio()`	In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
`SatParameters.Builder`	`clearRestartLbdAverageRatio()`	`optional double restart_lbd_average_ratio = 71 [default = 1];`
`SatParameters.Builder`	`clearRestartPeriod()`	Restart period for the FIXED_RESTART strategy.
`SatParameters.Builder`	`clearRestartRunningWindowSize()`	Size of the window for the moving average restarts.
`SatParameters.Builder`	`clearSearchBranching()`	`optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`SatParameters.Builder`	`clearSearchRandomizationTolerance()`	Search randomization will collect equivalent 'max valued' variables, and pick one randomly.
`SatParameters.Builder`	`clearShareLevelZeroBounds()`	Allows sharing of the bounds of modified variables at level 0.
`SatParameters.Builder`	`clearShareObjectiveBounds()`	Allows objective sharing between workers.
`SatParameters.Builder`	`clearStopAfterFirstSolution()`	For an optimization problem, stop the solver as soon as we have a solution.
`SatParameters.Builder`	`clearStopAfterPresolve()`	Mainly used when improving the presolver.
`SatParameters.Builder`	`clearStrategyChangeIncreaseRatio()`	The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`SatParameters.Builder`	`clearSubsumptionDuringConflictAnalysis()`	At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict.
`SatParameters.Builder`	`clearSymmetryLevel()`	Whether we try to automatically detect the symmetries in a model and exploit them.
`SatParameters.Builder`	`clearTreatBinaryClausesSeparately()`	If true, the binary clauses are treated separately from the others.
`SatParameters.Builder`	`clearUseAbslRandom()`	`optional bool use_absl_random = 180 [default = false];`
`SatParameters.Builder`	`clearUseBlockingRestart()`	Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
`SatParameters.Builder`	`clearUseBranchingInLp()`	If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
`SatParameters.Builder`	`clearUseCombinedNoOverlap()`	This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem.
`SatParameters.Builder`	`clearUseDisjunctiveConstraintInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem.
`SatParameters.Builder`	`clearUseErwaHeuristic()`	Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V.
`SatParameters.Builder`	`clearUseExactLpReason()`	The solver usually exploit the LP relaxation of a model.
`SatParameters.Builder`	`clearUseFeasibilityPump()`	Adds a feasibility pump subsolver along with lns subsolvers.
`SatParameters.Builder`	`clearUseImpliedBounds()`	Stores and exploits "implied-bounds" in the solver.
`SatParameters.Builder`	`clearUseLnsOnly()`	LNS parameters.
`SatParameters.Builder`	`clearUseOptimizationHints()`	For an optimization problem, whether we follow some hints in order to find a better first solution.
`SatParameters.Builder`	`clearUseOptionalVariables()`	If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional.
`SatParameters.Builder`	`clearUseOverloadCheckerInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy.
`SatParameters.Builder`	`clearUsePbResolution()`	Whether to use pseudo-Boolean resolution to analyze a conflict.
`SatParameters.Builder`	`clearUsePhaseSaving()`	If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic().
`SatParameters.Builder`	`clearUsePrecedencesInDisjunctiveConstraint()`	When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further.
`SatParameters.Builder`	`clearUseProbingSearch()`	If true, search will continuously probe Boolean variables, and integer variable bounds.
`SatParameters.Builder`	`clearUseRelaxationLns()`	Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
`SatParameters.Builder`	`clearUseRinsLns()`	Turns on relaxation induced neighborhood generator.
`SatParameters.Builder`	`clearUseSatInprocessing()`	`optional bool use_sat_inprocessing = 163 [default = false];`
`SatParameters.Builder`	`clearUseTimetableEdgeFindingInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts.
`SatParameters.Builder`	`clearVariableActivityDecay()`	Each time a conflict is found, the activities of some variables are increased by one.
`SatParameters.Builder`	`clone()`
`double`	`getAbsoluteGapLimit()`	Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit.
`boolean`	`getAddCgCuts()`	Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
`boolean`	`getAddCliqueCuts()`	Whether we generate clique cuts from the binary implication graph.
`boolean`	`getAddKnapsackCuts()`	Whether we generate knapsack cuts.
`boolean`	`getAddLinMaxCuts()`	For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et.
`boolean`	`getAddLpConstraintsLazily()`	If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch.
`boolean`	`getAddMirCuts()`	Whether we generate MIR cuts at root node.
`boolean`	`getAddZeroHalfCuts()`	Whether we generate Zero-Half cuts at root node.
`boolean`	`getAlsoBumpVariablesInConflictReasons()`	When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped.
`boolean`	`getAutoDetectGreaterThanAtLeastOneOf()`	If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present.
`SatParameters.BinaryMinizationAlgorithm`	`getBinaryMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];`
`int`	`getBinarySearchNumConflicts()`	If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict.
`double`	`getBlockingRestartMultiplier()`	`optional double blocking_restart_multiplier = 66 [default = 1.4];`
`int`	`getBlockingRestartWindowSize()`	`optional int32 blocking_restart_window_size = 65 [default = 5000];`
`int`	`getBooleanEncodingLevel()`	A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
`boolean`	`getCatchSigintSignal()`	Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve.
`double`	`getClauseActivityDecay()`	Clause activity parameters (same effect as the one on the variables).
`int`	`getClauseCleanupLbdBound()`	All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
`SatParameters.ClauseOrdering`	`getClauseCleanupOrdering()`	`optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];`
`int`	`getClauseCleanupPeriod()`	Trigger a cleanup when this number of "deletable" clauses is learned.
`SatParameters.ClauseProtection`	`getClauseCleanupProtection()`	`optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];`
`int`	`getClauseCleanupTarget()`	During a cleanup, we will always keep that number of "deletable" clauses.
`boolean`	`getConvertIntervals()`	Temporary flag util the feature is more mature.
`boolean`	`getCountAssumptionLevelsInLbd()`	Whether or not the assumption levels are taken into account during the LBD computation.
`boolean`	`getCoverOptimization()`	If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
`int`	`getCpModelMaxNumPresolveOperations()`	If positive, try to stop just after that many presolve rules have been applied.
`boolean`	`getCpModelPostsolveWithFullSolver()`	Advanced usage.
`boolean`	`getCpModelPresolve()`	Whether we presolve the cp_model before solving it.
`int`	`getCpModelProbingLevel()`	How much effort do we spend on probing.
`boolean`	`getCpModelUseSatPresolve()`	Whether we also use the sat presolve when cp_model_presolve is true.
`double`	`getCutActiveCountDecay()`	`optional double cut_active_count_decay = 156 [default = 0.8];`
`int`	`getCutCleanupTarget()`	Target number of constraints to remove during cleanup.
`double`	`getCutMaxActiveCountValue()`	These parameters are similar to sat clause management activity parameters.
`SatParameters`	`getDefaultInstanceForType()`
`java.lang.String`	`getDefaultRestartAlgorithms()`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`com.google.protobuf.ByteString`	`getDefaultRestartAlgorithmsBytes()`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`static com.google.protobuf.Descriptors.Descriptor`	`getDescriptor()`
`com.google.protobuf.Descriptors.Descriptor`	`getDescriptorForType()`
`boolean`	`getDisableConstraintExpansion()`	If true, it disable all constraint expansion.
`boolean`	`getDiversifyLnsParams()`	If true, registers more lns subsolvers with different parameters.
`boolean`	`getEnumerateAllSolutions()`	Whether we enumerate all solutions of a problem without objective.
`boolean`	`getExpandAlldiffConstraints()`	If true, expand all_different constraints that are not permutations.
`boolean`	`getExpandAutomatonConstraints()`	If true, the automaton constraints are expanded.
`boolean`	`getExpandElementConstraints()`	If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
`boolean`	`getExpandReservoirConstraints()`	If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`boolean`	`getExpandTableConstraints()`	If true, the positive table constraints are expanded.
`boolean`	`getExploitAllLpSolution()`	If true and the Lp relaxation of the problem has a solution, try to exploit it.
`boolean`	`getExploitBestSolution()`	When branching on a variable, follow the last best solution value.
`boolean`	`getExploitIntegerLpSolution()`	If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it.
`boolean`	`getExploitObjective()`	When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
`boolean`	`getExploitRelaxationSolution()`	When branching on a variable, follow the last best relaxation solution value.
`boolean`	`getFillTightenedDomainsInResponse()`	If true, add information about the derived variable domains to the CpSolverResponse.
`boolean`	`getFindMultipleCores()`	Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`SatParameters.FPRoundingMethod`	`getFpRounding()`	`optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];`
`double`	`getGlucoseDecayIncrement()`	`optional double glucose_decay_increment = 23 [default = 0.01];`
`int`	`getGlucoseDecayIncrementPeriod()`	`optional int32 glucose_decay_increment_period = 24 [default = 5000];`
`double`	`getGlucoseMaxDecay()`	The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95.
`int`	`getHintConflictLimit()`	Conflict limit used in the phase that exploit the solution hint.
`SatParameters.Polarity`	`getInitialPolarity()`	`optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`double`	`getInitialVariablesActivity()`	The initial value of the variables activity.
`boolean`	`getInstantiateAllVariables()`	If true, the solver will add a default integer branching strategy to the already defined search strategy.
`int`	`getInterleaveBatchSize()`	`optional int32 interleave_batch_size = 134 [default = 1];`
`boolean`	`getInterleaveSearch()`	Experimental.
`boolean`	`getKeepAllFeasibleSolutionsInPresolve()`	If true, we disable the presolve reductions that remove feasible solutions from the search space.
`int`	`getLinearizationLevel()`	A non-negative level indicating the type of constraints we consider in the LP relaxation.
`boolean`	`getLnsExpandIntervalsInConstraintGraph()`	`optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];`
`boolean`	`getLnsFocusOnDecisionVariables()`	`optional bool lns_focus_on_decision_variables = 105 [default = false];`
`java.lang.String`	`getLogPrefix()`	Add a prefix to all logs.
`com.google.protobuf.ByteString`	`getLogPrefixBytes()`	Add a prefix to all logs.
`boolean`	`getLogSearchProgress()`	Whether the solver should log the search progress.
`boolean`	`getLogToResponse()`	Log to response proto.
`boolean`	`getLogToStdout()`	Log to stdout.
`int`	`getMaxAllDiffCutSize()`	Cut generator for all diffs can add too many cuts for large all_diff constraints.
`double`	`getMaxClauseActivityValue()`	`optional double max_clause_activity_value = 18 [default = 1e+20];`
`int`	`getMaxConsecutiveInactiveCount()`	If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP.
`int`	`getMaxCutRoundsAtLevelZero()`	Max number of time we perform cut generation and resolve the LP at level 0.
`double`	`getMaxDeterministicTime()`	Maximum time allowed in deterministic time to solve a problem.
`int`	`getMaxIntegerRoundingScaling()`	In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`long`	`getMaxMemoryInMb()`	Maximum memory allowed for the whole thread containing the solver.
`long`	`getMaxNumberOfConflicts()`	Maximum number of conflicts allowed to solve a problem.
`int`	`getMaxNumCuts()`	The limit on the number of cuts in our cut pool.
`int`	`getMaxPresolveIterations()`	In case of large reduction in a presolve iteration, we perform multiple presolve iterations.
`SatParameters.MaxSatAssumptionOrder`	`getMaxSatAssumptionOrder()`	`optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];`
`boolean`	`getMaxSatReverseAssumptionOrder()`	If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
`SatParameters.MaxSatStratificationAlgorithm`	`getMaxSatStratification()`	`optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];`
`double`	`getMaxTimeInSeconds()`	Maximum time allowed in seconds to solve a problem.
`double`	`getMaxVariableActivityValue()`	`optional double max_variable_activity_value = 16 [default = 1e+100];`
`double`	`getMergeAtMostOneWorkLimit()`	`optional double merge_at_most_one_work_limit = 146 [default = 100000000];`
`double`	`getMergeNoOverlapWorkLimit()`	During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints.
`SatParameters.ConflictMinimizationAlgorithm`	`getMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];`
`boolean`	`getMinimizeCore()`	Whether we use a simple heuristic to try to minimize an UNSAT core.
`boolean`	`getMinimizeReductionDuringPbResolution()`	A different algorithm during PB resolution.
`int`	`getMinimizeWithPropagationNumDecisions()`	`optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];`
`int`	`getMinimizeWithPropagationRestartPeriod()`	Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization.
`double`	`getMinOrthogonalityForLpConstraints()`	While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call.
`boolean`	`getMipAutomaticallyScaleVariables()`	If true, some continuous variable might be automatially scaled.
`double`	`getMipCheckPrecision()`	As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`int`	`getMipMaxActivityExponent()`	To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power.
`double`	`getMipMaxBound()`	We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use.
`double`	`getMipVarScaling()`	All continuous variable of the problem will be multiplied by this factor.
`double`	`getMipWantedPrecision()`	When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients.
`java.lang.String`	`getName()`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`com.google.protobuf.ByteString`	`getNameBytes()`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`int`	`getNewConstraintsBatchSize()`	Add that many lazy constraints (or cuts) at once in the LP.
`int`	`getNumConflictsBeforeStrategyChanges()`	After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
`int`	`getNumSearchWorkers()`	Specify the number of parallel workers to use during search.
`boolean`	`getOnlyAddCutsAtLevelZero()`	For the cut that can be generated at any level, this control if we only try to generate them at the root node.
`boolean`	`getOptimizeWithCore()`	The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`boolean`	`getOptimizeWithMaxHs()`	This has no effect if optimize_with_core is false.
`int`	`getPbCleanupIncrement()`	Same as for the clauses, but for the learned pseudo-Boolean constraints.
`double`	`getPbCleanupRatio()`	`optional double pb_cleanup_ratio = 47 [default = 0.5];`
`boolean`	`getPermutePresolveConstraintOrder()`	`optional bool permute_presolve_constraint_order = 179 [default = false];`
`boolean`	`getPermuteVariableRandomly()`	This is mainly here to test the solver variability.
`int`	`getPolarityRephaseIncrement()`	If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion.
`boolean`	`getPolishLpSolution()`	Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis.
`SatParameters.VariableOrder`	`getPreferredVariableOrder()`	`optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];`
`boolean`	`getPresolveBlockedClause()`	Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
`int`	`getPresolveBvaThreshold()`	Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold.
`int`	`getPresolveBveClauseWeight()`	During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
`int`	`getPresolveBveThreshold()`	During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
`boolean`	`getPresolveExtractIntegerEnforcement()`	If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint".
`double`	`getPresolveProbingDeterministicTimeLimit()`	The maximum "deterministic" time limit to spend in probing.
`int`	`getPresolveSubstitutionLevel()`	How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve.
`boolean`	`getPresolveUseBva()`	Whether or not we use Bounded Variable Addition (BVA) in the presolve.
`long`	`getProbingPeriodAtRoot()`	If set at zero (the default), it is disabled.
`long`	`getPseudoCostReliabilityThreshold()`	The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`double`	`getRandomBranchesRatio()`	A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
`boolean`	`getRandomizeSearch()`	Randomize fixed search.
`double`	`getRandomPolarityRatio()`	The proportion of polarity chosen at random.
`int`	`getRandomSeed()`	At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed.
`boolean`	`getReduceMemoryUsageInInterleaveMode()`	Temporary parameter until the memory usage is more optimized.
`double`	`getRelativeGapLimit()`	`optional double relative_gap_limit = 160 [default = 0];`
`boolean`	`getRepairHint()`	If true, the solver tries to repair the solution given in the hint.
`SatParameters.RestartAlgorithm`	`getRestartAlgorithms(int index)`	The restart strategies will change each time the strategy_counter is increased.
`int`	`getRestartAlgorithmsCount()`	The restart strategies will change each time the strategy_counter is increased.
`java.util.List<SatParameters.RestartAlgorithm>`	`getRestartAlgorithmsList()`	The restart strategies will change each time the strategy_counter is increased.
`double`	`getRestartDlAverageRatio()`	In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
`double`	`getRestartLbdAverageRatio()`	`optional double restart_lbd_average_ratio = 71 [default = 1];`
`int`	`getRestartPeriod()`	Restart period for the FIXED_RESTART strategy.
`int`	`getRestartRunningWindowSize()`	Size of the window for the moving average restarts.
`SatParameters.SearchBranching`	`getSearchBranching()`	`optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`long`	`getSearchRandomizationTolerance()`	Search randomization will collect equivalent 'max valued' variables, and pick one randomly.
`boolean`	`getShareLevelZeroBounds()`	Allows sharing of the bounds of modified variables at level 0.
`boolean`	`getShareObjectiveBounds()`	Allows objective sharing between workers.
`boolean`	`getStopAfterFirstSolution()`	For an optimization problem, stop the solver as soon as we have a solution.
`boolean`	`getStopAfterPresolve()`	Mainly used when improving the presolver.
`double`	`getStrategyChangeIncreaseRatio()`	The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`boolean`	`getSubsumptionDuringConflictAnalysis()`	At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict.
`int`	`getSymmetryLevel()`	Whether we try to automatically detect the symmetries in a model and exploit them.
`boolean`	`getTreatBinaryClausesSeparately()`	If true, the binary clauses are treated separately from the others.
`boolean`	`getUseAbslRandom()`	`optional bool use_absl_random = 180 [default = false];`
`boolean`	`getUseBlockingRestart()`	Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
`boolean`	`getUseBranchingInLp()`	If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
`boolean`	`getUseCombinedNoOverlap()`	This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem.
`boolean`	`getUseDisjunctiveConstraintInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem.
`boolean`	`getUseErwaHeuristic()`	Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V.
`boolean`	`getUseExactLpReason()`	The solver usually exploit the LP relaxation of a model.
`boolean`	`getUseFeasibilityPump()`	Adds a feasibility pump subsolver along with lns subsolvers.
`boolean`	`getUseImpliedBounds()`	Stores and exploits "implied-bounds" in the solver.
`boolean`	`getUseLnsOnly()`	LNS parameters.
`boolean`	`getUseOptimizationHints()`	For an optimization problem, whether we follow some hints in order to find a better first solution.
`boolean`	`getUseOptionalVariables()`	If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional.
`boolean`	`getUseOverloadCheckerInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy.
`boolean`	`getUsePbResolution()`	Whether to use pseudo-Boolean resolution to analyze a conflict.
`boolean`	`getUsePhaseSaving()`	If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic().
`boolean`	`getUsePrecedencesInDisjunctiveConstraint()`	When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further.
`boolean`	`getUseProbingSearch()`	If true, search will continuously probe Boolean variables, and integer variable bounds.
`boolean`	`getUseRelaxationLns()`	Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
`boolean`	`getUseRinsLns()`	Turns on relaxation induced neighborhood generator.
`boolean`	`getUseSatInprocessing()`	`optional bool use_sat_inprocessing = 163 [default = false];`
`boolean`	`getUseTimetableEdgeFindingInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts.
`double`	`getVariableActivityDecay()`	Each time a conflict is found, the activities of some variables are increased by one.
`boolean`	`hasAbsoluteGapLimit()`	Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit.
`boolean`	`hasAddCgCuts()`	Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
`boolean`	`hasAddCliqueCuts()`	Whether we generate clique cuts from the binary implication graph.
`boolean`	`hasAddKnapsackCuts()`	Whether we generate knapsack cuts.
`boolean`	`hasAddLinMaxCuts()`	For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et.
`boolean`	`hasAddLpConstraintsLazily()`	If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch.
`boolean`	`hasAddMirCuts()`	Whether we generate MIR cuts at root node.
`boolean`	`hasAddZeroHalfCuts()`	Whether we generate Zero-Half cuts at root node.
`boolean`	`hasAlsoBumpVariablesInConflictReasons()`	When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped.
`boolean`	`hasAutoDetectGreaterThanAtLeastOneOf()`	If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present.
`boolean`	`hasBinaryMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];`
`boolean`	`hasBinarySearchNumConflicts()`	If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict.
`boolean`	`hasBlockingRestartMultiplier()`	`optional double blocking_restart_multiplier = 66 [default = 1.4];`
`boolean`	`hasBlockingRestartWindowSize()`	`optional int32 blocking_restart_window_size = 65 [default = 5000];`
`boolean`	`hasBooleanEncodingLevel()`	A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
`boolean`	`hasCatchSigintSignal()`	Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve.
`boolean`	`hasClauseActivityDecay()`	Clause activity parameters (same effect as the one on the variables).
`boolean`	`hasClauseCleanupLbdBound()`	All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
`boolean`	`hasClauseCleanupOrdering()`	`optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];`
`boolean`	`hasClauseCleanupPeriod()`	Trigger a cleanup when this number of "deletable" clauses is learned.
`boolean`	`hasClauseCleanupProtection()`	`optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];`
`boolean`	`hasClauseCleanupTarget()`	During a cleanup, we will always keep that number of "deletable" clauses.
`boolean`	`hasConvertIntervals()`	Temporary flag util the feature is more mature.
`boolean`	`hasCountAssumptionLevelsInLbd()`	Whether or not the assumption levels are taken into account during the LBD computation.
`boolean`	`hasCoverOptimization()`	If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
`boolean`	`hasCpModelMaxNumPresolveOperations()`	If positive, try to stop just after that many presolve rules have been applied.
`boolean`	`hasCpModelPostsolveWithFullSolver()`	Advanced usage.
`boolean`	`hasCpModelPresolve()`	Whether we presolve the cp_model before solving it.
`boolean`	`hasCpModelProbingLevel()`	How much effort do we spend on probing.
`boolean`	`hasCpModelUseSatPresolve()`	Whether we also use the sat presolve when cp_model_presolve is true.
`boolean`	`hasCutActiveCountDecay()`	`optional double cut_active_count_decay = 156 [default = 0.8];`
`boolean`	`hasCutCleanupTarget()`	Target number of constraints to remove during cleanup.
`boolean`	`hasCutMaxActiveCountValue()`	These parameters are similar to sat clause management activity parameters.
`boolean`	`hasDefaultRestartAlgorithms()`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`boolean`	`hasDisableConstraintExpansion()`	If true, it disable all constraint expansion.
`boolean`	`hasDiversifyLnsParams()`	If true, registers more lns subsolvers with different parameters.
`boolean`	`hasEnumerateAllSolutions()`	Whether we enumerate all solutions of a problem without objective.
`boolean`	`hasExpandAlldiffConstraints()`	If true, expand all_different constraints that are not permutations.
`boolean`	`hasExpandAutomatonConstraints()`	If true, the automaton constraints are expanded.
`boolean`	`hasExpandElementConstraints()`	If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
`boolean`	`hasExpandReservoirConstraints()`	If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`boolean`	`hasExpandTableConstraints()`	If true, the positive table constraints are expanded.
`boolean`	`hasExploitAllLpSolution()`	If true and the Lp relaxation of the problem has a solution, try to exploit it.
`boolean`	`hasExploitBestSolution()`	When branching on a variable, follow the last best solution value.
`boolean`	`hasExploitIntegerLpSolution()`	If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it.
`boolean`	`hasExploitObjective()`	When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
`boolean`	`hasExploitRelaxationSolution()`	When branching on a variable, follow the last best relaxation solution value.
`boolean`	`hasFillTightenedDomainsInResponse()`	If true, add information about the derived variable domains to the CpSolverResponse.
`boolean`	`hasFindMultipleCores()`	Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`boolean`	`hasFpRounding()`	`optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];`
`boolean`	`hasGlucoseDecayIncrement()`	`optional double glucose_decay_increment = 23 [default = 0.01];`
`boolean`	`hasGlucoseDecayIncrementPeriod()`	`optional int32 glucose_decay_increment_period = 24 [default = 5000];`
`boolean`	`hasGlucoseMaxDecay()`	The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95.
`boolean`	`hasHintConflictLimit()`	Conflict limit used in the phase that exploit the solution hint.
`boolean`	`hasInitialPolarity()`	`optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`boolean`	`hasInitialVariablesActivity()`	The initial value of the variables activity.
`boolean`	`hasInstantiateAllVariables()`	If true, the solver will add a default integer branching strategy to the already defined search strategy.
`boolean`	`hasInterleaveBatchSize()`	`optional int32 interleave_batch_size = 134 [default = 1];`
`boolean`	`hasInterleaveSearch()`	Experimental.
`boolean`	`hasKeepAllFeasibleSolutionsInPresolve()`	If true, we disable the presolve reductions that remove feasible solutions from the search space.
`boolean`	`hasLinearizationLevel()`	A non-negative level indicating the type of constraints we consider in the LP relaxation.
`boolean`	`hasLnsExpandIntervalsInConstraintGraph()`	`optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];`
`boolean`	`hasLnsFocusOnDecisionVariables()`	`optional bool lns_focus_on_decision_variables = 105 [default = false];`
`boolean`	`hasLogPrefix()`	Add a prefix to all logs.
`boolean`	`hasLogSearchProgress()`	Whether the solver should log the search progress.
`boolean`	`hasLogToResponse()`	Log to response proto.
`boolean`	`hasLogToStdout()`	Log to stdout.
`boolean`	`hasMaxAllDiffCutSize()`	Cut generator for all diffs can add too many cuts for large all_diff constraints.
`boolean`	`hasMaxClauseActivityValue()`	`optional double max_clause_activity_value = 18 [default = 1e+20];`
`boolean`	`hasMaxConsecutiveInactiveCount()`	If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP.
`boolean`	`hasMaxCutRoundsAtLevelZero()`	Max number of time we perform cut generation and resolve the LP at level 0.
`boolean`	`hasMaxDeterministicTime()`	Maximum time allowed in deterministic time to solve a problem.
`boolean`	`hasMaxIntegerRoundingScaling()`	In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`boolean`	`hasMaxMemoryInMb()`	Maximum memory allowed for the whole thread containing the solver.
`boolean`	`hasMaxNumberOfConflicts()`	Maximum number of conflicts allowed to solve a problem.
`boolean`	`hasMaxNumCuts()`	The limit on the number of cuts in our cut pool.
`boolean`	`hasMaxPresolveIterations()`	In case of large reduction in a presolve iteration, we perform multiple presolve iterations.
`boolean`	`hasMaxSatAssumptionOrder()`	`optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];`
`boolean`	`hasMaxSatReverseAssumptionOrder()`	If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
`boolean`	`hasMaxSatStratification()`	`optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];`
`boolean`	`hasMaxTimeInSeconds()`	Maximum time allowed in seconds to solve a problem.
`boolean`	`hasMaxVariableActivityValue()`	`optional double max_variable_activity_value = 16 [default = 1e+100];`
`boolean`	`hasMergeAtMostOneWorkLimit()`	`optional double merge_at_most_one_work_limit = 146 [default = 100000000];`
`boolean`	`hasMergeNoOverlapWorkLimit()`	During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints.
`boolean`	`hasMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];`
`boolean`	`hasMinimizeCore()`	Whether we use a simple heuristic to try to minimize an UNSAT core.
`boolean`	`hasMinimizeReductionDuringPbResolution()`	A different algorithm during PB resolution.
`boolean`	`hasMinimizeWithPropagationNumDecisions()`	`optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];`
`boolean`	`hasMinimizeWithPropagationRestartPeriod()`	Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization.
`boolean`	`hasMinOrthogonalityForLpConstraints()`	While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call.
`boolean`	`hasMipAutomaticallyScaleVariables()`	If true, some continuous variable might be automatially scaled.
`boolean`	`hasMipCheckPrecision()`	As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`boolean`	`hasMipMaxActivityExponent()`	To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power.
`boolean`	`hasMipMaxBound()`	We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use.
`boolean`	`hasMipVarScaling()`	All continuous variable of the problem will be multiplied by this factor.
`boolean`	`hasMipWantedPrecision()`	When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients.
`boolean`	`hasName()`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`boolean`	`hasNewConstraintsBatchSize()`	Add that many lazy constraints (or cuts) at once in the LP.
`boolean`	`hasNumConflictsBeforeStrategyChanges()`	After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
`boolean`	`hasNumSearchWorkers()`	Specify the number of parallel workers to use during search.
`boolean`	`hasOnlyAddCutsAtLevelZero()`	For the cut that can be generated at any level, this control if we only try to generate them at the root node.
`boolean`	`hasOptimizeWithCore()`	The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`boolean`	`hasOptimizeWithMaxHs()`	This has no effect if optimize_with_core is false.
`boolean`	`hasPbCleanupIncrement()`	Same as for the clauses, but for the learned pseudo-Boolean constraints.
`boolean`	`hasPbCleanupRatio()`	`optional double pb_cleanup_ratio = 47 [default = 0.5];`
`boolean`	`hasPermutePresolveConstraintOrder()`	`optional bool permute_presolve_constraint_order = 179 [default = false];`
`boolean`	`hasPermuteVariableRandomly()`	This is mainly here to test the solver variability.
`boolean`	`hasPolarityRephaseIncrement()`	If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion.
`boolean`	`hasPolishLpSolution()`	Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis.
`boolean`	`hasPreferredVariableOrder()`	`optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];`
`boolean`	`hasPresolveBlockedClause()`	Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
`boolean`	`hasPresolveBvaThreshold()`	Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold.
`boolean`	`hasPresolveBveClauseWeight()`	During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
`boolean`	`hasPresolveBveThreshold()`	During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
`boolean`	`hasPresolveExtractIntegerEnforcement()`	If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint".
`boolean`	`hasPresolveProbingDeterministicTimeLimit()`	The maximum "deterministic" time limit to spend in probing.
`boolean`	`hasPresolveSubstitutionLevel()`	How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve.
`boolean`	`hasPresolveUseBva()`	Whether or not we use Bounded Variable Addition (BVA) in the presolve.
`boolean`	`hasProbingPeriodAtRoot()`	If set at zero (the default), it is disabled.
`boolean`	`hasPseudoCostReliabilityThreshold()`	The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`boolean`	`hasRandomBranchesRatio()`	A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
`boolean`	`hasRandomizeSearch()`	Randomize fixed search.
`boolean`	`hasRandomPolarityRatio()`	The proportion of polarity chosen at random.
`boolean`	`hasRandomSeed()`	At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed.
`boolean`	`hasReduceMemoryUsageInInterleaveMode()`	Temporary parameter until the memory usage is more optimized.
`boolean`	`hasRelativeGapLimit()`	`optional double relative_gap_limit = 160 [default = 0];`
`boolean`	`hasRepairHint()`	If true, the solver tries to repair the solution given in the hint.
`boolean`	`hasRestartDlAverageRatio()`	In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
`boolean`	`hasRestartLbdAverageRatio()`	`optional double restart_lbd_average_ratio = 71 [default = 1];`
`boolean`	`hasRestartPeriod()`	Restart period for the FIXED_RESTART strategy.
`boolean`	`hasRestartRunningWindowSize()`	Size of the window for the moving average restarts.
`boolean`	`hasSearchBranching()`	`optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`boolean`	`hasSearchRandomizationTolerance()`	Search randomization will collect equivalent 'max valued' variables, and pick one randomly.
`boolean`	`hasShareLevelZeroBounds()`	Allows sharing of the bounds of modified variables at level 0.
`boolean`	`hasShareObjectiveBounds()`	Allows objective sharing between workers.
`boolean`	`hasStopAfterFirstSolution()`	For an optimization problem, stop the solver as soon as we have a solution.
`boolean`	`hasStopAfterPresolve()`	Mainly used when improving the presolver.
`boolean`	`hasStrategyChangeIncreaseRatio()`	The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`boolean`	`hasSubsumptionDuringConflictAnalysis()`	At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict.
`boolean`	`hasSymmetryLevel()`	Whether we try to automatically detect the symmetries in a model and exploit them.
`boolean`	`hasTreatBinaryClausesSeparately()`	If true, the binary clauses are treated separately from the others.
`boolean`	`hasUseAbslRandom()`	`optional bool use_absl_random = 180 [default = false];`
`boolean`	`hasUseBlockingRestart()`	Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
`boolean`	`hasUseBranchingInLp()`	If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
`boolean`	`hasUseCombinedNoOverlap()`	This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem.
`boolean`	`hasUseDisjunctiveConstraintInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem.
`boolean`	`hasUseErwaHeuristic()`	Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V.
`boolean`	`hasUseExactLpReason()`	The solver usually exploit the LP relaxation of a model.
`boolean`	`hasUseFeasibilityPump()`	Adds a feasibility pump subsolver along with lns subsolvers.
`boolean`	`hasUseImpliedBounds()`	Stores and exploits "implied-bounds" in the solver.
`boolean`	`hasUseLnsOnly()`	LNS parameters.
`boolean`	`hasUseOptimizationHints()`	For an optimization problem, whether we follow some hints in order to find a better first solution.
`boolean`	`hasUseOptionalVariables()`	If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional.
`boolean`	`hasUseOverloadCheckerInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy.
`boolean`	`hasUsePbResolution()`	Whether to use pseudo-Boolean resolution to analyze a conflict.
`boolean`	`hasUsePhaseSaving()`	If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic().
`boolean`	`hasUsePrecedencesInDisjunctiveConstraint()`	When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further.
`boolean`	`hasUseProbingSearch()`	If true, search will continuously probe Boolean variables, and integer variable bounds.
`boolean`	`hasUseRelaxationLns()`	Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
`boolean`	`hasUseRinsLns()`	Turns on relaxation induced neighborhood generator.
`boolean`	`hasUseSatInprocessing()`	`optional bool use_sat_inprocessing = 163 [default = false];`
`boolean`	`hasUseTimetableEdgeFindingInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts.
`boolean`	`hasVariableActivityDecay()`	Each time a conflict is found, the activities of some variables are increased by one.
`protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable`	`internalGetFieldAccessorTable()`
`boolean`	`isInitialized()`
`SatParameters.Builder`	`mergeFrom(SatParameters other)`
`SatParameters.Builder`	`mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`SatParameters.Builder`	`mergeFrom(com.google.protobuf.Message other)`
`SatParameters.Builder`	`mergeUnknownFields(com.google.protobuf.UnknownFieldSet unknownFields)`
`SatParameters.Builder`	`setAbsoluteGapLimit(double value)`	Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit.
`SatParameters.Builder`	`setAddCgCuts(boolean value)`	Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
`SatParameters.Builder`	`setAddCliqueCuts(boolean value)`	Whether we generate clique cuts from the binary implication graph.
`SatParameters.Builder`	`setAddKnapsackCuts(boolean value)`	Whether we generate knapsack cuts.
`SatParameters.Builder`	`setAddLinMaxCuts(boolean value)`	For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et.
`SatParameters.Builder`	`setAddLpConstraintsLazily(boolean value)`	If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch.
`SatParameters.Builder`	`setAddMirCuts(boolean value)`	Whether we generate MIR cuts at root node.
`SatParameters.Builder`	`setAddZeroHalfCuts(boolean value)`	Whether we generate Zero-Half cuts at root node.
`SatParameters.Builder`	`setAlsoBumpVariablesInConflictReasons(boolean value)`	When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped.
`SatParameters.Builder`	`setAutoDetectGreaterThanAtLeastOneOf(boolean value)`	If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present.
`SatParameters.Builder`	`setBinaryMinimizationAlgorithm(SatParameters.BinaryMinizationAlgorithm value)`	`optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];`
`SatParameters.Builder`	`setBinarySearchNumConflicts(int value)`	If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict.
`SatParameters.Builder`	`setBlockingRestartMultiplier(double value)`	`optional double blocking_restart_multiplier = 66 [default = 1.4];`
`SatParameters.Builder`	`setBlockingRestartWindowSize(int value)`	`optional int32 blocking_restart_window_size = 65 [default = 5000];`
`SatParameters.Builder`	`setBooleanEncodingLevel(int value)`	A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
`SatParameters.Builder`	`setCatchSigintSignal(boolean value)`	Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve.
`SatParameters.Builder`	`setClauseActivityDecay(double value)`	Clause activity parameters (same effect as the one on the variables).
`SatParameters.Builder`	`setClauseCleanupLbdBound(int value)`	All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
`SatParameters.Builder`	`setClauseCleanupOrdering(SatParameters.ClauseOrdering value)`	`optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];`
`SatParameters.Builder`	`setClauseCleanupPeriod(int value)`	Trigger a cleanup when this number of "deletable" clauses is learned.
`SatParameters.Builder`	`setClauseCleanupProtection(SatParameters.ClauseProtection value)`	`optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];`
`SatParameters.Builder`	`setClauseCleanupTarget(int value)`	During a cleanup, we will always keep that number of "deletable" clauses.
`SatParameters.Builder`	`setConvertIntervals(boolean value)`	Temporary flag util the feature is more mature.
`SatParameters.Builder`	`setCountAssumptionLevelsInLbd(boolean value)`	Whether or not the assumption levels are taken into account during the LBD computation.
`SatParameters.Builder`	`setCoverOptimization(boolean value)`	If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
`SatParameters.Builder`	`setCpModelMaxNumPresolveOperations(int value)`	If positive, try to stop just after that many presolve rules have been applied.
`SatParameters.Builder`	`setCpModelPostsolveWithFullSolver(boolean value)`	Advanced usage.
`SatParameters.Builder`	`setCpModelPresolve(boolean value)`	Whether we presolve the cp_model before solving it.
`SatParameters.Builder`	`setCpModelProbingLevel(int value)`	How much effort do we spend on probing.
`SatParameters.Builder`	`setCpModelUseSatPresolve(boolean value)`	Whether we also use the sat presolve when cp_model_presolve is true.
`SatParameters.Builder`	`setCutActiveCountDecay(double value)`	`optional double cut_active_count_decay = 156 [default = 0.8];`
`SatParameters.Builder`	`setCutCleanupTarget(int value)`	Target number of constraints to remove during cleanup.
`SatParameters.Builder`	`setCutMaxActiveCountValue(double value)`	These parameters are similar to sat clause management activity parameters.
`SatParameters.Builder`	`setDefaultRestartAlgorithms(java.lang.String value)`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`SatParameters.Builder`	`setDefaultRestartAlgorithmsBytes(com.google.protobuf.ByteString value)`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`SatParameters.Builder`	`setDisableConstraintExpansion(boolean value)`	If true, it disable all constraint expansion.
`SatParameters.Builder`	`setDiversifyLnsParams(boolean value)`	If true, registers more lns subsolvers with different parameters.
`SatParameters.Builder`	`setEnumerateAllSolutions(boolean value)`	Whether we enumerate all solutions of a problem without objective.
`SatParameters.Builder`	`setExpandAlldiffConstraints(boolean value)`	If true, expand all_different constraints that are not permutations.
`SatParameters.Builder`	`setExpandAutomatonConstraints(boolean value)`	If true, the automaton constraints are expanded.
`SatParameters.Builder`	`setExpandElementConstraints(boolean value)`	If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
`SatParameters.Builder`	`setExpandReservoirConstraints(boolean value)`	If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`SatParameters.Builder`	`setExpandTableConstraints(boolean value)`	If true, the positive table constraints are expanded.
`SatParameters.Builder`	`setExploitAllLpSolution(boolean value)`	If true and the Lp relaxation of the problem has a solution, try to exploit it.
`SatParameters.Builder`	`setExploitBestSolution(boolean value)`	When branching on a variable, follow the last best solution value.
`SatParameters.Builder`	`setExploitIntegerLpSolution(boolean value)`	If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it.
`SatParameters.Builder`	`setExploitObjective(boolean value)`	When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
`SatParameters.Builder`	`setExploitRelaxationSolution(boolean value)`	When branching on a variable, follow the last best relaxation solution value.
`SatParameters.Builder`	`setField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)`
`SatParameters.Builder`	`setFillTightenedDomainsInResponse(boolean value)`	If true, add information about the derived variable domains to the CpSolverResponse.
`SatParameters.Builder`	`setFindMultipleCores(boolean value)`	Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`SatParameters.Builder`	`setFpRounding(SatParameters.FPRoundingMethod value)`	`optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];`
`SatParameters.Builder`	`setGlucoseDecayIncrement(double value)`	`optional double glucose_decay_increment = 23 [default = 0.01];`
`SatParameters.Builder`	`setGlucoseDecayIncrementPeriod(int value)`	`optional int32 glucose_decay_increment_period = 24 [default = 5000];`
`SatParameters.Builder`	`setGlucoseMaxDecay(double value)`	The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95.
`SatParameters.Builder`	`setHintConflictLimit(int value)`	Conflict limit used in the phase that exploit the solution hint.
`SatParameters.Builder`	`setInitialPolarity(SatParameters.Polarity value)`	`optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`SatParameters.Builder`	`setInitialVariablesActivity(double value)`	The initial value of the variables activity.
`SatParameters.Builder`	`setInstantiateAllVariables(boolean value)`	If true, the solver will add a default integer branching strategy to the already defined search strategy.
`SatParameters.Builder`	`setInterleaveBatchSize(int value)`	`optional int32 interleave_batch_size = 134 [default = 1];`
`SatParameters.Builder`	`setInterleaveSearch(boolean value)`	Experimental.
`SatParameters.Builder`	`setKeepAllFeasibleSolutionsInPresolve(boolean value)`	If true, we disable the presolve reductions that remove feasible solutions from the search space.
`SatParameters.Builder`	`setLinearizationLevel(int value)`	A non-negative level indicating the type of constraints we consider in the LP relaxation.
`SatParameters.Builder`	`setLnsExpandIntervalsInConstraintGraph(boolean value)`	`optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];`
`SatParameters.Builder`	`setLnsFocusOnDecisionVariables(boolean value)`	`optional bool lns_focus_on_decision_variables = 105 [default = false];`
`SatParameters.Builder`	`setLogPrefix(java.lang.String value)`	Add a prefix to all logs.
`SatParameters.Builder`	`setLogPrefixBytes(com.google.protobuf.ByteString value)`	Add a prefix to all logs.
`SatParameters.Builder`	`setLogSearchProgress(boolean value)`	Whether the solver should log the search progress.
`SatParameters.Builder`	`setLogToResponse(boolean value)`	Log to response proto.
`SatParameters.Builder`	`setLogToStdout(boolean value)`	Log to stdout.
`SatParameters.Builder`	`setMaxAllDiffCutSize(int value)`	Cut generator for all diffs can add too many cuts for large all_diff constraints.
`SatParameters.Builder`	`setMaxClauseActivityValue(double value)`	`optional double max_clause_activity_value = 18 [default = 1e+20];`
`SatParameters.Builder`	`setMaxConsecutiveInactiveCount(int value)`	If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP.
`SatParameters.Builder`	`setMaxCutRoundsAtLevelZero(int value)`	Max number of time we perform cut generation and resolve the LP at level 0.
`SatParameters.Builder`	`setMaxDeterministicTime(double value)`	Maximum time allowed in deterministic time to solve a problem.
`SatParameters.Builder`	`setMaxIntegerRoundingScaling(int value)`	In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`SatParameters.Builder`	`setMaxMemoryInMb(long value)`	Maximum memory allowed for the whole thread containing the solver.
`SatParameters.Builder`	`setMaxNumberOfConflicts(long value)`	Maximum number of conflicts allowed to solve a problem.
`SatParameters.Builder`	`setMaxNumCuts(int value)`	The limit on the number of cuts in our cut pool.
`SatParameters.Builder`	`setMaxPresolveIterations(int value)`	In case of large reduction in a presolve iteration, we perform multiple presolve iterations.
`SatParameters.Builder`	`setMaxSatAssumptionOrder(SatParameters.MaxSatAssumptionOrder value)`	`optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];`
`SatParameters.Builder`	`setMaxSatReverseAssumptionOrder(boolean value)`	If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
`SatParameters.Builder`	`setMaxSatStratification(SatParameters.MaxSatStratificationAlgorithm value)`	`optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];`
`SatParameters.Builder`	`setMaxTimeInSeconds(double value)`	Maximum time allowed in seconds to solve a problem.
`SatParameters.Builder`	`setMaxVariableActivityValue(double value)`	`optional double max_variable_activity_value = 16 [default = 1e+100];`
`SatParameters.Builder`	`setMergeAtMostOneWorkLimit(double value)`	`optional double merge_at_most_one_work_limit = 146 [default = 100000000];`
`SatParameters.Builder`	`setMergeNoOverlapWorkLimit(double value)`	During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints.
`SatParameters.Builder`	`setMinimizationAlgorithm(SatParameters.ConflictMinimizationAlgorithm value)`	`optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];`
`SatParameters.Builder`	`setMinimizeCore(boolean value)`	Whether we use a simple heuristic to try to minimize an UNSAT core.
`SatParameters.Builder`	`setMinimizeReductionDuringPbResolution(boolean value)`	A different algorithm during PB resolution.
`SatParameters.Builder`	`setMinimizeWithPropagationNumDecisions(int value)`	`optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];`
`SatParameters.Builder`	`setMinimizeWithPropagationRestartPeriod(int value)`	Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization.
`SatParameters.Builder`	`setMinOrthogonalityForLpConstraints(double value)`	While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call.
`SatParameters.Builder`	`setMipAutomaticallyScaleVariables(boolean value)`	If true, some continuous variable might be automatially scaled.
`SatParameters.Builder`	`setMipCheckPrecision(double value)`	As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`SatParameters.Builder`	`setMipMaxActivityExponent(int value)`	To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power.
`SatParameters.Builder`	`setMipMaxBound(double value)`	We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use.
`SatParameters.Builder`	`setMipVarScaling(double value)`	All continuous variable of the problem will be multiplied by this factor.
`SatParameters.Builder`	`setMipWantedPrecision(double value)`	When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients.
`SatParameters.Builder`	`setName(java.lang.String value)`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`SatParameters.Builder`	`setNameBytes(com.google.protobuf.ByteString value)`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`SatParameters.Builder`	`setNewConstraintsBatchSize(int value)`	Add that many lazy constraints (or cuts) at once in the LP.
`SatParameters.Builder`	`setNumConflictsBeforeStrategyChanges(int value)`	After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
`SatParameters.Builder`	`setNumSearchWorkers(int value)`	Specify the number of parallel workers to use during search.
`SatParameters.Builder`	`setOnlyAddCutsAtLevelZero(boolean value)`	For the cut that can be generated at any level, this control if we only try to generate them at the root node.
`SatParameters.Builder`	`setOptimizeWithCore(boolean value)`	The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`SatParameters.Builder`	`setOptimizeWithMaxHs(boolean value)`	This has no effect if optimize_with_core is false.
`SatParameters.Builder`	`setPbCleanupIncrement(int value)`	Same as for the clauses, but for the learned pseudo-Boolean constraints.
`SatParameters.Builder`	`setPbCleanupRatio(double value)`	`optional double pb_cleanup_ratio = 47 [default = 0.5];`
`SatParameters.Builder`	`setPermutePresolveConstraintOrder(boolean value)`	`optional bool permute_presolve_constraint_order = 179 [default = false];`
`SatParameters.Builder`	`setPermuteVariableRandomly(boolean value)`	This is mainly here to test the solver variability.
`SatParameters.Builder`	`setPolarityRephaseIncrement(int value)`	If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion.
`SatParameters.Builder`	`setPolishLpSolution(boolean value)`	Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis.
`SatParameters.Builder`	`setPreferredVariableOrder(SatParameters.VariableOrder value)`	`optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];`
`SatParameters.Builder`	`setPresolveBlockedClause(boolean value)`	Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
`SatParameters.Builder`	`setPresolveBvaThreshold(int value)`	Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold.
`SatParameters.Builder`	`setPresolveBveClauseWeight(int value)`	During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
`SatParameters.Builder`	`setPresolveBveThreshold(int value)`	During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
`SatParameters.Builder`	`setPresolveExtractIntegerEnforcement(boolean value)`	If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint".
`SatParameters.Builder`	`setPresolveProbingDeterministicTimeLimit(double value)`	The maximum "deterministic" time limit to spend in probing.
`SatParameters.Builder`	`setPresolveSubstitutionLevel(int value)`	How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve.
`SatParameters.Builder`	`setPresolveUseBva(boolean value)`	Whether or not we use Bounded Variable Addition (BVA) in the presolve.
`SatParameters.Builder`	`setProbingPeriodAtRoot(long value)`	If set at zero (the default), it is disabled.
`SatParameters.Builder`	`setPseudoCostReliabilityThreshold(long value)`	The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`SatParameters.Builder`	`setRandomBranchesRatio(double value)`	A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
`SatParameters.Builder`	`setRandomizeSearch(boolean value)`	Randomize fixed search.
`SatParameters.Builder`	`setRandomPolarityRatio(double value)`	The proportion of polarity chosen at random.
`SatParameters.Builder`	`setRandomSeed(int value)`	At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed.
`SatParameters.Builder`	`setReduceMemoryUsageInInterleaveMode(boolean value)`	Temporary parameter until the memory usage is more optimized.
`SatParameters.Builder`	`setRelativeGapLimit(double value)`	`optional double relative_gap_limit = 160 [default = 0];`
`SatParameters.Builder`	`setRepairHint(boolean value)`	If true, the solver tries to repair the solution given in the hint.
`SatParameters.Builder`	`setRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value)`
`SatParameters.Builder`	`setRestartAlgorithms(int index, SatParameters.RestartAlgorithm value)`	The restart strategies will change each time the strategy_counter is increased.
`SatParameters.Builder`	`setRestartDlAverageRatio(double value)`	In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
`SatParameters.Builder`	`setRestartLbdAverageRatio(double value)`	`optional double restart_lbd_average_ratio = 71 [default = 1];`
`SatParameters.Builder`	`setRestartPeriod(int value)`	Restart period for the FIXED_RESTART strategy.
`SatParameters.Builder`	`setRestartRunningWindowSize(int value)`	Size of the window for the moving average restarts.
`SatParameters.Builder`	`setSearchBranching(SatParameters.SearchBranching value)`	`optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`SatParameters.Builder`	`setSearchRandomizationTolerance(long value)`	Search randomization will collect equivalent 'max valued' variables, and pick one randomly.
`SatParameters.Builder`	`setShareLevelZeroBounds(boolean value)`	Allows sharing of the bounds of modified variables at level 0.
`SatParameters.Builder`	`setShareObjectiveBounds(boolean value)`	Allows objective sharing between workers.
`SatParameters.Builder`	`setStopAfterFirstSolution(boolean value)`	For an optimization problem, stop the solver as soon as we have a solution.
`SatParameters.Builder`	`setStopAfterPresolve(boolean value)`	Mainly used when improving the presolver.
`SatParameters.Builder`	`setStrategyChangeIncreaseRatio(double value)`	The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`SatParameters.Builder`	`setSubsumptionDuringConflictAnalysis(boolean value)`	At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict.
`SatParameters.Builder`	`setSymmetryLevel(int value)`	Whether we try to automatically detect the symmetries in a model and exploit them.
`SatParameters.Builder`	`setTreatBinaryClausesSeparately(boolean value)`	If true, the binary clauses are treated separately from the others.
`SatParameters.Builder`	`setUnknownFields(com.google.protobuf.UnknownFieldSet unknownFields)`
`SatParameters.Builder`	`setUseAbslRandom(boolean value)`	`optional bool use_absl_random = 180 [default = false];`
`SatParameters.Builder`	`setUseBlockingRestart(boolean value)`	Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
`SatParameters.Builder`	`setUseBranchingInLp(boolean value)`	If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
`SatParameters.Builder`	`setUseCombinedNoOverlap(boolean value)`	This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem.
`SatParameters.Builder`	`setUseDisjunctiveConstraintInCumulativeConstraint(boolean value)`	When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem.
`SatParameters.Builder`	`setUseErwaHeuristic(boolean value)`	Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V.
`SatParameters.Builder`	`setUseExactLpReason(boolean value)`	The solver usually exploit the LP relaxation of a model.
`SatParameters.Builder`	`setUseFeasibilityPump(boolean value)`	Adds a feasibility pump subsolver along with lns subsolvers.
`SatParameters.Builder`	`setUseImpliedBounds(boolean value)`	Stores and exploits "implied-bounds" in the solver.
`SatParameters.Builder`	`setUseLnsOnly(boolean value)`	LNS parameters.
`SatParameters.Builder`	`setUseOptimizationHints(boolean value)`	For an optimization problem, whether we follow some hints in order to find a better first solution.
`SatParameters.Builder`	`setUseOptionalVariables(boolean value)`	If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional.
`SatParameters.Builder`	`setUseOverloadCheckerInCumulativeConstraint(boolean value)`	When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy.
`SatParameters.Builder`	`setUsePbResolution(boolean value)`	Whether to use pseudo-Boolean resolution to analyze a conflict.
`SatParameters.Builder`	`setUsePhaseSaving(boolean value)`	If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic().
`SatParameters.Builder`	`setUsePrecedencesInDisjunctiveConstraint(boolean value)`	When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further.
`SatParameters.Builder`	`setUseProbingSearch(boolean value)`	If true, search will continuously probe Boolean variables, and integer variable bounds.
`SatParameters.Builder`	`setUseRelaxationLns(boolean value)`	Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
`SatParameters.Builder`	`setUseRinsLns(boolean value)`	Turns on relaxation induced neighborhood generator.
`SatParameters.Builder`	`setUseSatInprocessing(boolean value)`	`optional bool use_sat_inprocessing = 163 [default = false];`
`SatParameters.Builder`	`setUseTimetableEdgeFindingInCumulativeConstraint(boolean value)`	When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts.
`SatParameters.Builder`	`setVariableActivityDecay(double value)`	Each time a conflict is found, the activities of some variables are increased by one.

Methods inherited from class com.google.protobuf.GeneratedMessageV3.Builder

getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof, internalGetMapField, internalGetMutableMapField, isClean, markClean, newBuilderForField, onBuilt, onChanged, setUnknownFieldsProto3

Methods inherited from class com.google.protobuf.AbstractMessage.Builder

findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeDelimitedFrom, mergeDelimitedFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString

Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder

addAll, addAll, mergeFrom, newUninitializedMessageException

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.google.protobuf.MessageLite.Builder

mergeFrom

Methods inherited from interface com.google.protobuf.MessageOrBuilder

findInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

Method Details
- getDescriptor
  
  public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()
- internalGetFieldAccessorTable
  
  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
  
  Specified by:
  
  internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- clear
  
  public SatParameters.Builder clear()
  
  Specified by:
  
  clear in interface com.google.protobuf.Message.Builder
  
  Specified by:
  
  clear in interface com.google.protobuf.MessageLite.Builder
  
  Overrides:
  
  clear in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- getDescriptorForType
  
  public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
  
  Specified by:
  
  getDescriptorForType in interface com.google.protobuf.Message.Builder
  
  Specified by:
  
  getDescriptorForType in interface com.google.protobuf.MessageOrBuilder
  
  Overrides:
  
  getDescriptorForType in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- getDefaultInstanceForType
  
  public SatParameters getDefaultInstanceForType()
  
  Specified by:
  
  getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
  
  Specified by:
  
  getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder
- build
  
  public SatParameters build()
  
  Specified by:
  
  build in interface com.google.protobuf.Message.Builder
  
  Specified by:
  
  build in interface com.google.protobuf.MessageLite.Builder
- buildPartial
  
  public SatParameters buildPartial()
  
  Specified by:
  
  buildPartial in interface com.google.protobuf.Message.Builder
  
  Specified by:
  
  buildPartial in interface com.google.protobuf.MessageLite.Builder
- clone
  
  public SatParameters.Builder clone()
  
  Specified by:
  
  clone in interface com.google.protobuf.Message.Builder
  
  Specified by:
  
  clone in interface com.google.protobuf.MessageLite.Builder
  
  Overrides:
  
  clone in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- setField
  
  public SatParameters.Builder setField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)
  
  Specified by:
  
  setField in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  setField in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- clearField
  
  public SatParameters.Builder clearField(com.google.protobuf.Descriptors.FieldDescriptor field)
  
  Specified by:
  
  clearField in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  clearField in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- clearOneof
  
  public SatParameters.Builder clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof)
  
  Specified by:
  
  clearOneof in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  clearOneof in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- setRepeatedField
  
  public SatParameters.Builder setRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value)
  
  Specified by:
  
  setRepeatedField in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  setRepeatedField in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- addRepeatedField
  
  public SatParameters.Builder addRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)
  
  Specified by:
  
  addRepeatedField in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  addRepeatedField in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- mergeFrom
  
  public SatParameters.Builder mergeFrom(com.google.protobuf.Message other)
  
  Specified by:
  
  mergeFrom in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  mergeFrom in class com.google.protobuf.AbstractMessage.Builder<SatParameters.Builder>
- mergeFrom
  
  public SatParameters.Builder mergeFrom(SatParameters other)
- isInitialized
  
  public final boolean isInitialized()
  
  Specified by:
  
  isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
  
  Overrides:
  
  isInitialized in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- mergeFrom
  
  public SatParameters.Builder mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException
  
  Specified by:
  
  mergeFrom in interface com.google.protobuf.Message.Builder
  
  Specified by:
  
  mergeFrom in interface com.google.protobuf.MessageLite.Builder
  
  Overrides:
  
  mergeFrom in class com.google.protobuf.AbstractMessage.Builder<SatParameters.Builder>
  
  Throws:
  
  java.io.IOException
- hasName
  
  public boolean hasName()
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Specified by:
  
  hasName in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the name field is set.
- getName
  
  public java.lang.String getName()
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Specified by:
  
  getName in interface SatParametersOrBuilder
  
  Returns:
  
  The name.
- getNameBytes
  
  public com.google.protobuf.ByteString getNameBytes()
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Specified by:
  
  getNameBytes in interface SatParametersOrBuilder
  
  Returns:
  
  The bytes for name.
- setName
  
  public SatParameters.Builder setName(java.lang.String value)
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Parameters:
  
  value - The name to set.
  
  Returns:
  
  This builder for chaining.
- clearName
  
  public SatParameters.Builder clearName()
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Returns:
  
  This builder for chaining.
- setNameBytes
  
  public SatParameters.Builder setNameBytes(com.google.protobuf.ByteString value)
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Parameters:
  
  value - The bytes for name to set.
  
  Returns:
  
  This builder for chaining.
- hasPreferredVariableOrder
  
  public boolean hasPreferredVariableOrder()
  
  optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  
  Specified by:
  
  hasPreferredVariableOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the preferredVariableOrder field is set.
- getPreferredVariableOrder
  
  public SatParameters.VariableOrder getPreferredVariableOrder()
  
  optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  
  Specified by:
  
  getPreferredVariableOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The preferredVariableOrder.
- setPreferredVariableOrder
  
  public SatParameters.Builder setPreferredVariableOrder(SatParameters.VariableOrder value)
  
  optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  
  Parameters:
  
  value - The preferredVariableOrder to set.
  
  Returns:
  
  This builder for chaining.
- clearPreferredVariableOrder
  
  public SatParameters.Builder clearPreferredVariableOrder()
  
  optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  
  Returns:
  
  This builder for chaining.
- hasInitialPolarity
  
  public boolean hasInitialPolarity()
  
  optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  
  Specified by:
  
  hasInitialPolarity in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the initialPolarity field is set.
- getInitialPolarity
  
  public SatParameters.Polarity getInitialPolarity()
  
  optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  
  Specified by:
  
  getInitialPolarity in interface SatParametersOrBuilder
  
  Returns:
  
  The initialPolarity.
- setInitialPolarity
  
  public SatParameters.Builder setInitialPolarity(SatParameters.Polarity value)
  
  optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  
  Parameters:
  
  value - The initialPolarity to set.
  
  Returns:
  
  This builder for chaining.
- clearInitialPolarity
  
  public SatParameters.Builder clearInitialPolarity()
  
  optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  
  Returns:
  
  This builder for chaining.
- hasUsePhaseSaving
  
  public boolean hasUsePhaseSaving()
  If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic(). Actually, we use a newer version where we follow the last value in the longest non-conflicting partial assignment in the current phase. This is called 'literal phase saving'. For details see 'A Lightweight Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and A.Darwiche, In 10th International Conference on Theory and Applications of Satisfiability Testing, 2007.
  optional bool use_phase_saving = 44 [default = true];
  Specified by:
  
  hasUsePhaseSaving in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the usePhaseSaving field is set.
- getUsePhaseSaving
  
  public boolean getUsePhaseSaving()
  If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic(). Actually, we use a newer version where we follow the last value in the longest non-conflicting partial assignment in the current phase. This is called 'literal phase saving'. For details see 'A Lightweight Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and A.Darwiche, In 10th International Conference on Theory and Applications of Satisfiability Testing, 2007.
  optional bool use_phase_saving = 44 [default = true];
  Specified by:
  
  getUsePhaseSaving in interface SatParametersOrBuilder
  
  Returns:
  
  The usePhaseSaving.
- setUsePhaseSaving
  
  public SatParameters.Builder setUsePhaseSaving(boolean value)
  If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic(). Actually, we use a newer version where we follow the last value in the longest non-conflicting partial assignment in the current phase. This is called 'literal phase saving'. For details see 'A Lightweight Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and A.Darwiche, In 10th International Conference on Theory and Applications of Satisfiability Testing, 2007.
  optional bool use_phase_saving = 44 [default = true];
  Parameters:
  
  value - The usePhaseSaving to set.
  
  Returns:
  
  This builder for chaining.
- clearUsePhaseSaving
  
  public SatParameters.Builder clearUsePhaseSaving()
  If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic(). Actually, we use a newer version where we follow the last value in the longest non-conflicting partial assignment in the current phase. This is called 'literal phase saving'. For details see 'A Lightweight Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and A.Darwiche, In 10th International Conference on Theory and Applications of Satisfiability Testing, 2007.
  optional bool use_phase_saving = 44 [default = true];
  Returns:
  
  This builder for chaining.
- hasPolarityRephaseIncrement
  
  public boolean hasPolarityRephaseIncrement()
  If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion. So x the first time, 2 * x the second time, etc...
  optional int32 polarity_rephase_increment = 168 [default = 1000];
  Specified by:
  
  hasPolarityRephaseIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the polarityRephaseIncrement field is set.
- getPolarityRephaseIncrement
  
  public int getPolarityRephaseIncrement()
  If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion. So x the first time, 2 * x the second time, etc...
  optional int32 polarity_rephase_increment = 168 [default = 1000];
  Specified by:
  
  getPolarityRephaseIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  The polarityRephaseIncrement.
- setPolarityRephaseIncrement
  
  public SatParameters.Builder setPolarityRephaseIncrement(int value)
  If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion. So x the first time, 2 * x the second time, etc...
  optional int32 polarity_rephase_increment = 168 [default = 1000];
  Parameters:
  
  value - The polarityRephaseIncrement to set.
  
  Returns:
  
  This builder for chaining.
- clearPolarityRephaseIncrement
  
  public SatParameters.Builder clearPolarityRephaseIncrement()
  If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion. So x the first time, 2 * x the second time, etc...
  optional int32 polarity_rephase_increment = 168 [default = 1000];
  Returns:
  
  This builder for chaining.
- hasRandomPolarityRatio
  
  public boolean hasRandomPolarityRatio()
  The proportion of polarity chosen at random. Note that this take precedence over the phase saving heuristic. This is different from initial_polarity:POLARITY_RANDOM because it will select a new random polarity each time the variable is branched upon instead of selecting one initially and then always taking this choice.
  optional double random_polarity_ratio = 45 [default = 0];
  Specified by:
  
  hasRandomPolarityRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomPolarityRatio field is set.
- getRandomPolarityRatio
  
  public double getRandomPolarityRatio()
  The proportion of polarity chosen at random. Note that this take precedence over the phase saving heuristic. This is different from initial_polarity:POLARITY_RANDOM because it will select a new random polarity each time the variable is branched upon instead of selecting one initially and then always taking this choice.
  optional double random_polarity_ratio = 45 [default = 0];
  Specified by:
  
  getRandomPolarityRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The randomPolarityRatio.
- setRandomPolarityRatio
  
  public SatParameters.Builder setRandomPolarityRatio(double value)
  The proportion of polarity chosen at random. Note that this take precedence over the phase saving heuristic. This is different from initial_polarity:POLARITY_RANDOM because it will select a new random polarity each time the variable is branched upon instead of selecting one initially and then always taking this choice.
  optional double random_polarity_ratio = 45 [default = 0];
  Parameters:
  
  value - The randomPolarityRatio to set.
  
  Returns:
  
  This builder for chaining.
- clearRandomPolarityRatio
  
  public SatParameters.Builder clearRandomPolarityRatio()
  The proportion of polarity chosen at random. Note that this take precedence over the phase saving heuristic. This is different from initial_polarity:POLARITY_RANDOM because it will select a new random polarity each time the variable is branched upon instead of selecting one initially and then always taking this choice.
  optional double random_polarity_ratio = 45 [default = 0];
  Returns:
  
  This builder for chaining.
- hasRandomBranchesRatio
  
  public boolean hasRandomBranchesRatio()
  A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
  optional double random_branches_ratio = 32 [default = 0];
  Specified by:
  
  hasRandomBranchesRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomBranchesRatio field is set.
- getRandomBranchesRatio
  
  public double getRandomBranchesRatio()
  A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
  optional double random_branches_ratio = 32 [default = 0];
  Specified by:
  
  getRandomBranchesRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The randomBranchesRatio.
- setRandomBranchesRatio
  
  public SatParameters.Builder setRandomBranchesRatio(double value)
  A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
  optional double random_branches_ratio = 32 [default = 0];
  Parameters:
  
  value - The randomBranchesRatio to set.
  
  Returns:
  
  This builder for chaining.
- clearRandomBranchesRatio
  
  public SatParameters.Builder clearRandomBranchesRatio()
  A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
  optional double random_branches_ratio = 32 [default = 0];
  Returns:
  
  This builder for chaining.
- hasUseErwaHeuristic
  
  public boolean hasUseErwaHeuristic()
  Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
  optional bool use_erwa_heuristic = 75 [default = false];
  Specified by:
  
  hasUseErwaHeuristic in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useErwaHeuristic field is set.
- getUseErwaHeuristic
  
  public boolean getUseErwaHeuristic()
  Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
  optional bool use_erwa_heuristic = 75 [default = false];
  Specified by:
  
  getUseErwaHeuristic in interface SatParametersOrBuilder
  
  Returns:
  
  The useErwaHeuristic.
- setUseErwaHeuristic
  
  public SatParameters.Builder setUseErwaHeuristic(boolean value)
  Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
  optional bool use_erwa_heuristic = 75 [default = false];
  Parameters:
  
  value - The useErwaHeuristic to set.
  
  Returns:
  
  This builder for chaining.
- clearUseErwaHeuristic
  
  public SatParameters.Builder clearUseErwaHeuristic()
  Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
  optional bool use_erwa_heuristic = 75 [default = false];
  Returns:
  
  This builder for chaining.
- hasInitialVariablesActivity
  
  public boolean hasInitialVariablesActivity()
  The initial value of the variables activity. A non-zero value only make sense when use_erwa_heuristic is true. Experiments with a value of 1e-2 together with the ERWA heuristic showed slighthly better result than simply using zero. The idea is that when the "learning rate" of a variable becomes lower than this value, then we prefer to branch on never explored before variables. This is not in the ERWA paper.
  optional double initial_variables_activity = 76 [default = 0];
  Specified by:
  
  hasInitialVariablesActivity in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the initialVariablesActivity field is set.
- getInitialVariablesActivity
  
  public double getInitialVariablesActivity()
  The initial value of the variables activity. A non-zero value only make sense when use_erwa_heuristic is true. Experiments with a value of 1e-2 together with the ERWA heuristic showed slighthly better result than simply using zero. The idea is that when the "learning rate" of a variable becomes lower than this value, then we prefer to branch on never explored before variables. This is not in the ERWA paper.
  optional double initial_variables_activity = 76 [default = 0];
  Specified by:
  
  getInitialVariablesActivity in interface SatParametersOrBuilder
  
  Returns:
  
  The initialVariablesActivity.
- setInitialVariablesActivity
  
  public SatParameters.Builder setInitialVariablesActivity(double value)
  The initial value of the variables activity. A non-zero value only make sense when use_erwa_heuristic is true. Experiments with a value of 1e-2 together with the ERWA heuristic showed slighthly better result than simply using zero. The idea is that when the "learning rate" of a variable becomes lower than this value, then we prefer to branch on never explored before variables. This is not in the ERWA paper.
  optional double initial_variables_activity = 76 [default = 0];
  Parameters:
  
  value - The initialVariablesActivity to set.
  
  Returns:
  
  This builder for chaining.
- clearInitialVariablesActivity
  
  public SatParameters.Builder clearInitialVariablesActivity()
  The initial value of the variables activity. A non-zero value only make sense when use_erwa_heuristic is true. Experiments with a value of 1e-2 together with the ERWA heuristic showed slighthly better result than simply using zero. The idea is that when the "learning rate" of a variable becomes lower than this value, then we prefer to branch on never explored before variables. This is not in the ERWA paper.
  optional double initial_variables_activity = 76 [default = 0];
  Returns:
  
  This builder for chaining.
- hasAlsoBumpVariablesInConflictReasons
  
  public boolean hasAlsoBumpVariablesInConflictReasons()
  When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped. This is addition to the variables in the conflict, and the one that were used during conflict resolution.
  optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  Specified by:
  
  hasAlsoBumpVariablesInConflictReasons in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the alsoBumpVariablesInConflictReasons field is set.
- getAlsoBumpVariablesInConflictReasons
  
  public boolean getAlsoBumpVariablesInConflictReasons()
  When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped. This is addition to the variables in the conflict, and the one that were used during conflict resolution.
  optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  Specified by:
  
  getAlsoBumpVariablesInConflictReasons in interface SatParametersOrBuilder
  
  Returns:
  
  The alsoBumpVariablesInConflictReasons.
- setAlsoBumpVariablesInConflictReasons
  
  public SatParameters.Builder setAlsoBumpVariablesInConflictReasons(boolean value)
  When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped. This is addition to the variables in the conflict, and the one that were used during conflict resolution.
  optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  Parameters:
  
  value - The alsoBumpVariablesInConflictReasons to set.
  
  Returns:
  
  This builder for chaining.
- clearAlsoBumpVariablesInConflictReasons
  
  public SatParameters.Builder clearAlsoBumpVariablesInConflictReasons()
  When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped. This is addition to the variables in the conflict, and the one that were used during conflict resolution.
  optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  Returns:
  
  This builder for chaining.
- hasMinimizationAlgorithm
  
  public boolean hasMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  
  Specified by:
  
  hasMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizationAlgorithm field is set.
- getMinimizationAlgorithm
  
  public SatParameters.ConflictMinimizationAlgorithm getMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  
  Specified by:
  
  getMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizationAlgorithm.
- setMinimizationAlgorithm
  
  public SatParameters.Builder setMinimizationAlgorithm(SatParameters.ConflictMinimizationAlgorithm value)
  
  optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  
  Parameters:
  
  value - The minimizationAlgorithm to set.
  
  Returns:
  
  This builder for chaining.
- clearMinimizationAlgorithm
  
  public SatParameters.Builder clearMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  
  Returns:
  
  This builder for chaining.
- hasBinaryMinimizationAlgorithm
  
  public boolean hasBinaryMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  
  Specified by:
  
  hasBinaryMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the binaryMinimizationAlgorithm field is set.
- getBinaryMinimizationAlgorithm
  
  public SatParameters.BinaryMinizationAlgorithm getBinaryMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  
  Specified by:
  
  getBinaryMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  The binaryMinimizationAlgorithm.
- setBinaryMinimizationAlgorithm
  
  public SatParameters.Builder setBinaryMinimizationAlgorithm(SatParameters.BinaryMinizationAlgorithm value)
  
  optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  
  Parameters:
  
  value - The binaryMinimizationAlgorithm to set.
  
  Returns:
  
  This builder for chaining.
- clearBinaryMinimizationAlgorithm
  
  public SatParameters.Builder clearBinaryMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  
  Returns:
  
  This builder for chaining.
- hasSubsumptionDuringConflictAnalysis
  
  public boolean hasSubsumptionDuringConflictAnalysis()
  At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict. When this is true, such clauses are detached and later removed from the problem.
  optional bool subsumption_during_conflict_analysis = 56 [default = true];
  Specified by:
  
  hasSubsumptionDuringConflictAnalysis in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the subsumptionDuringConflictAnalysis field is set.
- getSubsumptionDuringConflictAnalysis
  
  public boolean getSubsumptionDuringConflictAnalysis()
  At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict. When this is true, such clauses are detached and later removed from the problem.
  optional bool subsumption_during_conflict_analysis = 56 [default = true];
  Specified by:
  
  getSubsumptionDuringConflictAnalysis in interface SatParametersOrBuilder
  
  Returns:
  
  The subsumptionDuringConflictAnalysis.
- setSubsumptionDuringConflictAnalysis
  
  public SatParameters.Builder setSubsumptionDuringConflictAnalysis(boolean value)
  At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict. When this is true, such clauses are detached and later removed from the problem.
  optional bool subsumption_during_conflict_analysis = 56 [default = true];
  Parameters:
  
  value - The subsumptionDuringConflictAnalysis to set.
  
  Returns:
  
  This builder for chaining.
- clearSubsumptionDuringConflictAnalysis
  
  public SatParameters.Builder clearSubsumptionDuringConflictAnalysis()
  At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict. When this is true, such clauses are detached and later removed from the problem.
  optional bool subsumption_during_conflict_analysis = 56 [default = true];
  Returns:
  
  This builder for chaining.
- hasClauseCleanupPeriod
  
  public boolean hasClauseCleanupPeriod()
  Trigger a cleanup when this number of "deletable" clauses is learned.
  optional int32 clause_cleanup_period = 11 [default = 10000];
  Specified by:
  
  hasClauseCleanupPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupPeriod field is set.
- getClauseCleanupPeriod
  
  public int getClauseCleanupPeriod()
  Trigger a cleanup when this number of "deletable" clauses is learned.
  optional int32 clause_cleanup_period = 11 [default = 10000];
  Specified by:
  
  getClauseCleanupPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupPeriod.
- setClauseCleanupPeriod
  
  public SatParameters.Builder setClauseCleanupPeriod(int value)
  Trigger a cleanup when this number of "deletable" clauses is learned.
  optional int32 clause_cleanup_period = 11 [default = 10000];
  Parameters:
  
  value - The clauseCleanupPeriod to set.
  
  Returns:
  
  This builder for chaining.
- clearClauseCleanupPeriod
  
  public SatParameters.Builder clearClauseCleanupPeriod()
  Trigger a cleanup when this number of "deletable" clauses is learned.
  optional int32 clause_cleanup_period = 11 [default = 10000];
  Returns:
  
  This builder for chaining.
- hasClauseCleanupTarget
  
  public boolean hasClauseCleanupTarget()
  During a cleanup, we will always keep that number of "deletable" clauses. Note that this doesn't include the "protected" clauses.
  optional int32 clause_cleanup_target = 13 [default = 10000];
  Specified by:
  
  hasClauseCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupTarget field is set.
- getClauseCleanupTarget
  
  public int getClauseCleanupTarget()
  During a cleanup, we will always keep that number of "deletable" clauses. Note that this doesn't include the "protected" clauses.
  optional int32 clause_cleanup_target = 13 [default = 10000];
  Specified by:
  
  getClauseCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupTarget.
- setClauseCleanupTarget
  
  public SatParameters.Builder setClauseCleanupTarget(int value)
  During a cleanup, we will always keep that number of "deletable" clauses. Note that this doesn't include the "protected" clauses.
  optional int32 clause_cleanup_target = 13 [default = 10000];
  Parameters:
  
  value - The clauseCleanupTarget to set.
  
  Returns:
  
  This builder for chaining.
- clearClauseCleanupTarget
  
  public SatParameters.Builder clearClauseCleanupTarget()
  During a cleanup, we will always keep that number of "deletable" clauses. Note that this doesn't include the "protected" clauses.
  optional int32 clause_cleanup_target = 13 [default = 10000];
  Returns:
  
  This builder for chaining.
- hasClauseCleanupProtection
  
  public boolean hasClauseCleanupProtection()
  
  optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  
  Specified by:
  
  hasClauseCleanupProtection in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupProtection field is set.
- getClauseCleanupProtection
  
  public SatParameters.ClauseProtection getClauseCleanupProtection()
  
  optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  
  Specified by:
  
  getClauseCleanupProtection in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupProtection.
- setClauseCleanupProtection
  
  public SatParameters.Builder setClauseCleanupProtection(SatParameters.ClauseProtection value)
  
  optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  
  Parameters:
  
  value - The clauseCleanupProtection to set.
  
  Returns:
  
  This builder for chaining.
- clearClauseCleanupProtection
  
  public SatParameters.Builder clearClauseCleanupProtection()
  
  optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  
  Returns:
  
  This builder for chaining.
- hasClauseCleanupLbdBound
  
  public boolean hasClauseCleanupLbdBound()
  All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
  optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  Specified by:
  
  hasClauseCleanupLbdBound in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupLbdBound field is set.
- getClauseCleanupLbdBound
  
  public int getClauseCleanupLbdBound()
  All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
  optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  Specified by:
  
  getClauseCleanupLbdBound in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupLbdBound.
- setClauseCleanupLbdBound
  
  public SatParameters.Builder setClauseCleanupLbdBound(int value)
  All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
  optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  Parameters:
  
  value - The clauseCleanupLbdBound to set.
  
  Returns:
  
  This builder for chaining.
- clearClauseCleanupLbdBound
  
  public SatParameters.Builder clearClauseCleanupLbdBound()
  All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
  optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  Returns:
  
  This builder for chaining.
- hasClauseCleanupOrdering
  
  public boolean hasClauseCleanupOrdering()
  
  optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  
  Specified by:
  
  hasClauseCleanupOrdering in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupOrdering field is set.
- getClauseCleanupOrdering
  
  public SatParameters.ClauseOrdering getClauseCleanupOrdering()
  
  optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  
  Specified by:
  
  getClauseCleanupOrdering in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupOrdering.
- setClauseCleanupOrdering
  
  public SatParameters.Builder setClauseCleanupOrdering(SatParameters.ClauseOrdering value)
  
  optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  
  Parameters:
  
  value - The clauseCleanupOrdering to set.
  
  Returns:
  
  This builder for chaining.
- clearClauseCleanupOrdering
  
  public SatParameters.Builder clearClauseCleanupOrdering()
  
  optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  
  Returns:
  
  This builder for chaining.
- hasPbCleanupIncrement
  
  public boolean hasPbCleanupIncrement()
  Same as for the clauses, but for the learned pseudo-Boolean constraints.
  optional int32 pb_cleanup_increment = 46 [default = 200];
  Specified by:
  
  hasPbCleanupIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the pbCleanupIncrement field is set.
- getPbCleanupIncrement
  
  public int getPbCleanupIncrement()
  Same as for the clauses, but for the learned pseudo-Boolean constraints.
  optional int32 pb_cleanup_increment = 46 [default = 200];
  Specified by:
  
  getPbCleanupIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  The pbCleanupIncrement.
- setPbCleanupIncrement
  
  public SatParameters.Builder setPbCleanupIncrement(int value)
  Same as for the clauses, but for the learned pseudo-Boolean constraints.
  optional int32 pb_cleanup_increment = 46 [default = 200];
  Parameters:
  
  value - The pbCleanupIncrement to set.
  
  Returns:
  
  This builder for chaining.
- clearPbCleanupIncrement
  
  public SatParameters.Builder clearPbCleanupIncrement()
  Same as for the clauses, but for the learned pseudo-Boolean constraints.
  optional int32 pb_cleanup_increment = 46 [default = 200];
  Returns:
  
  This builder for chaining.
- hasPbCleanupRatio
  
  public boolean hasPbCleanupRatio()
  
  optional double pb_cleanup_ratio = 47 [default = 0.5];
  
  Specified by:
  
  hasPbCleanupRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the pbCleanupRatio field is set.
- getPbCleanupRatio
  
  public double getPbCleanupRatio()
  
  optional double pb_cleanup_ratio = 47 [default = 0.5];
  
  Specified by:
  
  getPbCleanupRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The pbCleanupRatio.
- setPbCleanupRatio
  
  public SatParameters.Builder setPbCleanupRatio(double value)
  
  optional double pb_cleanup_ratio = 47 [default = 0.5];
  
  Parameters:
  
  value - The pbCleanupRatio to set.
  
  Returns:
  
  This builder for chaining.
- clearPbCleanupRatio
  
  public SatParameters.Builder clearPbCleanupRatio()
  
  optional double pb_cleanup_ratio = 47 [default = 0.5];
  
  Returns:
  
  This builder for chaining.
- hasMinimizeWithPropagationRestartPeriod
  
  public boolean hasMinimizeWithPropagationRestartPeriod()
  Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization. The minimization technique is the same as the one used to minimize core in max-sat. We also minimize problem clauses and not just the learned clause that we keep forever like in the paper. Changing these parameters or the kind of clause we minimize seems to have a big impact on the overall perf on our benchmarks. So this technique seems definitely useful, but it is hard to tune properly.
  optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  Specified by:
  
  hasMinimizeWithPropagationRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeWithPropagationRestartPeriod field is set.
- getMinimizeWithPropagationRestartPeriod
  
  public int getMinimizeWithPropagationRestartPeriod()
  Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization. The minimization technique is the same as the one used to minimize core in max-sat. We also minimize problem clauses and not just the learned clause that we keep forever like in the paper. Changing these parameters or the kind of clause we minimize seems to have a big impact on the overall perf on our benchmarks. So this technique seems definitely useful, but it is hard to tune properly.
  optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  Specified by:
  
  getMinimizeWithPropagationRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeWithPropagationRestartPeriod.
- setMinimizeWithPropagationRestartPeriod
  
  public SatParameters.Builder setMinimizeWithPropagationRestartPeriod(int value)
  Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization. The minimization technique is the same as the one used to minimize core in max-sat. We also minimize problem clauses and not just the learned clause that we keep forever like in the paper. Changing these parameters or the kind of clause we minimize seems to have a big impact on the overall perf on our benchmarks. So this technique seems definitely useful, but it is hard to tune properly.
  optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  Parameters:
  
  value - The minimizeWithPropagationRestartPeriod to set.
  
  Returns:
  
  This builder for chaining.
- clearMinimizeWithPropagationRestartPeriod
  
  public SatParameters.Builder clearMinimizeWithPropagationRestartPeriod()
  Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization. The minimization technique is the same as the one used to minimize core in max-sat. We also minimize problem clauses and not just the learned clause that we keep forever like in the paper. Changing these parameters or the kind of clause we minimize seems to have a big impact on the overall perf on our benchmarks. So this technique seems definitely useful, but it is hard to tune properly.
  optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  Returns:
  
  This builder for chaining.
- hasMinimizeWithPropagationNumDecisions
  
  public boolean hasMinimizeWithPropagationNumDecisions()
  
  optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  
  Specified by:
  
  hasMinimizeWithPropagationNumDecisions in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeWithPropagationNumDecisions field is set.
- getMinimizeWithPropagationNumDecisions
  
  public int getMinimizeWithPropagationNumDecisions()
  
  optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  
  Specified by:
  
  getMinimizeWithPropagationNumDecisions in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeWithPropagationNumDecisions.
- setMinimizeWithPropagationNumDecisions
  
  public SatParameters.Builder setMinimizeWithPropagationNumDecisions(int value)
  
  optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  
  Parameters:
  
  value - The minimizeWithPropagationNumDecisions to set.
  
  Returns:
  
  This builder for chaining.
- clearMinimizeWithPropagationNumDecisions
  
  public SatParameters.Builder clearMinimizeWithPropagationNumDecisions()
  
  optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  
  Returns:
  
  This builder for chaining.
- hasVariableActivityDecay
  
  public boolean hasVariableActivityDecay()
  Each time a conflict is found, the activities of some variables are increased by one. Then, the activity of all variables are multiplied by variable_activity_decay. To implement this efficiently, the activity of all the variables is not decayed at each conflict. Instead, the activity increment is multiplied by 1 / decay. When an activity reach max_variable_activity_value, all the activity are multiplied by 1 / max_variable_activity_value.
  optional double variable_activity_decay = 15 [default = 0.8];
  Specified by:
  
  hasVariableActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the variableActivityDecay field is set.
- getVariableActivityDecay
  
  public double getVariableActivityDecay()
  Each time a conflict is found, the activities of some variables are increased by one. Then, the activity of all variables are multiplied by variable_activity_decay. To implement this efficiently, the activity of all the variables is not decayed at each conflict. Instead, the activity increment is multiplied by 1 / decay. When an activity reach max_variable_activity_value, all the activity are multiplied by 1 / max_variable_activity_value.
  optional double variable_activity_decay = 15 [default = 0.8];
  Specified by:
  
  getVariableActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The variableActivityDecay.
- setVariableActivityDecay
  
  public SatParameters.Builder setVariableActivityDecay(double value)
  Each time a conflict is found, the activities of some variables are increased by one. Then, the activity of all variables are multiplied by variable_activity_decay. To implement this efficiently, the activity of all the variables is not decayed at each conflict. Instead, the activity increment is multiplied by 1 / decay. When an activity reach max_variable_activity_value, all the activity are multiplied by 1 / max_variable_activity_value.
  optional double variable_activity_decay = 15 [default = 0.8];
  Parameters:
  
  value - The variableActivityDecay to set.
  
  Returns:
  
  This builder for chaining.
- clearVariableActivityDecay
  
  public SatParameters.Builder clearVariableActivityDecay()
  Each time a conflict is found, the activities of some variables are increased by one. Then, the activity of all variables are multiplied by variable_activity_decay. To implement this efficiently, the activity of all the variables is not decayed at each conflict. Instead, the activity increment is multiplied by 1 / decay. When an activity reach max_variable_activity_value, all the activity are multiplied by 1 / max_variable_activity_value.
  optional double variable_activity_decay = 15 [default = 0.8];
  Returns:
  
  This builder for chaining.
- hasMaxVariableActivityValue
  
  public boolean hasMaxVariableActivityValue()
  
  optional double max_variable_activity_value = 16 [default = 1e+100];
  
  Specified by:
  
  hasMaxVariableActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxVariableActivityValue field is set.
- getMaxVariableActivityValue
  
  public double getMaxVariableActivityValue()
  
  optional double max_variable_activity_value = 16 [default = 1e+100];
  
  Specified by:
  
  getMaxVariableActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  The maxVariableActivityValue.
- setMaxVariableActivityValue
  
  public SatParameters.Builder setMaxVariableActivityValue(double value)
  
  optional double max_variable_activity_value = 16 [default = 1e+100];
  
  Parameters:
  
  value - The maxVariableActivityValue to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxVariableActivityValue
  
  public SatParameters.Builder clearMaxVariableActivityValue()
  
  optional double max_variable_activity_value = 16 [default = 1e+100];
  
  Returns:
  
  This builder for chaining.
- hasGlucoseMaxDecay
  
  public boolean hasGlucoseMaxDecay()
  The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95. This "hack" seems to work well and comes from: Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013 http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
  optional double glucose_max_decay = 22 [default = 0.95];
  Specified by:
  
  hasGlucoseMaxDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the glucoseMaxDecay field is set.
- getGlucoseMaxDecay
  
  public double getGlucoseMaxDecay()
  The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95. This "hack" seems to work well and comes from: Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013 http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
  optional double glucose_max_decay = 22 [default = 0.95];
  Specified by:
  
  getGlucoseMaxDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The glucoseMaxDecay.
- setGlucoseMaxDecay
  
  public SatParameters.Builder setGlucoseMaxDecay(double value)
  The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95. This "hack" seems to work well and comes from: Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013 http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
  optional double glucose_max_decay = 22 [default = 0.95];
  Parameters:
  
  value - The glucoseMaxDecay to set.
  
  Returns:
  
  This builder for chaining.
- clearGlucoseMaxDecay
  
  public SatParameters.Builder clearGlucoseMaxDecay()
  The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95. This "hack" seems to work well and comes from: Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013 http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
  optional double glucose_max_decay = 22 [default = 0.95];
  Returns:
  
  This builder for chaining.
- hasGlucoseDecayIncrement
  
  public boolean hasGlucoseDecayIncrement()
  
  optional double glucose_decay_increment = 23 [default = 0.01];
  
  Specified by:
  
  hasGlucoseDecayIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the glucoseDecayIncrement field is set.
- getGlucoseDecayIncrement
  
  public double getGlucoseDecayIncrement()
  
  optional double glucose_decay_increment = 23 [default = 0.01];
  
  Specified by:
  
  getGlucoseDecayIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  The glucoseDecayIncrement.
- setGlucoseDecayIncrement
  
  public SatParameters.Builder setGlucoseDecayIncrement(double value)
  
  optional double glucose_decay_increment = 23 [default = 0.01];
  
  Parameters:
  
  value - The glucoseDecayIncrement to set.
  
  Returns:
  
  This builder for chaining.
- clearGlucoseDecayIncrement
  
  public SatParameters.Builder clearGlucoseDecayIncrement()
  
  optional double glucose_decay_increment = 23 [default = 0.01];
  
  Returns:
  
  This builder for chaining.
- hasGlucoseDecayIncrementPeriod
  
  public boolean hasGlucoseDecayIncrementPeriod()
  
  optional int32 glucose_decay_increment_period = 24 [default = 5000];
  
  Specified by:
  
  hasGlucoseDecayIncrementPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the glucoseDecayIncrementPeriod field is set.
- getGlucoseDecayIncrementPeriod
  
  public int getGlucoseDecayIncrementPeriod()
  
  optional int32 glucose_decay_increment_period = 24 [default = 5000];
  
  Specified by:
  
  getGlucoseDecayIncrementPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The glucoseDecayIncrementPeriod.
- setGlucoseDecayIncrementPeriod
  
  public SatParameters.Builder setGlucoseDecayIncrementPeriod(int value)
  
  optional int32 glucose_decay_increment_period = 24 [default = 5000];
  
  Parameters:
  
  value - The glucoseDecayIncrementPeriod to set.
  
  Returns:
  
  This builder for chaining.
- clearGlucoseDecayIncrementPeriod
  
  public SatParameters.Builder clearGlucoseDecayIncrementPeriod()
  
  optional int32 glucose_decay_increment_period = 24 [default = 5000];
  
  Returns:
  
  This builder for chaining.
- hasClauseActivityDecay
  
  public boolean hasClauseActivityDecay()
  Clause activity parameters (same effect as the one on the variables).
  optional double clause_activity_decay = 17 [default = 0.999];
  Specified by:
  
  hasClauseActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseActivityDecay field is set.
- getClauseActivityDecay
  
  public double getClauseActivityDecay()
  Clause activity parameters (same effect as the one on the variables).
  optional double clause_activity_decay = 17 [default = 0.999];
  Specified by:
  
  getClauseActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseActivityDecay.
- setClauseActivityDecay
  
  public SatParameters.Builder setClauseActivityDecay(double value)
  Clause activity parameters (same effect as the one on the variables).
  optional double clause_activity_decay = 17 [default = 0.999];
  Parameters:
  
  value - The clauseActivityDecay to set.
  
  Returns:
  
  This builder for chaining.
- clearClauseActivityDecay
  
  public SatParameters.Builder clearClauseActivityDecay()
  Clause activity parameters (same effect as the one on the variables).
  optional double clause_activity_decay = 17 [default = 0.999];
  Returns:
  
  This builder for chaining.
- hasMaxClauseActivityValue
  
  public boolean hasMaxClauseActivityValue()
  
  optional double max_clause_activity_value = 18 [default = 1e+20];
  
  Specified by:
  
  hasMaxClauseActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxClauseActivityValue field is set.
- getMaxClauseActivityValue
  
  public double getMaxClauseActivityValue()
  
  optional double max_clause_activity_value = 18 [default = 1e+20];
  
  Specified by:
  
  getMaxClauseActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  The maxClauseActivityValue.
- setMaxClauseActivityValue
  
  public SatParameters.Builder setMaxClauseActivityValue(double value)
  
  optional double max_clause_activity_value = 18 [default = 1e+20];
  
  Parameters:
  
  value - The maxClauseActivityValue to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxClauseActivityValue
  
  public SatParameters.Builder clearMaxClauseActivityValue()
  
  optional double max_clause_activity_value = 18 [default = 1e+20];
  
  Returns:
  
  This builder for chaining.
- getRestartAlgorithmsList
  
  public java.util.List<SatParameters.RestartAlgorithm> getRestartAlgorithmsList()
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Specified by:
  
  getRestartAlgorithmsList in interface SatParametersOrBuilder
  
  Returns:
  
  A list containing the restartAlgorithms.
- getRestartAlgorithmsCount
  
  public int getRestartAlgorithmsCount()
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Specified by:
  
  getRestartAlgorithmsCount in interface SatParametersOrBuilder
  
  Returns:
  
  The count of restartAlgorithms.
- getRestartAlgorithms
  
  public SatParameters.RestartAlgorithm getRestartAlgorithms(int index)
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Specified by:
  
  getRestartAlgorithms in interface SatParametersOrBuilder
  
  Parameters:
  
  index - The index of the element to return.
  
  Returns:
  
  The restartAlgorithms at the given index.
- setRestartAlgorithms
  
  public SatParameters.Builder setRestartAlgorithms(int index, SatParameters.RestartAlgorithm value)
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Parameters:
  
  index - The index to set the value at.
  
  value - The restartAlgorithms to set.
  
  Returns:
  
  This builder for chaining.
- addRestartAlgorithms
  
  public SatParameters.Builder addRestartAlgorithms(SatParameters.RestartAlgorithm value)
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Parameters:
  
  value - The restartAlgorithms to add.
  
  Returns:
  
  This builder for chaining.
- addAllRestartAlgorithms
  
  public SatParameters.Builder addAllRestartAlgorithms(java.lang.Iterable<? extends SatParameters.RestartAlgorithm> values)
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Parameters:
  
  values - The restartAlgorithms to add.
  
  Returns:
  
  This builder for chaining.
- clearRestartAlgorithms
  
  public SatParameters.Builder clearRestartAlgorithms()
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Returns:
  
  This builder for chaining.
- hasDefaultRestartAlgorithms
  
  public boolean hasDefaultRestartAlgorithms()
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Specified by:
  
  hasDefaultRestartAlgorithms in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the defaultRestartAlgorithms field is set.
- getDefaultRestartAlgorithms
  
  public java.lang.String getDefaultRestartAlgorithms()
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Specified by:
  
  getDefaultRestartAlgorithms in interface SatParametersOrBuilder
  
  Returns:
  
  The defaultRestartAlgorithms.
- getDefaultRestartAlgorithmsBytes
  
  public com.google.protobuf.ByteString getDefaultRestartAlgorithmsBytes()
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Specified by:
  
  getDefaultRestartAlgorithmsBytes in interface SatParametersOrBuilder
  
  Returns:
  
  The bytes for defaultRestartAlgorithms.
- setDefaultRestartAlgorithms
  
  public SatParameters.Builder setDefaultRestartAlgorithms(java.lang.String value)
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Parameters:
  
  value - The defaultRestartAlgorithms to set.
  
  Returns:
  
  This builder for chaining.
- clearDefaultRestartAlgorithms
  
  public SatParameters.Builder clearDefaultRestartAlgorithms()
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Returns:
  
  This builder for chaining.
- setDefaultRestartAlgorithmsBytes
  
  public SatParameters.Builder setDefaultRestartAlgorithmsBytes(com.google.protobuf.ByteString value)
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Parameters:
  
  value - The bytes for defaultRestartAlgorithms to set.
  
  Returns:
  
  This builder for chaining.
- hasRestartPeriod
  
  public boolean hasRestartPeriod()
  Restart period for the FIXED_RESTART strategy. This is also the multiplier used by the LUBY_RESTART strategy.
  optional int32 restart_period = 30 [default = 50];
  Specified by:
  
  hasRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartPeriod field is set.
- getRestartPeriod
  
  public int getRestartPeriod()
  Restart period for the FIXED_RESTART strategy. This is also the multiplier used by the LUBY_RESTART strategy.
  optional int32 restart_period = 30 [default = 50];
  Specified by:
  
  getRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The restartPeriod.
- setRestartPeriod
  
  public SatParameters.Builder setRestartPeriod(int value)
  Restart period for the FIXED_RESTART strategy. This is also the multiplier used by the LUBY_RESTART strategy.
  optional int32 restart_period = 30 [default = 50];
  Parameters:
  
  value - The restartPeriod to set.
  
  Returns:
  
  This builder for chaining.
- clearRestartPeriod
  
  public SatParameters.Builder clearRestartPeriod()
  Restart period for the FIXED_RESTART strategy. This is also the multiplier used by the LUBY_RESTART strategy.
  optional int32 restart_period = 30 [default = 50];
  Returns:
  
  This builder for chaining.
- hasRestartRunningWindowSize
  
  public boolean hasRestartRunningWindowSize()
  Size of the window for the moving average restarts.
  optional int32 restart_running_window_size = 62 [default = 50];
  Specified by:
  
  hasRestartRunningWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartRunningWindowSize field is set.
- getRestartRunningWindowSize
  
  public int getRestartRunningWindowSize()
  Size of the window for the moving average restarts.
  optional int32 restart_running_window_size = 62 [default = 50];
  Specified by:
  
  getRestartRunningWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  The restartRunningWindowSize.
- setRestartRunningWindowSize
  
  public SatParameters.Builder setRestartRunningWindowSize(int value)
  Size of the window for the moving average restarts.
  optional int32 restart_running_window_size = 62 [default = 50];
  Parameters:
  
  value - The restartRunningWindowSize to set.
  
  Returns:
  
  This builder for chaining.
- clearRestartRunningWindowSize
  
  public SatParameters.Builder clearRestartRunningWindowSize()
  Size of the window for the moving average restarts.
  optional int32 restart_running_window_size = 62 [default = 50];
  Returns:
  
  This builder for chaining.
- hasRestartDlAverageRatio
  
  public boolean hasRestartDlAverageRatio()
  In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
  optional double restart_dl_average_ratio = 63 [default = 1];
  Specified by:
  
  hasRestartDlAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartDlAverageRatio field is set.
- getRestartDlAverageRatio
  
  public double getRestartDlAverageRatio()
  In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
  optional double restart_dl_average_ratio = 63 [default = 1];
  Specified by:
  
  getRestartDlAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The restartDlAverageRatio.
- setRestartDlAverageRatio
  
  public SatParameters.Builder setRestartDlAverageRatio(double value)
  In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
  optional double restart_dl_average_ratio = 63 [default = 1];
  Parameters:
  
  value - The restartDlAverageRatio to set.
  
  Returns:
  
  This builder for chaining.
- clearRestartDlAverageRatio
  
  public SatParameters.Builder clearRestartDlAverageRatio()
  In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
  optional double restart_dl_average_ratio = 63 [default = 1];
  Returns:
  
  This builder for chaining.
- hasRestartLbdAverageRatio
  
  public boolean hasRestartLbdAverageRatio()
  
  optional double restart_lbd_average_ratio = 71 [default = 1];
  
  Specified by:
  
  hasRestartLbdAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartLbdAverageRatio field is set.
- getRestartLbdAverageRatio
  
  public double getRestartLbdAverageRatio()
  
  optional double restart_lbd_average_ratio = 71 [default = 1];
  
  Specified by:
  
  getRestartLbdAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The restartLbdAverageRatio.
- setRestartLbdAverageRatio
  
  public SatParameters.Builder setRestartLbdAverageRatio(double value)
  
  optional double restart_lbd_average_ratio = 71 [default = 1];
  
  Parameters:
  
  value - The restartLbdAverageRatio to set.
  
  Returns:
  
  This builder for chaining.
- clearRestartLbdAverageRatio
  
  public SatParameters.Builder clearRestartLbdAverageRatio()
  
  optional double restart_lbd_average_ratio = 71 [default = 1];
  
  Returns:
  
  This builder for chaining.
- hasUseBlockingRestart
  
  public boolean hasUseBlockingRestart()
  Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
  optional bool use_blocking_restart = 64 [default = false];
  Specified by:
  
  hasUseBlockingRestart in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useBlockingRestart field is set.
- getUseBlockingRestart
  
  public boolean getUseBlockingRestart()
  Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
  optional bool use_blocking_restart = 64 [default = false];
  Specified by:
  
  getUseBlockingRestart in interface SatParametersOrBuilder
  
  Returns:
  
  The useBlockingRestart.
- setUseBlockingRestart
  
  public SatParameters.Builder setUseBlockingRestart(boolean value)
  Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
  optional bool use_blocking_restart = 64 [default = false];
  Parameters:
  
  value - The useBlockingRestart to set.
  
  Returns:
  
  This builder for chaining.
- clearUseBlockingRestart
  
  public SatParameters.Builder clearUseBlockingRestart()
  Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
  optional bool use_blocking_restart = 64 [default = false];
  Returns:
  
  This builder for chaining.
- hasBlockingRestartWindowSize
  
  public boolean hasBlockingRestartWindowSize()
  
  optional int32 blocking_restart_window_size = 65 [default = 5000];
  
  Specified by:
  
  hasBlockingRestartWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the blockingRestartWindowSize field is set.
- getBlockingRestartWindowSize
  
  public int getBlockingRestartWindowSize()
  
  optional int32 blocking_restart_window_size = 65 [default = 5000];
  
  Specified by:
  
  getBlockingRestartWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  The blockingRestartWindowSize.
- setBlockingRestartWindowSize
  
  public SatParameters.Builder setBlockingRestartWindowSize(int value)
  
  optional int32 blocking_restart_window_size = 65 [default = 5000];
  
  Parameters:
  
  value - The blockingRestartWindowSize to set.
  
  Returns:
  
  This builder for chaining.
- clearBlockingRestartWindowSize
  
  public SatParameters.Builder clearBlockingRestartWindowSize()
  
  optional int32 blocking_restart_window_size = 65 [default = 5000];
  
  Returns:
  
  This builder for chaining.
- hasBlockingRestartMultiplier
  
  public boolean hasBlockingRestartMultiplier()
  
  optional double blocking_restart_multiplier = 66 [default = 1.4];
  
  Specified by:
  
  hasBlockingRestartMultiplier in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the blockingRestartMultiplier field is set.
- getBlockingRestartMultiplier
  
  public double getBlockingRestartMultiplier()
  
  optional double blocking_restart_multiplier = 66 [default = 1.4];
  
  Specified by:
  
  getBlockingRestartMultiplier in interface SatParametersOrBuilder
  
  Returns:
  
  The blockingRestartMultiplier.
- setBlockingRestartMultiplier
  
  public SatParameters.Builder setBlockingRestartMultiplier(double value)
  
  optional double blocking_restart_multiplier = 66 [default = 1.4];
  
  Parameters:
  
  value - The blockingRestartMultiplier to set.
  
  Returns:
  
  This builder for chaining.
- clearBlockingRestartMultiplier
  
  public SatParameters.Builder clearBlockingRestartMultiplier()
  
  optional double blocking_restart_multiplier = 66 [default = 1.4];
  
  Returns:
  
  This builder for chaining.
- hasNumConflictsBeforeStrategyChanges
  
  public boolean hasNumConflictsBeforeStrategyChanges()
  After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
  optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  Specified by:
  
  hasNumConflictsBeforeStrategyChanges in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the numConflictsBeforeStrategyChanges field is set.
- getNumConflictsBeforeStrategyChanges
  
  public int getNumConflictsBeforeStrategyChanges()
  After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
  optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  Specified by:
  
  getNumConflictsBeforeStrategyChanges in interface SatParametersOrBuilder
  
  Returns:
  
  The numConflictsBeforeStrategyChanges.
- setNumConflictsBeforeStrategyChanges
  
  public SatParameters.Builder setNumConflictsBeforeStrategyChanges(int value)
  After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
  optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  Parameters:
  
  value - The numConflictsBeforeStrategyChanges to set.
  
  Returns:
  
  This builder for chaining.
- clearNumConflictsBeforeStrategyChanges
  
  public SatParameters.Builder clearNumConflictsBeforeStrategyChanges()
  After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
  optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  Returns:
  
  This builder for chaining.
- hasStrategyChangeIncreaseRatio
  
  public boolean hasStrategyChangeIncreaseRatio()
  The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
  optional double strategy_change_increase_ratio = 69 [default = 0];
  Specified by:
  
  hasStrategyChangeIncreaseRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the strategyChangeIncreaseRatio field is set.
- getStrategyChangeIncreaseRatio
  
  public double getStrategyChangeIncreaseRatio()
  The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
  optional double strategy_change_increase_ratio = 69 [default = 0];
  Specified by:
  
  getStrategyChangeIncreaseRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The strategyChangeIncreaseRatio.
- setStrategyChangeIncreaseRatio
  
  public SatParameters.Builder setStrategyChangeIncreaseRatio(double value)
  The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
  optional double strategy_change_increase_ratio = 69 [default = 0];
  Parameters:
  
  value - The strategyChangeIncreaseRatio to set.
  
  Returns:
  
  This builder for chaining.
- clearStrategyChangeIncreaseRatio
  
  public SatParameters.Builder clearStrategyChangeIncreaseRatio()
  The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
  optional double strategy_change_increase_ratio = 69 [default = 0];
  Returns:
  
  This builder for chaining.
- hasMaxTimeInSeconds
  
  public boolean hasMaxTimeInSeconds()
  Maximum time allowed in seconds to solve a problem. The counter will starts at the beginning of the Solve() call.
  optional double max_time_in_seconds = 36 [default = inf];
  Specified by:
  
  hasMaxTimeInSeconds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxTimeInSeconds field is set.
- getMaxTimeInSeconds
  
  public double getMaxTimeInSeconds()
  Maximum time allowed in seconds to solve a problem. The counter will starts at the beginning of the Solve() call.
  optional double max_time_in_seconds = 36 [default = inf];
  Specified by:
  
  getMaxTimeInSeconds in interface SatParametersOrBuilder
  
  Returns:
  
  The maxTimeInSeconds.
- setMaxTimeInSeconds
  
  public SatParameters.Builder setMaxTimeInSeconds(double value)
  Maximum time allowed in seconds to solve a problem. The counter will starts at the beginning of the Solve() call.
  optional double max_time_in_seconds = 36 [default = inf];
  Parameters:
  
  value - The maxTimeInSeconds to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxTimeInSeconds
  
  public SatParameters.Builder clearMaxTimeInSeconds()
  Maximum time allowed in seconds to solve a problem. The counter will starts at the beginning of the Solve() call.
  optional double max_time_in_seconds = 36 [default = inf];
  Returns:
  
  This builder for chaining.
- hasMaxDeterministicTime
  
  public boolean hasMaxDeterministicTime()
  Maximum time allowed in deterministic time to solve a problem. The deterministic time should be correlated with the real time used by the solver, the time unit being as close as possible to a second.
  optional double max_deterministic_time = 67 [default = inf];
  Specified by:
  
  hasMaxDeterministicTime in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxDeterministicTime field is set.
- getMaxDeterministicTime
  
  public double getMaxDeterministicTime()
  Maximum time allowed in deterministic time to solve a problem. The deterministic time should be correlated with the real time used by the solver, the time unit being as close as possible to a second.
  optional double max_deterministic_time = 67 [default = inf];
  Specified by:
  
  getMaxDeterministicTime in interface SatParametersOrBuilder
  
  Returns:
  
  The maxDeterministicTime.
- setMaxDeterministicTime
  
  public SatParameters.Builder setMaxDeterministicTime(double value)
  Maximum time allowed in deterministic time to solve a problem. The deterministic time should be correlated with the real time used by the solver, the time unit being as close as possible to a second.
  optional double max_deterministic_time = 67 [default = inf];
  Parameters:
  
  value - The maxDeterministicTime to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxDeterministicTime
  
  public SatParameters.Builder clearMaxDeterministicTime()
  Maximum time allowed in deterministic time to solve a problem. The deterministic time should be correlated with the real time used by the solver, the time unit being as close as possible to a second.
  optional double max_deterministic_time = 67 [default = inf];
  Returns:
  
  This builder for chaining.
- hasMaxNumberOfConflicts
  
  public boolean hasMaxNumberOfConflicts()
  Maximum number of conflicts allowed to solve a problem. TODO(user,user): Maybe change the way the conflict limit is enforced? currently it is enforced on each independent internal SAT solve, rather than on the overall number of conflicts across all solves. So in the context of an optimization problem, this is not really usable directly by a client.
  optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  Specified by:
  
  hasMaxNumberOfConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxNumberOfConflicts field is set.
- getMaxNumberOfConflicts
  
  public long getMaxNumberOfConflicts()
  Maximum number of conflicts allowed to solve a problem. TODO(user,user): Maybe change the way the conflict limit is enforced? currently it is enforced on each independent internal SAT solve, rather than on the overall number of conflicts across all solves. So in the context of an optimization problem, this is not really usable directly by a client.
  optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  Specified by:
  
  getMaxNumberOfConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  The maxNumberOfConflicts.
- setMaxNumberOfConflicts
  
  public SatParameters.Builder setMaxNumberOfConflicts(long value)
  Maximum number of conflicts allowed to solve a problem. TODO(user,user): Maybe change the way the conflict limit is enforced? currently it is enforced on each independent internal SAT solve, rather than on the overall number of conflicts across all solves. So in the context of an optimization problem, this is not really usable directly by a client.
  optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  Parameters:
  
  value - The maxNumberOfConflicts to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxNumberOfConflicts
  
  public SatParameters.Builder clearMaxNumberOfConflicts()
  Maximum number of conflicts allowed to solve a problem. TODO(user,user): Maybe change the way the conflict limit is enforced? currently it is enforced on each independent internal SAT solve, rather than on the overall number of conflicts across all solves. So in the context of an optimization problem, this is not really usable directly by a client.
  optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  Returns:
  
  This builder for chaining.
- hasMaxMemoryInMb
  
  public boolean hasMaxMemoryInMb()
  Maximum memory allowed for the whole thread containing the solver. The solver will abort as soon as it detects that this limit is crossed. As a result, this limit is approximative, but usually the solver will not go too much over.
  optional int64 max_memory_in_mb = 40 [default = 10000];
  Specified by:
  
  hasMaxMemoryInMb in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxMemoryInMb field is set.
- getMaxMemoryInMb
  
  public long getMaxMemoryInMb()
  Maximum memory allowed for the whole thread containing the solver. The solver will abort as soon as it detects that this limit is crossed. As a result, this limit is approximative, but usually the solver will not go too much over.
  optional int64 max_memory_in_mb = 40 [default = 10000];
  Specified by:
  
  getMaxMemoryInMb in interface SatParametersOrBuilder
  
  Returns:
  
  The maxMemoryInMb.
- setMaxMemoryInMb
  
  public SatParameters.Builder setMaxMemoryInMb(long value)
  Maximum memory allowed for the whole thread containing the solver. The solver will abort as soon as it detects that this limit is crossed. As a result, this limit is approximative, but usually the solver will not go too much over.
  optional int64 max_memory_in_mb = 40 [default = 10000];
  Parameters:
  
  value - The maxMemoryInMb to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxMemoryInMb
  
  public SatParameters.Builder clearMaxMemoryInMb()
  Maximum memory allowed for the whole thread containing the solver. The solver will abort as soon as it detects that this limit is crossed. As a result, this limit is approximative, but usually the solver will not go too much over.
  optional int64 max_memory_in_mb = 40 [default = 10000];
  Returns:
  
  This builder for chaining.
- hasAbsoluteGapLimit
  
  public boolean hasAbsoluteGapLimit()
  Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit. The exact definition is: - Absolute: abs(O - B) - Relative: abs(O - B) / max(1, abs(O)). Important: The relative gap depends on the objective offset! If you artificially shift the objective, you will get widely different value of the relative gap. Note that if the gap is reached, the search status will be OPTIMAL. But one can check the best objective bound to see the actual gap.
  optional double absolute_gap_limit = 159 [default = 0];
  Specified by:
  
  hasAbsoluteGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the absoluteGapLimit field is set.
- getAbsoluteGapLimit
  
  public double getAbsoluteGapLimit()
  Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit. The exact definition is: - Absolute: abs(O - B) - Relative: abs(O - B) / max(1, abs(O)). Important: The relative gap depends on the objective offset! If you artificially shift the objective, you will get widely different value of the relative gap. Note that if the gap is reached, the search status will be OPTIMAL. But one can check the best objective bound to see the actual gap.
  optional double absolute_gap_limit = 159 [default = 0];
  Specified by:
  
  getAbsoluteGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The absoluteGapLimit.
- setAbsoluteGapLimit
  
  public SatParameters.Builder setAbsoluteGapLimit(double value)
  Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit. The exact definition is: - Absolute: abs(O - B) - Relative: abs(O - B) / max(1, abs(O)). Important: The relative gap depends on the objective offset! If you artificially shift the objective, you will get widely different value of the relative gap. Note that if the gap is reached, the search status will be OPTIMAL. But one can check the best objective bound to see the actual gap.
  optional double absolute_gap_limit = 159 [default = 0];
  Parameters:
  
  value - The absoluteGapLimit to set.
  
  Returns:
  
  This builder for chaining.
- clearAbsoluteGapLimit
  
  public SatParameters.Builder clearAbsoluteGapLimit()
  Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit. The exact definition is: - Absolute: abs(O - B) - Relative: abs(O - B) / max(1, abs(O)). Important: The relative gap depends on the objective offset! If you artificially shift the objective, you will get widely different value of the relative gap. Note that if the gap is reached, the search status will be OPTIMAL. But one can check the best objective bound to see the actual gap.
  optional double absolute_gap_limit = 159 [default = 0];
  Returns:
  
  This builder for chaining.
- hasRelativeGapLimit
  
  public boolean hasRelativeGapLimit()
  
  optional double relative_gap_limit = 160 [default = 0];
  
  Specified by:
  
  hasRelativeGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the relativeGapLimit field is set.
- getRelativeGapLimit
  
  public double getRelativeGapLimit()
  
  optional double relative_gap_limit = 160 [default = 0];
  
  Specified by:
  
  getRelativeGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The relativeGapLimit.
- setRelativeGapLimit
  
  public SatParameters.Builder setRelativeGapLimit(double value)
  
  optional double relative_gap_limit = 160 [default = 0];
  
  Parameters:
  
  value - The relativeGapLimit to set.
  
  Returns:
  
  This builder for chaining.
- clearRelativeGapLimit
  
  public SatParameters.Builder clearRelativeGapLimit()
  
  optional double relative_gap_limit = 160 [default = 0];
  
  Returns:
  
  This builder for chaining.
- hasTreatBinaryClausesSeparately
  
  public boolean hasTreatBinaryClausesSeparately()
  If true, the binary clauses are treated separately from the others. This should be faster and uses less memory. However it changes the propagation order.
  optional bool treat_binary_clauses_separately = 33 [default = true];
  Specified by:
  
  hasTreatBinaryClausesSeparately in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the treatBinaryClausesSeparately field is set.
- getTreatBinaryClausesSeparately
  
  public boolean getTreatBinaryClausesSeparately()
  If true, the binary clauses are treated separately from the others. This should be faster and uses less memory. However it changes the propagation order.
  optional bool treat_binary_clauses_separately = 33 [default = true];
  Specified by:
  
  getTreatBinaryClausesSeparately in interface SatParametersOrBuilder
  
  Returns:
  
  The treatBinaryClausesSeparately.
- setTreatBinaryClausesSeparately
  
  public SatParameters.Builder setTreatBinaryClausesSeparately(boolean value)
  If true, the binary clauses are treated separately from the others. This should be faster and uses less memory. However it changes the propagation order.
  optional bool treat_binary_clauses_separately = 33 [default = true];
  Parameters:
  
  value - The treatBinaryClausesSeparately to set.
  
  Returns:
  
  This builder for chaining.
- clearTreatBinaryClausesSeparately
  
  public SatParameters.Builder clearTreatBinaryClausesSeparately()
  If true, the binary clauses are treated separately from the others. This should be faster and uses less memory. However it changes the propagation order.
  optional bool treat_binary_clauses_separately = 33 [default = true];
  Returns:
  
  This builder for chaining.
- hasRandomSeed
  
  public boolean hasRandomSeed()
  At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed. If you change the random seed, the solver may make different choices during the solving process. For some problems, the running time may vary a lot depending on small change in the solving algorithm. Running the solver with different seeds enables to have more robust benchmarks when evaluating new features.
  optional int32 random_seed = 31 [default = 1];
  Specified by:
  
  hasRandomSeed in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomSeed field is set.
- getRandomSeed
  
  public int getRandomSeed()
  At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed. If you change the random seed, the solver may make different choices during the solving process. For some problems, the running time may vary a lot depending on small change in the solving algorithm. Running the solver with different seeds enables to have more robust benchmarks when evaluating new features.
  optional int32 random_seed = 31 [default = 1];
  Specified by:
  
  getRandomSeed in interface SatParametersOrBuilder
  
  Returns:
  
  The randomSeed.
- setRandomSeed
  
  public SatParameters.Builder setRandomSeed(int value)
  At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed. If you change the random seed, the solver may make different choices during the solving process. For some problems, the running time may vary a lot depending on small change in the solving algorithm. Running the solver with different seeds enables to have more robust benchmarks when evaluating new features.
  optional int32 random_seed = 31 [default = 1];
  Parameters:
  
  value - The randomSeed to set.
  
  Returns:
  
  This builder for chaining.
- clearRandomSeed
  
  public SatParameters.Builder clearRandomSeed()
  At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed. If you change the random seed, the solver may make different choices during the solving process. For some problems, the running time may vary a lot depending on small change in the solving algorithm. Running the solver with different seeds enables to have more robust benchmarks when evaluating new features.
  optional int32 random_seed = 31 [default = 1];
  Returns:
  
  This builder for chaining.
- hasPermuteVariableRandomly
  
  public boolean hasPermuteVariableRandomly()
  This is mainly here to test the solver variability. Note that in tests, if not explicitly set to false, all 3 options will be set to true so that clients do not rely on the solver returning a specific solution if they are many equivalent optimal solutions.
  optional bool permute_variable_randomly = 178 [default = false];
  Specified by:
  
  hasPermuteVariableRandomly in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the permuteVariableRandomly field is set.
- getPermuteVariableRandomly
  
  public boolean getPermuteVariableRandomly()
  This is mainly here to test the solver variability. Note that in tests, if not explicitly set to false, all 3 options will be set to true so that clients do not rely on the solver returning a specific solution if they are many equivalent optimal solutions.
  optional bool permute_variable_randomly = 178 [default = false];
  Specified by:
  
  getPermuteVariableRandomly in interface SatParametersOrBuilder
  
  Returns:
  
  The permuteVariableRandomly.
- setPermuteVariableRandomly
  
  public SatParameters.Builder setPermuteVariableRandomly(boolean value)
  This is mainly here to test the solver variability. Note that in tests, if not explicitly set to false, all 3 options will be set to true so that clients do not rely on the solver returning a specific solution if they are many equivalent optimal solutions.
  optional bool permute_variable_randomly = 178 [default = false];
  Parameters:
  
  value - The permuteVariableRandomly to set.
  
  Returns:
  
  This builder for chaining.
- clearPermuteVariableRandomly
  
  public SatParameters.Builder clearPermuteVariableRandomly()
  This is mainly here to test the solver variability. Note that in tests, if not explicitly set to false, all 3 options will be set to true so that clients do not rely on the solver returning a specific solution if they are many equivalent optimal solutions.
  optional bool permute_variable_randomly = 178 [default = false];
  Returns:
  
  This builder for chaining.
- hasPermutePresolveConstraintOrder
  
  public boolean hasPermutePresolveConstraintOrder()
  
  optional bool permute_presolve_constraint_order = 179 [default = false];
  
  Specified by:
  
  hasPermutePresolveConstraintOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the permutePresolveConstraintOrder field is set.
- getPermutePresolveConstraintOrder
  
  public boolean getPermutePresolveConstraintOrder()
  
  optional bool permute_presolve_constraint_order = 179 [default = false];
  
  Specified by:
  
  getPermutePresolveConstraintOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The permutePresolveConstraintOrder.
- setPermutePresolveConstraintOrder
  
  public SatParameters.Builder setPermutePresolveConstraintOrder(boolean value)
  
  optional bool permute_presolve_constraint_order = 179 [default = false];
  
  Parameters:
  
  value - The permutePresolveConstraintOrder to set.
  
  Returns:
  
  This builder for chaining.
- clearPermutePresolveConstraintOrder
  
  public SatParameters.Builder clearPermutePresolveConstraintOrder()
  
  optional bool permute_presolve_constraint_order = 179 [default = false];
  
  Returns:
  
  This builder for chaining.
- hasUseAbslRandom
  
  public boolean hasUseAbslRandom()
  
  optional bool use_absl_random = 180 [default = false];
  
  Specified by:
  
  hasUseAbslRandom in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useAbslRandom field is set.
- getUseAbslRandom
  
  public boolean getUseAbslRandom()
  
  optional bool use_absl_random = 180 [default = false];
  
  Specified by:
  
  getUseAbslRandom in interface SatParametersOrBuilder
  
  Returns:
  
  The useAbslRandom.
- setUseAbslRandom
  
  public SatParameters.Builder setUseAbslRandom(boolean value)
  
  optional bool use_absl_random = 180 [default = false];
  
  Parameters:
  
  value - The useAbslRandom to set.
  
  Returns:
  
  This builder for chaining.
- clearUseAbslRandom
  
  public SatParameters.Builder clearUseAbslRandom()
  
  optional bool use_absl_random = 180 [default = false];
  
  Returns:
  
  This builder for chaining.
- hasLogSearchProgress
  
  public boolean hasLogSearchProgress()
  Whether the solver should log the search progress. By default, it logs to LOG(INFO). This can be overwritten by the log_destination parameter.
  optional bool log_search_progress = 41 [default = false];
  Specified by:
  
  hasLogSearchProgress in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logSearchProgress field is set.
- getLogSearchProgress
  
  public boolean getLogSearchProgress()
  Whether the solver should log the search progress. By default, it logs to LOG(INFO). This can be overwritten by the log_destination parameter.
  optional bool log_search_progress = 41 [default = false];
  Specified by:
  
  getLogSearchProgress in interface SatParametersOrBuilder
  
  Returns:
  
  The logSearchProgress.
- setLogSearchProgress
  
  public SatParameters.Builder setLogSearchProgress(boolean value)
  Whether the solver should log the search progress. By default, it logs to LOG(INFO). This can be overwritten by the log_destination parameter.
  optional bool log_search_progress = 41 [default = false];
  Parameters:
  
  value - The logSearchProgress to set.
  
  Returns:
  
  This builder for chaining.
- clearLogSearchProgress
  
  public SatParameters.Builder clearLogSearchProgress()
  Whether the solver should log the search progress. By default, it logs to LOG(INFO). This can be overwritten by the log_destination parameter.
  optional bool log_search_progress = 41 [default = false];
  Returns:
  
  This builder for chaining.
- hasLogPrefix
  
  public boolean hasLogPrefix()
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Specified by:
  
  hasLogPrefix in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logPrefix field is set.
- getLogPrefix
  
  public java.lang.String getLogPrefix()
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Specified by:
  
  getLogPrefix in interface SatParametersOrBuilder
  
  Returns:
  
  The logPrefix.
- getLogPrefixBytes
  
  public com.google.protobuf.ByteString getLogPrefixBytes()
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Specified by:
  
  getLogPrefixBytes in interface SatParametersOrBuilder
  
  Returns:
  
  The bytes for logPrefix.
- setLogPrefix
  
  public SatParameters.Builder setLogPrefix(java.lang.String value)
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Parameters:
  
  value - The logPrefix to set.
  
  Returns:
  
  This builder for chaining.
- clearLogPrefix
  
  public SatParameters.Builder clearLogPrefix()
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Returns:
  
  This builder for chaining.
- setLogPrefixBytes
  
  public SatParameters.Builder setLogPrefixBytes(com.google.protobuf.ByteString value)
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Parameters:
  
  value - The bytes for logPrefix to set.
  
  Returns:
  
  This builder for chaining.
- hasLogToStdout
  
  public boolean hasLogToStdout()
  Log to stdout.
  optional bool log_to_stdout = 186 [default = true];
  Specified by:
  
  hasLogToStdout in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logToStdout field is set.
- getLogToStdout
  
  public boolean getLogToStdout()
  Log to stdout.
  optional bool log_to_stdout = 186 [default = true];
  Specified by:
  
  getLogToStdout in interface SatParametersOrBuilder
  
  Returns:
  
  The logToStdout.
- setLogToStdout
  
  public SatParameters.Builder setLogToStdout(boolean value)
  Log to stdout.
  optional bool log_to_stdout = 186 [default = true];
  Parameters:
  
  value - The logToStdout to set.
  
  Returns:
  
  This builder for chaining.
- clearLogToStdout
  
  public SatParameters.Builder clearLogToStdout()
  Log to stdout.
  optional bool log_to_stdout = 186 [default = true];
  Returns:
  
  This builder for chaining.
- hasLogToResponse
  
  public boolean hasLogToResponse()
  Log to response proto.
  optional bool log_to_response = 187 [default = false];
  Specified by:
  
  hasLogToResponse in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logToResponse field is set.
- getLogToResponse
  
  public boolean getLogToResponse()
  Log to response proto.
  optional bool log_to_response = 187 [default = false];
  Specified by:
  
  getLogToResponse in interface SatParametersOrBuilder
  
  Returns:
  
  The logToResponse.
- setLogToResponse
  
  public SatParameters.Builder setLogToResponse(boolean value)
  Log to response proto.
  optional bool log_to_response = 187 [default = false];
  Parameters:
  
  value - The logToResponse to set.
  
  Returns:
  
  This builder for chaining.
- clearLogToResponse
  
  public SatParameters.Builder clearLogToResponse()
  Log to response proto.
  optional bool log_to_response = 187 [default = false];
  Returns:
  
  This builder for chaining.
- hasUsePbResolution
  
  public boolean hasUsePbResolution()
  Whether to use pseudo-Boolean resolution to analyze a conflict. Note that this option only make sense if your problem is modelized using pseudo-Boolean constraints. If you only have clauses, this shouldn't change anything (except slow the solver down).
  optional bool use_pb_resolution = 43 [default = false];
  Specified by:
  
  hasUsePbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the usePbResolution field is set.
- getUsePbResolution
  
  public boolean getUsePbResolution()
  Whether to use pseudo-Boolean resolution to analyze a conflict. Note that this option only make sense if your problem is modelized using pseudo-Boolean constraints. If you only have clauses, this shouldn't change anything (except slow the solver down).
  optional bool use_pb_resolution = 43 [default = false];
  Specified by:
  
  getUsePbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  The usePbResolution.
- setUsePbResolution
  
  public SatParameters.Builder setUsePbResolution(boolean value)
  Whether to use pseudo-Boolean resolution to analyze a conflict. Note that this option only make sense if your problem is modelized using pseudo-Boolean constraints. If you only have clauses, this shouldn't change anything (except slow the solver down).
  optional bool use_pb_resolution = 43 [default = false];
  Parameters:
  
  value - The usePbResolution to set.
  
  Returns:
  
  This builder for chaining.
- clearUsePbResolution
  
  public SatParameters.Builder clearUsePbResolution()
  Whether to use pseudo-Boolean resolution to analyze a conflict. Note that this option only make sense if your problem is modelized using pseudo-Boolean constraints. If you only have clauses, this shouldn't change anything (except slow the solver down).
  optional bool use_pb_resolution = 43 [default = false];
  Returns:
  
  This builder for chaining.
- hasMinimizeReductionDuringPbResolution
  
  public boolean hasMinimizeReductionDuringPbResolution()
  A different algorithm during PB resolution. It minimizes the number of calls to ReduceCoefficients() which can be time consuming. However, the search space will be different and if the coefficients are large, this may lead to integer overflows that could otherwise be prevented.
  optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  Specified by:
  
  hasMinimizeReductionDuringPbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeReductionDuringPbResolution field is set.
- getMinimizeReductionDuringPbResolution
  
  public boolean getMinimizeReductionDuringPbResolution()
  A different algorithm during PB resolution. It minimizes the number of calls to ReduceCoefficients() which can be time consuming. However, the search space will be different and if the coefficients are large, this may lead to integer overflows that could otherwise be prevented.
  optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  Specified by:
  
  getMinimizeReductionDuringPbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeReductionDuringPbResolution.
- setMinimizeReductionDuringPbResolution
  
  public SatParameters.Builder setMinimizeReductionDuringPbResolution(boolean value)
  A different algorithm during PB resolution. It minimizes the number of calls to ReduceCoefficients() which can be time consuming. However, the search space will be different and if the coefficients are large, this may lead to integer overflows that could otherwise be prevented.
  optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  Parameters:
  
  value - The minimizeReductionDuringPbResolution to set.
  
  Returns:
  
  This builder for chaining.
- clearMinimizeReductionDuringPbResolution
  
  public SatParameters.Builder clearMinimizeReductionDuringPbResolution()
  A different algorithm during PB resolution. It minimizes the number of calls to ReduceCoefficients() which can be time consuming. However, the search space will be different and if the coefficients are large, this may lead to integer overflows that could otherwise be prevented.
  optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  Returns:
  
  This builder for chaining.
- hasCountAssumptionLevelsInLbd
  
  public boolean hasCountAssumptionLevelsInLbd()
  Whether or not the assumption levels are taken into account during the LBD computation. According to the reference below, not counting them improves the solver in some situation. Note that this only impact solves under assumptions. Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for Incremental SAT Solving with Assumptions: Application to MUS Extraction" Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes in Computer Science Volume 7962, 2013, pp 309-317.
  optional bool count_assumption_levels_in_lbd = 49 [default = true];
  Specified by:
  
  hasCountAssumptionLevelsInLbd in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the countAssumptionLevelsInLbd field is set.
- getCountAssumptionLevelsInLbd
  
  public boolean getCountAssumptionLevelsInLbd()
  Whether or not the assumption levels are taken into account during the LBD computation. According to the reference below, not counting them improves the solver in some situation. Note that this only impact solves under assumptions. Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for Incremental SAT Solving with Assumptions: Application to MUS Extraction" Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes in Computer Science Volume 7962, 2013, pp 309-317.
  optional bool count_assumption_levels_in_lbd = 49 [default = true];
  Specified by:
  
  getCountAssumptionLevelsInLbd in interface SatParametersOrBuilder
  
  Returns:
  
  The countAssumptionLevelsInLbd.
- setCountAssumptionLevelsInLbd
  
  public SatParameters.Builder setCountAssumptionLevelsInLbd(boolean value)
  Whether or not the assumption levels are taken into account during the LBD computation. According to the reference below, not counting them improves the solver in some situation. Note that this only impact solves under assumptions. Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for Incremental SAT Solving with Assumptions: Application to MUS Extraction" Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes in Computer Science Volume 7962, 2013, pp 309-317.
  optional bool count_assumption_levels_in_lbd = 49 [default = true];
  Parameters:
  
  value - The countAssumptionLevelsInLbd to set.
  
  Returns:
  
  This builder for chaining.
- clearCountAssumptionLevelsInLbd
  
  public SatParameters.Builder clearCountAssumptionLevelsInLbd()
  Whether or not the assumption levels are taken into account during the LBD computation. According to the reference below, not counting them improves the solver in some situation. Note that this only impact solves under assumptions. Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for Incremental SAT Solving with Assumptions: Application to MUS Extraction" Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes in Computer Science Volume 7962, 2013, pp 309-317.
  optional bool count_assumption_levels_in_lbd = 49 [default = true];
  Returns:
  
  This builder for chaining.
- hasPresolveBveThreshold
  
  public boolean hasPresolveBveThreshold()
  During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
  optional int32 presolve_bve_threshold = 54 [default = 500];
  Specified by:
  
  hasPresolveBveThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBveThreshold field is set.
- getPresolveBveThreshold
  
  public int getPresolveBveThreshold()
  During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
  optional int32 presolve_bve_threshold = 54 [default = 500];
  Specified by:
  
  getPresolveBveThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBveThreshold.
- setPresolveBveThreshold
  
  public SatParameters.Builder setPresolveBveThreshold(int value)
  During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
  optional int32 presolve_bve_threshold = 54 [default = 500];
  Parameters:
  
  value - The presolveBveThreshold to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveBveThreshold
  
  public SatParameters.Builder clearPresolveBveThreshold()
  During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
  optional int32 presolve_bve_threshold = 54 [default = 500];
  Returns:
  
  This builder for chaining.
- hasPresolveBveClauseWeight
  
  public boolean hasPresolveBveClauseWeight()
  During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
  optional int32 presolve_bve_clause_weight = 55 [default = 3];
  Specified by:
  
  hasPresolveBveClauseWeight in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBveClauseWeight field is set.
- getPresolveBveClauseWeight
  
  public int getPresolveBveClauseWeight()
  During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
  optional int32 presolve_bve_clause_weight = 55 [default = 3];
  Specified by:
  
  getPresolveBveClauseWeight in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBveClauseWeight.
- setPresolveBveClauseWeight
  
  public SatParameters.Builder setPresolveBveClauseWeight(int value)
  During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
  optional int32 presolve_bve_clause_weight = 55 [default = 3];
  Parameters:
  
  value - The presolveBveClauseWeight to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveBveClauseWeight
  
  public SatParameters.Builder clearPresolveBveClauseWeight()
  During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
  optional int32 presolve_bve_clause_weight = 55 [default = 3];
  Returns:
  
  This builder for chaining.
- hasPresolveProbingDeterministicTimeLimit
  
  public boolean hasPresolveProbingDeterministicTimeLimit()
  The maximum "deterministic" time limit to spend in probing. A value of zero will disable the probing.
  optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  Specified by:
  
  hasPresolveProbingDeterministicTimeLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveProbingDeterministicTimeLimit field is set.
- getPresolveProbingDeterministicTimeLimit
  
  public double getPresolveProbingDeterministicTimeLimit()
  The maximum "deterministic" time limit to spend in probing. A value of zero will disable the probing.
  optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  Specified by:
  
  getPresolveProbingDeterministicTimeLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveProbingDeterministicTimeLimit.
- setPresolveProbingDeterministicTimeLimit
  
  public SatParameters.Builder setPresolveProbingDeterministicTimeLimit(double value)
  The maximum "deterministic" time limit to spend in probing. A value of zero will disable the probing.
  optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  Parameters:
  
  value - The presolveProbingDeterministicTimeLimit to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveProbingDeterministicTimeLimit
  
  public SatParameters.Builder clearPresolveProbingDeterministicTimeLimit()
  The maximum "deterministic" time limit to spend in probing. A value of zero will disable the probing.
  optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  Returns:
  
  This builder for chaining.
- hasPresolveBlockedClause
  
  public boolean hasPresolveBlockedClause()
  Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
  optional bool presolve_blocked_clause = 88 [default = true];
  Specified by:
  
  hasPresolveBlockedClause in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBlockedClause field is set.
- getPresolveBlockedClause
  
  public boolean getPresolveBlockedClause()
  Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
  optional bool presolve_blocked_clause = 88 [default = true];
  Specified by:
  
  getPresolveBlockedClause in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBlockedClause.
- setPresolveBlockedClause
  
  public SatParameters.Builder setPresolveBlockedClause(boolean value)
  Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
  optional bool presolve_blocked_clause = 88 [default = true];
  Parameters:
  
  value - The presolveBlockedClause to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveBlockedClause
  
  public SatParameters.Builder clearPresolveBlockedClause()
  Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
  optional bool presolve_blocked_clause = 88 [default = true];
  Returns:
  
  This builder for chaining.
- hasPresolveUseBva
  
  public boolean hasPresolveUseBva()
  Whether or not we use Bounded Variable Addition (BVA) in the presolve.
  optional bool presolve_use_bva = 72 [default = true];
  Specified by:
  
  hasPresolveUseBva in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveUseBva field is set.
- getPresolveUseBva
  
  public boolean getPresolveUseBva()
  Whether or not we use Bounded Variable Addition (BVA) in the presolve.
  optional bool presolve_use_bva = 72 [default = true];
  Specified by:
  
  getPresolveUseBva in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveUseBva.
- setPresolveUseBva
  
  public SatParameters.Builder setPresolveUseBva(boolean value)
  Whether or not we use Bounded Variable Addition (BVA) in the presolve.
  optional bool presolve_use_bva = 72 [default = true];
  Parameters:
  
  value - The presolveUseBva to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveUseBva
  
  public SatParameters.Builder clearPresolveUseBva()
  Whether or not we use Bounded Variable Addition (BVA) in the presolve.
  optional bool presolve_use_bva = 72 [default = true];
  Returns:
  
  This builder for chaining.
- hasPresolveBvaThreshold
  
  public boolean hasPresolveBvaThreshold()
  Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold. The algorithm described in the paper uses 0, but quick experiments showed that 1 is a good value. It may not be worth it to add a new variable just to remove one clause.
  optional int32 presolve_bva_threshold = 73 [default = 1];
  Specified by:
  
  hasPresolveBvaThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBvaThreshold field is set.
- getPresolveBvaThreshold
  
  public int getPresolveBvaThreshold()
  Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold. The algorithm described in the paper uses 0, but quick experiments showed that 1 is a good value. It may not be worth it to add a new variable just to remove one clause.
  optional int32 presolve_bva_threshold = 73 [default = 1];
  Specified by:
  
  getPresolveBvaThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBvaThreshold.
- setPresolveBvaThreshold
  
  public SatParameters.Builder setPresolveBvaThreshold(int value)
  Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold. The algorithm described in the paper uses 0, but quick experiments showed that 1 is a good value. It may not be worth it to add a new variable just to remove one clause.
  optional int32 presolve_bva_threshold = 73 [default = 1];
  Parameters:
  
  value - The presolveBvaThreshold to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveBvaThreshold
  
  public SatParameters.Builder clearPresolveBvaThreshold()
  Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold. The algorithm described in the paper uses 0, but quick experiments showed that 1 is a good value. It may not be worth it to add a new variable just to remove one clause.
  optional int32 presolve_bva_threshold = 73 [default = 1];
  Returns:
  
  This builder for chaining.
- hasMaxPresolveIterations
  
  public boolean hasMaxPresolveIterations()
  In case of large reduction in a presolve iteration, we perform multiple presolve iterations. This parameter controls the maximum number of such presolve iterations.
  optional int32 max_presolve_iterations = 138 [default = 3];
  Specified by:
  
  hasMaxPresolveIterations in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxPresolveIterations field is set.
- getMaxPresolveIterations
  
  public int getMaxPresolveIterations()
  In case of large reduction in a presolve iteration, we perform multiple presolve iterations. This parameter controls the maximum number of such presolve iterations.
  optional int32 max_presolve_iterations = 138 [default = 3];
  Specified by:
  
  getMaxPresolveIterations in interface SatParametersOrBuilder
  
  Returns:
  
  The maxPresolveIterations.
- setMaxPresolveIterations
  
  public SatParameters.Builder setMaxPresolveIterations(int value)
  In case of large reduction in a presolve iteration, we perform multiple presolve iterations. This parameter controls the maximum number of such presolve iterations.
  optional int32 max_presolve_iterations = 138 [default = 3];
  Parameters:
  
  value - The maxPresolveIterations to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxPresolveIterations
  
  public SatParameters.Builder clearMaxPresolveIterations()
  In case of large reduction in a presolve iteration, we perform multiple presolve iterations. This parameter controls the maximum number of such presolve iterations.
  optional int32 max_presolve_iterations = 138 [default = 3];
  Returns:
  
  This builder for chaining.
- hasCpModelPresolve
  
  public boolean hasCpModelPresolve()
  Whether we presolve the cp_model before solving it.
  optional bool cp_model_presolve = 86 [default = true];
  Specified by:
  
  hasCpModelPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelPresolve field is set.
- getCpModelPresolve
  
  public boolean getCpModelPresolve()
  Whether we presolve the cp_model before solving it.
  optional bool cp_model_presolve = 86 [default = true];
  Specified by:
  
  getCpModelPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelPresolve.
- setCpModelPresolve
  
  public SatParameters.Builder setCpModelPresolve(boolean value)
  Whether we presolve the cp_model before solving it.
  optional bool cp_model_presolve = 86 [default = true];
  Parameters:
  
  value - The cpModelPresolve to set.
  
  Returns:
  
  This builder for chaining.
- clearCpModelPresolve
  
  public SatParameters.Builder clearCpModelPresolve()
  Whether we presolve the cp_model before solving it.
  optional bool cp_model_presolve = 86 [default = true];
  Returns:
  
  This builder for chaining.
- hasCpModelPostsolveWithFullSolver
  
  public boolean hasCpModelPostsolveWithFullSolver()
  Advanced usage. We have two different postsolve code. The default one should be better and it allows for a more powerful presolve, but some rarely used features like not fully assigning all variables require the other one.
  optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
  Specified by:
  
  hasCpModelPostsolveWithFullSolver in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelPostsolveWithFullSolver field is set.
- getCpModelPostsolveWithFullSolver
  
  public boolean getCpModelPostsolveWithFullSolver()
  Advanced usage. We have two different postsolve code. The default one should be better and it allows for a more powerful presolve, but some rarely used features like not fully assigning all variables require the other one.
  optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
  Specified by:
  
  getCpModelPostsolveWithFullSolver in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelPostsolveWithFullSolver.
- setCpModelPostsolveWithFullSolver
  
  public SatParameters.Builder setCpModelPostsolveWithFullSolver(boolean value)
  Advanced usage. We have two different postsolve code. The default one should be better and it allows for a more powerful presolve, but some rarely used features like not fully assigning all variables require the other one.
  optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
  Parameters:
  
  value - The cpModelPostsolveWithFullSolver to set.
  
  Returns:
  
  This builder for chaining.
- clearCpModelPostsolveWithFullSolver
  
  public SatParameters.Builder clearCpModelPostsolveWithFullSolver()
  Advanced usage. We have two different postsolve code. The default one should be better and it allows for a more powerful presolve, but some rarely used features like not fully assigning all variables require the other one.
  optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
  Returns:
  
  This builder for chaining.
- hasCpModelMaxNumPresolveOperations
  
  public boolean hasCpModelMaxNumPresolveOperations()
  If positive, try to stop just after that many presolve rules have been applied. This is mainly useful for debugging presolve.
  optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
  Specified by:
  
  hasCpModelMaxNumPresolveOperations in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelMaxNumPresolveOperations field is set.
- getCpModelMaxNumPresolveOperations
  
  public int getCpModelMaxNumPresolveOperations()
  If positive, try to stop just after that many presolve rules have been applied. This is mainly useful for debugging presolve.
  optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
  Specified by:
  
  getCpModelMaxNumPresolveOperations in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelMaxNumPresolveOperations.
- setCpModelMaxNumPresolveOperations
  
  public SatParameters.Builder setCpModelMaxNumPresolveOperations(int value)
  If positive, try to stop just after that many presolve rules have been applied. This is mainly useful for debugging presolve.
  optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
  Parameters:
  
  value - The cpModelMaxNumPresolveOperations to set.
  
  Returns:
  
  This builder for chaining.
- clearCpModelMaxNumPresolveOperations
  
  public SatParameters.Builder clearCpModelMaxNumPresolveOperations()
  If positive, try to stop just after that many presolve rules have been applied. This is mainly useful for debugging presolve.
  optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
  Returns:
  
  This builder for chaining.
- hasCpModelProbingLevel
  
  public boolean hasCpModelProbingLevel()
  How much effort do we spend on probing. 0 disables it completely.
  optional int32 cp_model_probing_level = 110 [default = 2];
  Specified by:
  
  hasCpModelProbingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelProbingLevel field is set.
- getCpModelProbingLevel
  
  public int getCpModelProbingLevel()
  How much effort do we spend on probing. 0 disables it completely.
  optional int32 cp_model_probing_level = 110 [default = 2];
  Specified by:
  
  getCpModelProbingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelProbingLevel.
- setCpModelProbingLevel
  
  public SatParameters.Builder setCpModelProbingLevel(int value)
  How much effort do we spend on probing. 0 disables it completely.
  optional int32 cp_model_probing_level = 110 [default = 2];
  Parameters:
  
  value - The cpModelProbingLevel to set.
  
  Returns:
  
  This builder for chaining.
- clearCpModelProbingLevel
  
  public SatParameters.Builder clearCpModelProbingLevel()
  How much effort do we spend on probing. 0 disables it completely.
  optional int32 cp_model_probing_level = 110 [default = 2];
  Returns:
  
  This builder for chaining.
- hasCpModelUseSatPresolve
  
  public boolean hasCpModelUseSatPresolve()
  Whether we also use the sat presolve when cp_model_presolve is true.
  optional bool cp_model_use_sat_presolve = 93 [default = true];
  Specified by:
  
  hasCpModelUseSatPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelUseSatPresolve field is set.
- getCpModelUseSatPresolve
  
  public boolean getCpModelUseSatPresolve()
  Whether we also use the sat presolve when cp_model_presolve is true.
  optional bool cp_model_use_sat_presolve = 93 [default = true];
  Specified by:
  
  getCpModelUseSatPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelUseSatPresolve.
- setCpModelUseSatPresolve
  
  public SatParameters.Builder setCpModelUseSatPresolve(boolean value)
  Whether we also use the sat presolve when cp_model_presolve is true.
  optional bool cp_model_use_sat_presolve = 93 [default = true];
  Parameters:
  
  value - The cpModelUseSatPresolve to set.
  
  Returns:
  
  This builder for chaining.
- clearCpModelUseSatPresolve
  
  public SatParameters.Builder clearCpModelUseSatPresolve()
  Whether we also use the sat presolve when cp_model_presolve is true.
  optional bool cp_model_use_sat_presolve = 93 [default = true];
  Returns:
  
  This builder for chaining.
- hasUseSatInprocessing
  
  public boolean hasUseSatInprocessing()
  
  optional bool use_sat_inprocessing = 163 [default = false];
  
  Specified by:
  
  hasUseSatInprocessing in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useSatInprocessing field is set.
- getUseSatInprocessing
  
  public boolean getUseSatInprocessing()
  
  optional bool use_sat_inprocessing = 163 [default = false];
  
  Specified by:
  
  getUseSatInprocessing in interface SatParametersOrBuilder
  
  Returns:
  
  The useSatInprocessing.
- setUseSatInprocessing
  
  public SatParameters.Builder setUseSatInprocessing(boolean value)
  
  optional bool use_sat_inprocessing = 163 [default = false];
  
  Parameters:
  
  value - The useSatInprocessing to set.
  
  Returns:
  
  This builder for chaining.
- clearUseSatInprocessing
  
  public SatParameters.Builder clearUseSatInprocessing()
  
  optional bool use_sat_inprocessing = 163 [default = false];
  
  Returns:
  
  This builder for chaining.
- hasExpandElementConstraints
  
  public boolean hasExpandElementConstraints()
  If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
  optional bool expand_element_constraints = 140 [default = true];
  Specified by:
  
  hasExpandElementConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandElementConstraints field is set.
- getExpandElementConstraints
  
  public boolean getExpandElementConstraints()
  If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
  optional bool expand_element_constraints = 140 [default = true];
  Specified by:
  
  getExpandElementConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandElementConstraints.
- setExpandElementConstraints
  
  public SatParameters.Builder setExpandElementConstraints(boolean value)
  If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
  optional bool expand_element_constraints = 140 [default = true];
  Parameters:
  
  value - The expandElementConstraints to set.
  
  Returns:
  
  This builder for chaining.
- clearExpandElementConstraints
  
  public SatParameters.Builder clearExpandElementConstraints()
  If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
  optional bool expand_element_constraints = 140 [default = true];
  Returns:
  
  This builder for chaining.
- hasExpandAutomatonConstraints
  
  public boolean hasExpandAutomatonConstraints()
  If true, the automaton constraints are expanded.
  optional bool expand_automaton_constraints = 143 [default = true];
  Specified by:
  
  hasExpandAutomatonConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandAutomatonConstraints field is set.
- getExpandAutomatonConstraints
  
  public boolean getExpandAutomatonConstraints()
  If true, the automaton constraints are expanded.
  optional bool expand_automaton_constraints = 143 [default = true];
  Specified by:
  
  getExpandAutomatonConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandAutomatonConstraints.
- setExpandAutomatonConstraints
  
  public SatParameters.Builder setExpandAutomatonConstraints(boolean value)
  If true, the automaton constraints are expanded.
  optional bool expand_automaton_constraints = 143 [default = true];
  Parameters:
  
  value - The expandAutomatonConstraints to set.
  
  Returns:
  
  This builder for chaining.
- clearExpandAutomatonConstraints
  
  public SatParameters.Builder clearExpandAutomatonConstraints()
  If true, the automaton constraints are expanded.
  optional bool expand_automaton_constraints = 143 [default = true];
  Returns:
  
  This builder for chaining.
- hasExpandTableConstraints
  
  public boolean hasExpandTableConstraints()
  If true, the positive table constraints are expanded. Note that currently, negative table constraints are always expanded.
  optional bool expand_table_constraints = 158 [default = true];
  Specified by:
  
  hasExpandTableConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandTableConstraints field is set.
- getExpandTableConstraints
  
  public boolean getExpandTableConstraints()
  If true, the positive table constraints are expanded. Note that currently, negative table constraints are always expanded.
  optional bool expand_table_constraints = 158 [default = true];
  Specified by:
  
  getExpandTableConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandTableConstraints.
- setExpandTableConstraints
  
  public SatParameters.Builder setExpandTableConstraints(boolean value)
  If true, the positive table constraints are expanded. Note that currently, negative table constraints are always expanded.
  optional bool expand_table_constraints = 158 [default = true];
  Parameters:
  
  value - The expandTableConstraints to set.
  
  Returns:
  
  This builder for chaining.
- clearExpandTableConstraints
  
  public SatParameters.Builder clearExpandTableConstraints()
  If true, the positive table constraints are expanded. Note that currently, negative table constraints are always expanded.
  optional bool expand_table_constraints = 158 [default = true];
  Returns:
  
  This builder for chaining.
- hasExpandAlldiffConstraints
  
  public boolean hasExpandAlldiffConstraints()
  If true, expand all_different constraints that are not permutations. Permutations (#Variables = #Values) are always expanded.
  optional bool expand_alldiff_constraints = 170 [default = false];
  Specified by:
  
  hasExpandAlldiffConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandAlldiffConstraints field is set.
- getExpandAlldiffConstraints
  
  public boolean getExpandAlldiffConstraints()
  If true, expand all_different constraints that are not permutations. Permutations (#Variables = #Values) are always expanded.
  optional bool expand_alldiff_constraints = 170 [default = false];
  Specified by:
  
  getExpandAlldiffConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandAlldiffConstraints.
- setExpandAlldiffConstraints
  
  public SatParameters.Builder setExpandAlldiffConstraints(boolean value)
  If true, expand all_different constraints that are not permutations. Permutations (#Variables = #Values) are always expanded.
  optional bool expand_alldiff_constraints = 170 [default = false];
  Parameters:
  
  value - The expandAlldiffConstraints to set.
  
  Returns:
  
  This builder for chaining.
- clearExpandAlldiffConstraints
  
  public SatParameters.Builder clearExpandAlldiffConstraints()
  If true, expand all_different constraints that are not permutations. Permutations (#Variables = #Values) are always expanded.
  optional bool expand_alldiff_constraints = 170 [default = false];
  Returns:
  
  This builder for chaining.
- hasExpandReservoirConstraints
  
  public boolean hasExpandReservoirConstraints()
  If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
  optional bool expand_reservoir_constraints = 182 [default = true];
  Specified by:
  
  hasExpandReservoirConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandReservoirConstraints field is set.
- getExpandReservoirConstraints
  
  public boolean getExpandReservoirConstraints()
  If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
  optional bool expand_reservoir_constraints = 182 [default = true];
  Specified by:
  
  getExpandReservoirConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandReservoirConstraints.
- setExpandReservoirConstraints
  
  public SatParameters.Builder setExpandReservoirConstraints(boolean value)
  If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
  optional bool expand_reservoir_constraints = 182 [default = true];
  Parameters:
  
  value - The expandReservoirConstraints to set.
  
  Returns:
  
  This builder for chaining.
- clearExpandReservoirConstraints
  
  public SatParameters.Builder clearExpandReservoirConstraints()
  If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
  optional bool expand_reservoir_constraints = 182 [default = true];
  Returns:
  
  This builder for chaining.
- hasDisableConstraintExpansion
  
  public boolean hasDisableConstraintExpansion()
  If true, it disable all constraint expansion. This should only be used to test the presolve of expanded constraints.
  optional bool disable_constraint_expansion = 181 [default = false];
  Specified by:
  
  hasDisableConstraintExpansion in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the disableConstraintExpansion field is set.
- getDisableConstraintExpansion
  
  public boolean getDisableConstraintExpansion()
  If true, it disable all constraint expansion. This should only be used to test the presolve of expanded constraints.
  optional bool disable_constraint_expansion = 181 [default = false];
  Specified by:
  
  getDisableConstraintExpansion in interface SatParametersOrBuilder
  
  Returns:
  
  The disableConstraintExpansion.
- setDisableConstraintExpansion
  
  public SatParameters.Builder setDisableConstraintExpansion(boolean value)
  If true, it disable all constraint expansion. This should only be used to test the presolve of expanded constraints.
  optional bool disable_constraint_expansion = 181 [default = false];
  Parameters:
  
  value - The disableConstraintExpansion to set.
  
  Returns:
  
  This builder for chaining.
- clearDisableConstraintExpansion
  
  public SatParameters.Builder clearDisableConstraintExpansion()
  If true, it disable all constraint expansion. This should only be used to test the presolve of expanded constraints.
  optional bool disable_constraint_expansion = 181 [default = false];
  Returns:
  
  This builder for chaining.
- hasMergeNoOverlapWorkLimit
  
  public boolean hasMergeNoOverlapWorkLimit()
  During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints. This code can be slow, so we have a limit in place on the number of explored nodes in the underlying graph. The internal limit is an int64, but we use double here to simplify manual input.
  optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  Specified by:
  
  hasMergeNoOverlapWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mergeNoOverlapWorkLimit field is set.
- getMergeNoOverlapWorkLimit
  
  public double getMergeNoOverlapWorkLimit()
  During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints. This code can be slow, so we have a limit in place on the number of explored nodes in the underlying graph. The internal limit is an int64, but we use double here to simplify manual input.
  optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  Specified by:
  
  getMergeNoOverlapWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The mergeNoOverlapWorkLimit.
- setMergeNoOverlapWorkLimit
  
  public SatParameters.Builder setMergeNoOverlapWorkLimit(double value)
  During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints. This code can be slow, so we have a limit in place on the number of explored nodes in the underlying graph. The internal limit is an int64, but we use double here to simplify manual input.
  optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  Parameters:
  
  value - The mergeNoOverlapWorkLimit to set.
  
  Returns:
  
  This builder for chaining.
- clearMergeNoOverlapWorkLimit
  
  public SatParameters.Builder clearMergeNoOverlapWorkLimit()
  During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints. This code can be slow, so we have a limit in place on the number of explored nodes in the underlying graph. The internal limit is an int64, but we use double here to simplify manual input.
  optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  Returns:
  
  This builder for chaining.
- hasMergeAtMostOneWorkLimit
  
  public boolean hasMergeAtMostOneWorkLimit()
  
  optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  
  Specified by:
  
  hasMergeAtMostOneWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mergeAtMostOneWorkLimit field is set.
- getMergeAtMostOneWorkLimit
  
  public double getMergeAtMostOneWorkLimit()
  
  optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  
  Specified by:
  
  getMergeAtMostOneWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The mergeAtMostOneWorkLimit.
- setMergeAtMostOneWorkLimit
  
  public SatParameters.Builder setMergeAtMostOneWorkLimit(double value)
  
  optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  
  Parameters:
  
  value - The mergeAtMostOneWorkLimit to set.
  
  Returns:
  
  This builder for chaining.
- clearMergeAtMostOneWorkLimit
  
  public SatParameters.Builder clearMergeAtMostOneWorkLimit()
  
  optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  
  Returns:
  
  This builder for chaining.
- hasPresolveSubstitutionLevel
  
  public boolean hasPresolveSubstitutionLevel()
  How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve. This currently only concerns variable appearing only in linear constraints. For now the value 0 turns it off and any positive value performs substitution.
  optional int32 presolve_substitution_level = 147 [default = 1];
  Specified by:
  
  hasPresolveSubstitutionLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveSubstitutionLevel field is set.
- getPresolveSubstitutionLevel
  
  public int getPresolveSubstitutionLevel()
  How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve. This currently only concerns variable appearing only in linear constraints. For now the value 0 turns it off and any positive value performs substitution.
  optional int32 presolve_substitution_level = 147 [default = 1];
  Specified by:
  
  getPresolveSubstitutionLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveSubstitutionLevel.
- setPresolveSubstitutionLevel
  
  public SatParameters.Builder setPresolveSubstitutionLevel(int value)
  How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve. This currently only concerns variable appearing only in linear constraints. For now the value 0 turns it off and any positive value performs substitution.
  optional int32 presolve_substitution_level = 147 [default = 1];
  Parameters:
  
  value - The presolveSubstitutionLevel to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveSubstitutionLevel
  
  public SatParameters.Builder clearPresolveSubstitutionLevel()
  How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve. This currently only concerns variable appearing only in linear constraints. For now the value 0 turns it off and any positive value performs substitution.
  optional int32 presolve_substitution_level = 147 [default = 1];
  Returns:
  
  This builder for chaining.
- hasPresolveExtractIntegerEnforcement
  
  public boolean hasPresolveExtractIntegerEnforcement()
  If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint". This should always be beneficial except that we don't always handle them as efficiently as we could for now. This causes problem on manna81.mps (LP relaxation not as tight it seems) and on neos-3354841-apure.mps.gz (too many literals created this way).
  optional bool presolve_extract_integer_enforcement = 174 [default = false];
  Specified by:
  
  hasPresolveExtractIntegerEnforcement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveExtractIntegerEnforcement field is set.
- getPresolveExtractIntegerEnforcement
  
  public boolean getPresolveExtractIntegerEnforcement()
  If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint". This should always be beneficial except that we don't always handle them as efficiently as we could for now. This causes problem on manna81.mps (LP relaxation not as tight it seems) and on neos-3354841-apure.mps.gz (too many literals created this way).
  optional bool presolve_extract_integer_enforcement = 174 [default = false];
  Specified by:
  
  getPresolveExtractIntegerEnforcement in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveExtractIntegerEnforcement.
- setPresolveExtractIntegerEnforcement
  
  public SatParameters.Builder setPresolveExtractIntegerEnforcement(boolean value)
  If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint". This should always be beneficial except that we don't always handle them as efficiently as we could for now. This causes problem on manna81.mps (LP relaxation not as tight it seems) and on neos-3354841-apure.mps.gz (too many literals created this way).
  optional bool presolve_extract_integer_enforcement = 174 [default = false];
  Parameters:
  
  value - The presolveExtractIntegerEnforcement to set.
  
  Returns:
  
  This builder for chaining.
- clearPresolveExtractIntegerEnforcement
  
  public SatParameters.Builder clearPresolveExtractIntegerEnforcement()
  If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint". This should always be beneficial except that we don't always handle them as efficiently as we could for now. This causes problem on manna81.mps (LP relaxation not as tight it seems) and on neos-3354841-apure.mps.gz (too many literals created this way).
  optional bool presolve_extract_integer_enforcement = 174 [default = false];
  Returns:
  
  This builder for chaining.
- hasUseOptimizationHints
  
  public boolean hasUseOptimizationHints()
  For an optimization problem, whether we follow some hints in order to find a better first solution. For a variable with hint, the solver will always try to follow the hint. It will revert to the variable_branching default otherwise.
  optional bool use_optimization_hints = 35 [default = true];
  Specified by:
  
  hasUseOptimizationHints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useOptimizationHints field is set.
- getUseOptimizationHints
  
  public boolean getUseOptimizationHints()
  For an optimization problem, whether we follow some hints in order to find a better first solution. For a variable with hint, the solver will always try to follow the hint. It will revert to the variable_branching default otherwise.
  optional bool use_optimization_hints = 35 [default = true];
  Specified by:
  
  getUseOptimizationHints in interface SatParametersOrBuilder
  
  Returns:
  
  The useOptimizationHints.
- setUseOptimizationHints
  
  public SatParameters.Builder setUseOptimizationHints(boolean value)
  For an optimization problem, whether we follow some hints in order to find a better first solution. For a variable with hint, the solver will always try to follow the hint. It will revert to the variable_branching default otherwise.
  optional bool use_optimization_hints = 35 [default = true];
  Parameters:
  
  value - The useOptimizationHints to set.
  
  Returns:
  
  This builder for chaining.
- clearUseOptimizationHints
  
  public SatParameters.Builder clearUseOptimizationHints()
  For an optimization problem, whether we follow some hints in order to find a better first solution. For a variable with hint, the solver will always try to follow the hint. It will revert to the variable_branching default otherwise.
  optional bool use_optimization_hints = 35 [default = true];
  Returns:
  
  This builder for chaining.
- hasMinimizeCore
  
  public boolean hasMinimizeCore()
  Whether we use a simple heuristic to try to minimize an UNSAT core.
  optional bool minimize_core = 50 [default = true];
  Specified by:
  
  hasMinimizeCore in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeCore field is set.
- getMinimizeCore
  
  public boolean getMinimizeCore()
  Whether we use a simple heuristic to try to minimize an UNSAT core.
  optional bool minimize_core = 50 [default = true];
  Specified by:
  
  getMinimizeCore in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeCore.
- setMinimizeCore
  
  public SatParameters.Builder setMinimizeCore(boolean value)
  Whether we use a simple heuristic to try to minimize an UNSAT core.
  optional bool minimize_core = 50 [default = true];
  Parameters:
  
  value - The minimizeCore to set.
  
  Returns:
  
  This builder for chaining.
- clearMinimizeCore
  
  public SatParameters.Builder clearMinimizeCore()
  Whether we use a simple heuristic to try to minimize an UNSAT core.
  optional bool minimize_core = 50 [default = true];
  Returns:
  
  This builder for chaining.
- hasFindMultipleCores
  
  public boolean hasFindMultipleCores()
  Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
  optional bool find_multiple_cores = 84 [default = true];
  Specified by:
  
  hasFindMultipleCores in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the findMultipleCores field is set.
- getFindMultipleCores
  
  public boolean getFindMultipleCores()
  Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
  optional bool find_multiple_cores = 84 [default = true];
  Specified by:
  
  getFindMultipleCores in interface SatParametersOrBuilder
  
  Returns:
  
  The findMultipleCores.
- setFindMultipleCores
  
  public SatParameters.Builder setFindMultipleCores(boolean value)
  Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
  optional bool find_multiple_cores = 84 [default = true];
  Parameters:
  
  value - The findMultipleCores to set.
  
  Returns:
  
  This builder for chaining.
- clearFindMultipleCores
  
  public SatParameters.Builder clearFindMultipleCores()
  Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
  optional bool find_multiple_cores = 84 [default = true];
  Returns:
  
  This builder for chaining.
- hasCoverOptimization
  
  public boolean hasCoverOptimization()
  If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
  optional bool cover_optimization = 89 [default = true];
  Specified by:
  
  hasCoverOptimization in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the coverOptimization field is set.
- getCoverOptimization
  
  public boolean getCoverOptimization()
  If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
  optional bool cover_optimization = 89 [default = true];
  Specified by:
  
  getCoverOptimization in interface SatParametersOrBuilder
  
  Returns:
  
  The coverOptimization.
- setCoverOptimization
  
  public SatParameters.Builder setCoverOptimization(boolean value)
  If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
  optional bool cover_optimization = 89 [default = true];
  Parameters:
  
  value - The coverOptimization to set.
  
  Returns:
  
  This builder for chaining.
- clearCoverOptimization
  
  public SatParameters.Builder clearCoverOptimization()
  If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
  optional bool cover_optimization = 89 [default = true];
  Returns:
  
  This builder for chaining.
- hasMaxSatAssumptionOrder
  
  public boolean hasMaxSatAssumptionOrder()
  
  optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  
  Specified by:
  
  hasMaxSatAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxSatAssumptionOrder field is set.
- getMaxSatAssumptionOrder
  
  public SatParameters.MaxSatAssumptionOrder getMaxSatAssumptionOrder()
  
  optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  
  Specified by:
  
  getMaxSatAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The maxSatAssumptionOrder.
- setMaxSatAssumptionOrder
  
  public SatParameters.Builder setMaxSatAssumptionOrder(SatParameters.MaxSatAssumptionOrder value)
  
  optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  
  Parameters:
  
  value - The maxSatAssumptionOrder to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxSatAssumptionOrder
  
  public SatParameters.Builder clearMaxSatAssumptionOrder()
  
  optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  
  Returns:
  
  This builder for chaining.
- hasMaxSatReverseAssumptionOrder
  
  public boolean hasMaxSatReverseAssumptionOrder()
  If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
  optional bool max_sat_reverse_assumption_order = 52 [default = false];
  Specified by:
  
  hasMaxSatReverseAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxSatReverseAssumptionOrder field is set.
- getMaxSatReverseAssumptionOrder
  
  public boolean getMaxSatReverseAssumptionOrder()
  If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
  optional bool max_sat_reverse_assumption_order = 52 [default = false];
  Specified by:
  
  getMaxSatReverseAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The maxSatReverseAssumptionOrder.
- setMaxSatReverseAssumptionOrder
  
  public SatParameters.Builder setMaxSatReverseAssumptionOrder(boolean value)
  If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
  optional bool max_sat_reverse_assumption_order = 52 [default = false];
  Parameters:
  
  value - The maxSatReverseAssumptionOrder to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxSatReverseAssumptionOrder
  
  public SatParameters.Builder clearMaxSatReverseAssumptionOrder()
  If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
  optional bool max_sat_reverse_assumption_order = 52 [default = false];
  Returns:
  
  This builder for chaining.
- hasMaxSatStratification
  
  public boolean hasMaxSatStratification()
  
  optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  
  Specified by:
  
  hasMaxSatStratification in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxSatStratification field is set.
- getMaxSatStratification
  
  public SatParameters.MaxSatStratificationAlgorithm getMaxSatStratification()
  
  optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  
  Specified by:
  
  getMaxSatStratification in interface SatParametersOrBuilder
  
  Returns:
  
  The maxSatStratification.
- setMaxSatStratification
  
  public SatParameters.Builder setMaxSatStratification(SatParameters.MaxSatStratificationAlgorithm value)
  
  optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  
  Parameters:
  
  value - The maxSatStratification to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxSatStratification
  
  public SatParameters.Builder clearMaxSatStratification()
  
  optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  
  Returns:
  
  This builder for chaining.
- hasUsePrecedencesInDisjunctiveConstraint
  
  public boolean hasUsePrecedencesInDisjunctiveConstraint()
  When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further. For instance if task A and B are both before C and task A and B are in disjunction, then we can deduce that task C must start after duration(A) + duration(B) instead of simply max(duration(A), duration(B)), provided that the start time for all task was currently zero. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  Specified by:
  
  hasUsePrecedencesInDisjunctiveConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the usePrecedencesInDisjunctiveConstraint field is set.
- getUsePrecedencesInDisjunctiveConstraint
  
  public boolean getUsePrecedencesInDisjunctiveConstraint()
  When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further. For instance if task A and B are both before C and task A and B are in disjunction, then we can deduce that task C must start after duration(A) + duration(B) instead of simply max(duration(A), duration(B)), provided that the start time for all task was currently zero. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  Specified by:
  
  getUsePrecedencesInDisjunctiveConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The usePrecedencesInDisjunctiveConstraint.
- setUsePrecedencesInDisjunctiveConstraint
  
  public SatParameters.Builder setUsePrecedencesInDisjunctiveConstraint(boolean value)
  When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further. For instance if task A and B are both before C and task A and B are in disjunction, then we can deduce that task C must start after duration(A) + duration(B) instead of simply max(duration(A), duration(B)), provided that the start time for all task was currently zero. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  Parameters:
  
  value - The usePrecedencesInDisjunctiveConstraint to set.
  
  Returns:
  
  This builder for chaining.
- clearUsePrecedencesInDisjunctiveConstraint
  
  public SatParameters.Builder clearUsePrecedencesInDisjunctiveConstraint()
  When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further. For instance if task A and B are both before C and task A and B are in disjunction, then we can deduce that task C must start after duration(A) + duration(B) instead of simply max(duration(A), duration(B)), provided that the start time for all task was currently zero. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  Returns:
  
  This builder for chaining.
- hasUseOverloadCheckerInCumulativeConstraint
  
  public boolean hasUseOverloadCheckerInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy. This additional level supplements the default level of reasoning as well as timetable edge finding. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  Specified by:
  
  hasUseOverloadCheckerInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useOverloadCheckerInCumulativeConstraint field is set.
- getUseOverloadCheckerInCumulativeConstraint
  
  public boolean getUseOverloadCheckerInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy. This additional level supplements the default level of reasoning as well as timetable edge finding. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  Specified by:
  
  getUseOverloadCheckerInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The useOverloadCheckerInCumulativeConstraint.
- setUseOverloadCheckerInCumulativeConstraint
  
  public SatParameters.Builder setUseOverloadCheckerInCumulativeConstraint(boolean value)
  When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy. This additional level supplements the default level of reasoning as well as timetable edge finding. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  Parameters:
  
  value - The useOverloadCheckerInCumulativeConstraint to set.
  
  Returns:
  
  This builder for chaining.
- clearUseOverloadCheckerInCumulativeConstraint
  
  public SatParameters.Builder clearUseOverloadCheckerInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy. This additional level supplements the default level of reasoning as well as timetable edge finding. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  Returns:
  
  This builder for chaining.
- hasUseTimetableEdgeFindingInCumulativeConstraint
  
  public boolean hasUseTimetableEdgeFindingInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts. This additional level supplements the default level of reasoning as well as overload_checker. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  Specified by:
  
  hasUseTimetableEdgeFindingInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useTimetableEdgeFindingInCumulativeConstraint field is set.
- getUseTimetableEdgeFindingInCumulativeConstraint
  
  public boolean getUseTimetableEdgeFindingInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts. This additional level supplements the default level of reasoning as well as overload_checker. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  Specified by:
  
  getUseTimetableEdgeFindingInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The useTimetableEdgeFindingInCumulativeConstraint.
- setUseTimetableEdgeFindingInCumulativeConstraint
  
  public SatParameters.Builder setUseTimetableEdgeFindingInCumulativeConstraint(boolean value)
  When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts. This additional level supplements the default level of reasoning as well as overload_checker. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  Parameters:
  
  value - The useTimetableEdgeFindingInCumulativeConstraint to set.
  
  Returns:
  
  This builder for chaining.
- clearUseTimetableEdgeFindingInCumulativeConstraint
  
  public SatParameters.Builder clearUseTimetableEdgeFindingInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts. This additional level supplements the default level of reasoning as well as overload_checker. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  Returns:
  
  This builder for chaining.
- hasUseDisjunctiveConstraintInCumulativeConstraint
  
  public boolean hasUseDisjunctiveConstraintInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem. This additional level supplements the default level of reasoning. Propagators of the cumulative constraint will not be used at all if all the tasks are disjunctive at root node. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  Specified by:
  
  hasUseDisjunctiveConstraintInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useDisjunctiveConstraintInCumulativeConstraint field is set.
- getUseDisjunctiveConstraintInCumulativeConstraint
  
  public boolean getUseDisjunctiveConstraintInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem. This additional level supplements the default level of reasoning. Propagators of the cumulative constraint will not be used at all if all the tasks are disjunctive at root node. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  Specified by:
  
  getUseDisjunctiveConstraintInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The useDisjunctiveConstraintInCumulativeConstraint.
- setUseDisjunctiveConstraintInCumulativeConstraint
  
  public SatParameters.Builder setUseDisjunctiveConstraintInCumulativeConstraint(boolean value)
  When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem. This additional level supplements the default level of reasoning. Propagators of the cumulative constraint will not be used at all if all the tasks are disjunctive at root node. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  Parameters:
  
  value - The useDisjunctiveConstraintInCumulativeConstraint to set.
  
  Returns:
  
  This builder for chaining.
- clearUseDisjunctiveConstraintInCumulativeConstraint
  
  public SatParameters.Builder clearUseDisjunctiveConstraintInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem. This additional level supplements the default level of reasoning. Propagators of the cumulative constraint will not be used at all if all the tasks are disjunctive at root node. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  Returns:
  
  This builder for chaining.
- hasLinearizationLevel
  
  public boolean hasLinearizationLevel()
  A non-negative level indicating the type of constraints we consider in the LP relaxation. At level zero, no LP relaxation is used. At level 1, only the linear constraint and full encoding are added. At level 2, we also add all the Boolean constraints.
  optional int32 linearization_level = 90 [default = 1];
  Specified by:
  
  hasLinearizationLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the linearizationLevel field is set.
- getLinearizationLevel
  
  public int getLinearizationLevel()
  A non-negative level indicating the type of constraints we consider in the LP relaxation. At level zero, no LP relaxation is used. At level 1, only the linear constraint and full encoding are added. At level 2, we also add all the Boolean constraints.
  optional int32 linearization_level = 90 [default = 1];
  Specified by:
  
  getLinearizationLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The linearizationLevel.
- setLinearizationLevel
  
  public SatParameters.Builder setLinearizationLevel(int value)
  A non-negative level indicating the type of constraints we consider in the LP relaxation. At level zero, no LP relaxation is used. At level 1, only the linear constraint and full encoding are added. At level 2, we also add all the Boolean constraints.
  optional int32 linearization_level = 90 [default = 1];
  Parameters:
  
  value - The linearizationLevel to set.
  
  Returns:
  
  This builder for chaining.
- clearLinearizationLevel
  
  public SatParameters.Builder clearLinearizationLevel()
  A non-negative level indicating the type of constraints we consider in the LP relaxation. At level zero, no LP relaxation is used. At level 1, only the linear constraint and full encoding are added. At level 2, we also add all the Boolean constraints.
  optional int32 linearization_level = 90 [default = 1];
  Returns:
  
  This builder for chaining.
- hasBooleanEncodingLevel
  
  public boolean hasBooleanEncodingLevel()
  A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
  optional int32 boolean_encoding_level = 107 [default = 1];
  Specified by:
  
  hasBooleanEncodingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the booleanEncodingLevel field is set.
- getBooleanEncodingLevel
  
  public int getBooleanEncodingLevel()
  A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
  optional int32 boolean_encoding_level = 107 [default = 1];
  Specified by:
  
  getBooleanEncodingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The booleanEncodingLevel.
- setBooleanEncodingLevel
  
  public SatParameters.Builder setBooleanEncodingLevel(int value)
  A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
  optional int32 boolean_encoding_level = 107 [default = 1];
  Parameters:
  
  value - The booleanEncodingLevel to set.
  
  Returns:
  
  This builder for chaining.
- clearBooleanEncodingLevel
  
  public SatParameters.Builder clearBooleanEncodingLevel()
  A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
  optional int32 boolean_encoding_level = 107 [default = 1];
  Returns:
  
  This builder for chaining.
- hasMaxNumCuts
  
  public boolean hasMaxNumCuts()
  The limit on the number of cuts in our cut pool. When this is reached we do not generate cuts anymore. TODO(user): We should probably remove this parameters, and just always generate cuts but only keep the best n or something.
  optional int32 max_num_cuts = 91 [default = 10000];
  Specified by:
  
  hasMaxNumCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxNumCuts field is set.
- getMaxNumCuts
  
  public int getMaxNumCuts()
  The limit on the number of cuts in our cut pool. When this is reached we do not generate cuts anymore. TODO(user): We should probably remove this parameters, and just always generate cuts but only keep the best n or something.
  optional int32 max_num_cuts = 91 [default = 10000];
  Specified by:
  
  getMaxNumCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The maxNumCuts.
- setMaxNumCuts
  
  public SatParameters.Builder setMaxNumCuts(int value)
  The limit on the number of cuts in our cut pool. When this is reached we do not generate cuts anymore. TODO(user): We should probably remove this parameters, and just always generate cuts but only keep the best n or something.
  optional int32 max_num_cuts = 91 [default = 10000];
  Parameters:
  
  value - The maxNumCuts to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxNumCuts
  
  public SatParameters.Builder clearMaxNumCuts()
  The limit on the number of cuts in our cut pool. When this is reached we do not generate cuts anymore. TODO(user): We should probably remove this parameters, and just always generate cuts but only keep the best n or something.
  optional int32 max_num_cuts = 91 [default = 10000];
  Returns:
  
  This builder for chaining.
- hasOnlyAddCutsAtLevelZero
  
  public boolean hasOnlyAddCutsAtLevelZero()
  For the cut that can be generated at any level, this control if we only try to generate them at the root node.
  optional bool only_add_cuts_at_level_zero = 92 [default = false];
  Specified by:
  
  hasOnlyAddCutsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the onlyAddCutsAtLevelZero field is set.
- getOnlyAddCutsAtLevelZero
  
  public boolean getOnlyAddCutsAtLevelZero()
  For the cut that can be generated at any level, this control if we only try to generate them at the root node.
  optional bool only_add_cuts_at_level_zero = 92 [default = false];
  Specified by:
  
  getOnlyAddCutsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  The onlyAddCutsAtLevelZero.
- setOnlyAddCutsAtLevelZero
  
  public SatParameters.Builder setOnlyAddCutsAtLevelZero(boolean value)
  For the cut that can be generated at any level, this control if we only try to generate them at the root node.
  optional bool only_add_cuts_at_level_zero = 92 [default = false];
  Parameters:
  
  value - The onlyAddCutsAtLevelZero to set.
  
  Returns:
  
  This builder for chaining.
- clearOnlyAddCutsAtLevelZero
  
  public SatParameters.Builder clearOnlyAddCutsAtLevelZero()
  For the cut that can be generated at any level, this control if we only try to generate them at the root node.
  optional bool only_add_cuts_at_level_zero = 92 [default = false];
  Returns:
  
  This builder for chaining.
- hasAddKnapsackCuts
  
  public boolean hasAddKnapsackCuts()
  Whether we generate knapsack cuts. Note that in our setting where all variables are integer and bounded on both side, such a cut could be applied to any constraint.
  optional bool add_knapsack_cuts = 111 [default = false];
  Specified by:
  
  hasAddKnapsackCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addKnapsackCuts field is set.
- getAddKnapsackCuts
  
  public boolean getAddKnapsackCuts()
  Whether we generate knapsack cuts. Note that in our setting where all variables are integer and bounded on both side, such a cut could be applied to any constraint.
  optional bool add_knapsack_cuts = 111 [default = false];
  Specified by:
  
  getAddKnapsackCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addKnapsackCuts.
- setAddKnapsackCuts
  
  public SatParameters.Builder setAddKnapsackCuts(boolean value)
  Whether we generate knapsack cuts. Note that in our setting where all variables are integer and bounded on both side, such a cut could be applied to any constraint.
  optional bool add_knapsack_cuts = 111 [default = false];
  Parameters:
  
  value - The addKnapsackCuts to set.
  
  Returns:
  
  This builder for chaining.
- clearAddKnapsackCuts
  
  public SatParameters.Builder clearAddKnapsackCuts()
  Whether we generate knapsack cuts. Note that in our setting where all variables are integer and bounded on both side, such a cut could be applied to any constraint.
  optional bool add_knapsack_cuts = 111 [default = false];
  Returns:
  
  This builder for chaining.
- hasAddCgCuts
  
  public boolean hasAddCgCuts()
  Whether we generate and add Chvatal-Gomory cuts to the LP at root node. Note that for now, this is not heavily tuned.
  optional bool add_cg_cuts = 117 [default = true];
  Specified by:
  
  hasAddCgCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addCgCuts field is set.
- getAddCgCuts
  
  public boolean getAddCgCuts()
  Whether we generate and add Chvatal-Gomory cuts to the LP at root node. Note that for now, this is not heavily tuned.
  optional bool add_cg_cuts = 117 [default = true];
  Specified by:
  
  getAddCgCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addCgCuts.
- setAddCgCuts
  
  public SatParameters.Builder setAddCgCuts(boolean value)
  Whether we generate and add Chvatal-Gomory cuts to the LP at root node. Note that for now, this is not heavily tuned.
  optional bool add_cg_cuts = 117 [default = true];
  Parameters:
  
  value - The addCgCuts to set.
  
  Returns:
  
  This builder for chaining.
- clearAddCgCuts
  
  public SatParameters.Builder clearAddCgCuts()
  Whether we generate and add Chvatal-Gomory cuts to the LP at root node. Note that for now, this is not heavily tuned.
  optional bool add_cg_cuts = 117 [default = true];
  Returns:
  
  This builder for chaining.
- hasAddMirCuts
  
  public boolean hasAddMirCuts()
  Whether we generate MIR cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_mir_cuts = 120 [default = true];
  Specified by:
  
  hasAddMirCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addMirCuts field is set.
- getAddMirCuts
  
  public boolean getAddMirCuts()
  Whether we generate MIR cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_mir_cuts = 120 [default = true];
  Specified by:
  
  getAddMirCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addMirCuts.
- setAddMirCuts
  
  public SatParameters.Builder setAddMirCuts(boolean value)
  Whether we generate MIR cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_mir_cuts = 120 [default = true];
  Parameters:
  
  value - The addMirCuts to set.
  
  Returns:
  
  This builder for chaining.
- clearAddMirCuts
  
  public SatParameters.Builder clearAddMirCuts()
  Whether we generate MIR cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_mir_cuts = 120 [default = true];
  Returns:
  
  This builder for chaining.
- hasAddZeroHalfCuts
  
  public boolean hasAddZeroHalfCuts()
  Whether we generate Zero-Half cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_zero_half_cuts = 169 [default = true];
  Specified by:
  
  hasAddZeroHalfCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addZeroHalfCuts field is set.
- getAddZeroHalfCuts
  
  public boolean getAddZeroHalfCuts()
  Whether we generate Zero-Half cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_zero_half_cuts = 169 [default = true];
  Specified by:
  
  getAddZeroHalfCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addZeroHalfCuts.
- setAddZeroHalfCuts
  
  public SatParameters.Builder setAddZeroHalfCuts(boolean value)
  Whether we generate Zero-Half cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_zero_half_cuts = 169 [default = true];
  Parameters:
  
  value - The addZeroHalfCuts to set.
  
  Returns:
  
  This builder for chaining.
- clearAddZeroHalfCuts
  
  public SatParameters.Builder clearAddZeroHalfCuts()
  Whether we generate Zero-Half cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_zero_half_cuts = 169 [default = true];
  Returns:
  
  This builder for chaining.
- hasAddCliqueCuts
  
  public boolean hasAddCliqueCuts()
  Whether we generate clique cuts from the binary implication graph. Note that as the search goes on, this graph will contains new binary clauses learned by the SAT engine.
  optional bool add_clique_cuts = 172 [default = true];
  Specified by:
  
  hasAddCliqueCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addCliqueCuts field is set.
- getAddCliqueCuts
  
  public boolean getAddCliqueCuts()
  Whether we generate clique cuts from the binary implication graph. Note that as the search goes on, this graph will contains new binary clauses learned by the SAT engine.
  optional bool add_clique_cuts = 172 [default = true];
  Specified by:
  
  getAddCliqueCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addCliqueCuts.
- setAddCliqueCuts
  
  public SatParameters.Builder setAddCliqueCuts(boolean value)
  Whether we generate clique cuts from the binary implication graph. Note that as the search goes on, this graph will contains new binary clauses learned by the SAT engine.
  optional bool add_clique_cuts = 172 [default = true];
  Parameters:
  
  value - The addCliqueCuts to set.
  
  Returns:
  
  This builder for chaining.
- clearAddCliqueCuts
  
  public SatParameters.Builder clearAddCliqueCuts()
  Whether we generate clique cuts from the binary implication graph. Note that as the search goes on, this graph will contains new binary clauses learned by the SAT engine.
  optional bool add_clique_cuts = 172 [default = true];
  Returns:
  
  This builder for chaining.
- hasMaxAllDiffCutSize
  
  public boolean hasMaxAllDiffCutSize()
  Cut generator for all diffs can add too many cuts for large all_diff constraints. This parameter restricts the large all_diff constraints to have a cut generator.
  optional int32 max_all_diff_cut_size = 148 [default = 7];
  Specified by:
  
  hasMaxAllDiffCutSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxAllDiffCutSize field is set.
- getMaxAllDiffCutSize
  
  public int getMaxAllDiffCutSize()
  Cut generator for all diffs can add too many cuts for large all_diff constraints. This parameter restricts the large all_diff constraints to have a cut generator.
  optional int32 max_all_diff_cut_size = 148 [default = 7];
  Specified by:
  
  getMaxAllDiffCutSize in interface SatParametersOrBuilder
  
  Returns:
  
  The maxAllDiffCutSize.
- setMaxAllDiffCutSize
  
  public SatParameters.Builder setMaxAllDiffCutSize(int value)
  Cut generator for all diffs can add too many cuts for large all_diff constraints. This parameter restricts the large all_diff constraints to have a cut generator.
  optional int32 max_all_diff_cut_size = 148 [default = 7];
  Parameters:
  
  value - The maxAllDiffCutSize to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxAllDiffCutSize
  
  public SatParameters.Builder clearMaxAllDiffCutSize()
  Cut generator for all diffs can add too many cuts for large all_diff constraints. This parameter restricts the large all_diff constraints to have a cut generator.
  optional int32 max_all_diff_cut_size = 148 [default = 7];
  Returns:
  
  This builder for chaining.
- hasAddLinMaxCuts
  
  public boolean hasAddLinMaxCuts()
  For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
  optional bool add_lin_max_cuts = 152 [default = true];
  Specified by:
  
  hasAddLinMaxCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addLinMaxCuts field is set.
- getAddLinMaxCuts
  
  public boolean getAddLinMaxCuts()
  For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
  optional bool add_lin_max_cuts = 152 [default = true];
  Specified by:
  
  getAddLinMaxCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addLinMaxCuts.
- setAddLinMaxCuts
  
  public SatParameters.Builder setAddLinMaxCuts(boolean value)
  For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
  optional bool add_lin_max_cuts = 152 [default = true];
  Parameters:
  
  value - The addLinMaxCuts to set.
  
  Returns:
  
  This builder for chaining.
- clearAddLinMaxCuts
  
  public SatParameters.Builder clearAddLinMaxCuts()
  For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
  optional bool add_lin_max_cuts = 152 [default = true];
  Returns:
  
  This builder for chaining.
- hasMaxIntegerRoundingScaling
  
  public boolean hasMaxIntegerRoundingScaling()
  In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive). The lower this is, the lower the integer coefficients of the cut will be. Note that cut generated by lower values are not necessarily worse than cut generated by larger value. There is no strict dominance relationship. Setting this to 2 result in the "strong fractional rouding" of Letchford and Lodi.
  optional int32 max_integer_rounding_scaling = 119 [default = 600];
  Specified by:
  
  hasMaxIntegerRoundingScaling in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxIntegerRoundingScaling field is set.
- getMaxIntegerRoundingScaling
  
  public int getMaxIntegerRoundingScaling()
  In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive). The lower this is, the lower the integer coefficients of the cut will be. Note that cut generated by lower values are not necessarily worse than cut generated by larger value. There is no strict dominance relationship. Setting this to 2 result in the "strong fractional rouding" of Letchford and Lodi.
  optional int32 max_integer_rounding_scaling = 119 [default = 600];
  Specified by:
  
  getMaxIntegerRoundingScaling in interface SatParametersOrBuilder
  
  Returns:
  
  The maxIntegerRoundingScaling.
- setMaxIntegerRoundingScaling
  
  public SatParameters.Builder setMaxIntegerRoundingScaling(int value)
  In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive). The lower this is, the lower the integer coefficients of the cut will be. Note that cut generated by lower values are not necessarily worse than cut generated by larger value. There is no strict dominance relationship. Setting this to 2 result in the "strong fractional rouding" of Letchford and Lodi.
  optional int32 max_integer_rounding_scaling = 119 [default = 600];
  Parameters:
  
  value - The maxIntegerRoundingScaling to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxIntegerRoundingScaling
  
  public SatParameters.Builder clearMaxIntegerRoundingScaling()
  In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive). The lower this is, the lower the integer coefficients of the cut will be. Note that cut generated by lower values are not necessarily worse than cut generated by larger value. There is no strict dominance relationship. Setting this to 2 result in the "strong fractional rouding" of Letchford and Lodi.
  optional int32 max_integer_rounding_scaling = 119 [default = 600];
  Returns:
  
  This builder for chaining.
- hasAddLpConstraintsLazily
  
  public boolean hasAddLpConstraintsLazily()
  If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch. A constraint that is only added like this is known as a "lazy" constraint in the literature, except that we currently consider all constraints as lazy here.
  optional bool add_lp_constraints_lazily = 112 [default = true];
  Specified by:
  
  hasAddLpConstraintsLazily in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addLpConstraintsLazily field is set.
- getAddLpConstraintsLazily
  
  public boolean getAddLpConstraintsLazily()
  If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch. A constraint that is only added like this is known as a "lazy" constraint in the literature, except that we currently consider all constraints as lazy here.
  optional bool add_lp_constraints_lazily = 112 [default = true];
  Specified by:
  
  getAddLpConstraintsLazily in interface SatParametersOrBuilder
  
  Returns:
  
  The addLpConstraintsLazily.
- setAddLpConstraintsLazily
  
  public SatParameters.Builder setAddLpConstraintsLazily(boolean value)
  If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch. A constraint that is only added like this is known as a "lazy" constraint in the literature, except that we currently consider all constraints as lazy here.
  optional bool add_lp_constraints_lazily = 112 [default = true];
  Parameters:
  
  value - The addLpConstraintsLazily to set.
  
  Returns:
  
  This builder for chaining.
- clearAddLpConstraintsLazily
  
  public SatParameters.Builder clearAddLpConstraintsLazily()
  If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch. A constraint that is only added like this is known as a "lazy" constraint in the literature, except that we currently consider all constraints as lazy here.
  optional bool add_lp_constraints_lazily = 112 [default = true];
  Returns:
  
  This builder for chaining.
- hasMinOrthogonalityForLpConstraints
  
  public boolean hasMinOrthogonalityForLpConstraints()
  While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call. Orthogonality is defined as 1 - cosine(vector angle between constraints). A value of zero disable this feature.
  optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  Specified by:
  
  hasMinOrthogonalityForLpConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minOrthogonalityForLpConstraints field is set.
- getMinOrthogonalityForLpConstraints
  
  public double getMinOrthogonalityForLpConstraints()
  While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call. Orthogonality is defined as 1 - cosine(vector angle between constraints). A value of zero disable this feature.
  optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  Specified by:
  
  getMinOrthogonalityForLpConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The minOrthogonalityForLpConstraints.
- setMinOrthogonalityForLpConstraints
  
  public SatParameters.Builder setMinOrthogonalityForLpConstraints(double value)
  While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call. Orthogonality is defined as 1 - cosine(vector angle between constraints). A value of zero disable this feature.
  optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  Parameters:
  
  value - The minOrthogonalityForLpConstraints to set.
  
  Returns:
  
  This builder for chaining.
- clearMinOrthogonalityForLpConstraints
  
  public SatParameters.Builder clearMinOrthogonalityForLpConstraints()
  While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call. Orthogonality is defined as 1 - cosine(vector angle between constraints). A value of zero disable this feature.
  optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  Returns:
  
  This builder for chaining.
- hasMaxCutRoundsAtLevelZero
  
  public boolean hasMaxCutRoundsAtLevelZero()
  Max number of time we perform cut generation and resolve the LP at level 0.
  optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  Specified by:
  
  hasMaxCutRoundsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxCutRoundsAtLevelZero field is set.
- getMaxCutRoundsAtLevelZero
  
  public int getMaxCutRoundsAtLevelZero()
  Max number of time we perform cut generation and resolve the LP at level 0.
  optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  Specified by:
  
  getMaxCutRoundsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  The maxCutRoundsAtLevelZero.
- setMaxCutRoundsAtLevelZero
  
  public SatParameters.Builder setMaxCutRoundsAtLevelZero(int value)
  Max number of time we perform cut generation and resolve the LP at level 0.
  optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  Parameters:
  
  value - The maxCutRoundsAtLevelZero to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxCutRoundsAtLevelZero
  
  public SatParameters.Builder clearMaxCutRoundsAtLevelZero()
  Max number of time we perform cut generation and resolve the LP at level 0.
  optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  Returns:
  
  This builder for chaining.
- hasMaxConsecutiveInactiveCount
  
  public boolean hasMaxConsecutiveInactiveCount()
  If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP. Note that it might be added again later if it become violated by the current LP solution.
  optional int32 max_consecutive_inactive_count = 121 [default = 100];
  Specified by:
  
  hasMaxConsecutiveInactiveCount in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxConsecutiveInactiveCount field is set.
- getMaxConsecutiveInactiveCount
  
  public int getMaxConsecutiveInactiveCount()
  If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP. Note that it might be added again later if it become violated by the current LP solution.
  optional int32 max_consecutive_inactive_count = 121 [default = 100];
  Specified by:
  
  getMaxConsecutiveInactiveCount in interface SatParametersOrBuilder
  
  Returns:
  
  The maxConsecutiveInactiveCount.
- setMaxConsecutiveInactiveCount
  
  public SatParameters.Builder setMaxConsecutiveInactiveCount(int value)
  If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP. Note that it might be added again later if it become violated by the current LP solution.
  optional int32 max_consecutive_inactive_count = 121 [default = 100];
  Parameters:
  
  value - The maxConsecutiveInactiveCount to set.
  
  Returns:
  
  This builder for chaining.
- clearMaxConsecutiveInactiveCount
  
  public SatParameters.Builder clearMaxConsecutiveInactiveCount()
  If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP. Note that it might be added again later if it become violated by the current LP solution.
  optional int32 max_consecutive_inactive_count = 121 [default = 100];
  Returns:
  
  This builder for chaining.
- hasCutMaxActiveCountValue
  
  public boolean hasCutMaxActiveCountValue()
  These parameters are similar to sat clause management activity parameters. They are effective only if the number of generated cuts exceed the storage limit. Default values are based on a few experiments on miplib instances.
  optional double cut_max_active_count_value = 155 [default = 10000000000];
  Specified by:
  
  hasCutMaxActiveCountValue in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cutMaxActiveCountValue field is set.
- getCutMaxActiveCountValue
  
  public double getCutMaxActiveCountValue()
  These parameters are similar to sat clause management activity parameters. They are effective only if the number of generated cuts exceed the storage limit. Default values are based on a few experiments on miplib instances.
  optional double cut_max_active_count_value = 155 [default = 10000000000];
  Specified by:
  
  getCutMaxActiveCountValue in interface SatParametersOrBuilder
  
  Returns:
  
  The cutMaxActiveCountValue.
- setCutMaxActiveCountValue
  
  public SatParameters.Builder setCutMaxActiveCountValue(double value)
  These parameters are similar to sat clause management activity parameters. They are effective only if the number of generated cuts exceed the storage limit. Default values are based on a few experiments on miplib instances.
  optional double cut_max_active_count_value = 155 [default = 10000000000];
  Parameters:
  
  value - The cutMaxActiveCountValue to set.
  
  Returns:
  
  This builder for chaining.
- clearCutMaxActiveCountValue
  
  public SatParameters.Builder clearCutMaxActiveCountValue()
  These parameters are similar to sat clause management activity parameters. They are effective only if the number of generated cuts exceed the storage limit. Default values are based on a few experiments on miplib instances.
  optional double cut_max_active_count_value = 155 [default = 10000000000];
  Returns:
  
  This builder for chaining.
- hasCutActiveCountDecay
  
  public boolean hasCutActiveCountDecay()
  
  optional double cut_active_count_decay = 156 [default = 0.8];
  
  Specified by:
  
  hasCutActiveCountDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cutActiveCountDecay field is set.
- getCutActiveCountDecay
  
  public double getCutActiveCountDecay()
  
  optional double cut_active_count_decay = 156 [default = 0.8];
  
  Specified by:
  
  getCutActiveCountDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The cutActiveCountDecay.
- setCutActiveCountDecay
  
  public SatParameters.Builder setCutActiveCountDecay(double value)
  
  optional double cut_active_count_decay = 156 [default = 0.8];
  
  Parameters:
  
  value - The cutActiveCountDecay to set.
  
  Returns:
  
  This builder for chaining.
- clearCutActiveCountDecay
  
  public SatParameters.Builder clearCutActiveCountDecay()
  
  optional double cut_active_count_decay = 156 [default = 0.8];
  
  Returns:
  
  This builder for chaining.
- hasCutCleanupTarget
  
  public boolean hasCutCleanupTarget()
  Target number of constraints to remove during cleanup.
  optional int32 cut_cleanup_target = 157 [default = 1000];
  Specified by:
  
  hasCutCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cutCleanupTarget field is set.
- getCutCleanupTarget
  
  public int getCutCleanupTarget()
  Target number of constraints to remove during cleanup.
  optional int32 cut_cleanup_target = 157 [default = 1000];
  Specified by:
  
  getCutCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  The cutCleanupTarget.
- setCutCleanupTarget
  
  public SatParameters.Builder setCutCleanupTarget(int value)
  Target number of constraints to remove during cleanup.
  optional int32 cut_cleanup_target = 157 [default = 1000];
  Parameters:
  
  value - The cutCleanupTarget to set.
  
  Returns:
  
  This builder for chaining.
- clearCutCleanupTarget
  
  public SatParameters.Builder clearCutCleanupTarget()
  Target number of constraints to remove during cleanup.
  optional int32 cut_cleanup_target = 157 [default = 1000];
  Returns:
  
  This builder for chaining.
- hasNewConstraintsBatchSize
  
  public boolean hasNewConstraintsBatchSize()
  Add that many lazy constraints (or cuts) at once in the LP. Note that at the beginning of the solve, we do add more than this.
  optional int32 new_constraints_batch_size = 122 [default = 50];
  Specified by:
  
  hasNewConstraintsBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the newConstraintsBatchSize field is set.
- getNewConstraintsBatchSize
  
  public int getNewConstraintsBatchSize()
  Add that many lazy constraints (or cuts) at once in the LP. Note that at the beginning of the solve, we do add more than this.
  optional int32 new_constraints_batch_size = 122 [default = 50];
  Specified by:
  
  getNewConstraintsBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  The newConstraintsBatchSize.
- setNewConstraintsBatchSize
  
  public SatParameters.Builder setNewConstraintsBatchSize(int value)
  Add that many lazy constraints (or cuts) at once in the LP. Note that at the beginning of the solve, we do add more than this.
  optional int32 new_constraints_batch_size = 122 [default = 50];
  Parameters:
  
  value - The newConstraintsBatchSize to set.
  
  Returns:
  
  This builder for chaining.
- clearNewConstraintsBatchSize
  
  public SatParameters.Builder clearNewConstraintsBatchSize()
  Add that many lazy constraints (or cuts) at once in the LP. Note that at the beginning of the solve, we do add more than this.
  optional int32 new_constraints_batch_size = 122 [default = 50];
  Returns:
  
  This builder for chaining.
- hasSearchBranching
  
  public boolean hasSearchBranching()
  
  optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  
  Specified by:
  
  hasSearchBranching in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the searchBranching field is set.
- getSearchBranching
  
  public SatParameters.SearchBranching getSearchBranching()
  
  optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  
  Specified by:
  
  getSearchBranching in interface SatParametersOrBuilder
  
  Returns:
  
  The searchBranching.
- setSearchBranching
  
  public SatParameters.Builder setSearchBranching(SatParameters.SearchBranching value)
  
  optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  
  Parameters:
  
  value - The searchBranching to set.
  
  Returns:
  
  This builder for chaining.
- clearSearchBranching
  
  public SatParameters.Builder clearSearchBranching()
  
  optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  
  Returns:
  
  This builder for chaining.
- hasHintConflictLimit
  
  public boolean hasHintConflictLimit()
  Conflict limit used in the phase that exploit the solution hint.
  optional int32 hint_conflict_limit = 153 [default = 10];
  Specified by:
  
  hasHintConflictLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the hintConflictLimit field is set.
- getHintConflictLimit
  
  public int getHintConflictLimit()
  Conflict limit used in the phase that exploit the solution hint.
  optional int32 hint_conflict_limit = 153 [default = 10];
  Specified by:
  
  getHintConflictLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The hintConflictLimit.
- setHintConflictLimit
  
  public SatParameters.Builder setHintConflictLimit(int value)
  Conflict limit used in the phase that exploit the solution hint.
  optional int32 hint_conflict_limit = 153 [default = 10];
  Parameters:
  
  value - The hintConflictLimit to set.
  
  Returns:
  
  This builder for chaining.
- clearHintConflictLimit
  
  public SatParameters.Builder clearHintConflictLimit()
  Conflict limit used in the phase that exploit the solution hint.
  optional int32 hint_conflict_limit = 153 [default = 10];
  Returns:
  
  This builder for chaining.
- hasRepairHint
  
  public boolean hasRepairHint()
  If true, the solver tries to repair the solution given in the hint. This search terminates after the 'hint_conflict_limit' is reached and the solver switches to regular search. If false, then we do a FIXED_SEARCH using the hint until the hint_conflict_limit is reached.
  optional bool repair_hint = 167 [default = false];
  Specified by:
  
  hasRepairHint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the repairHint field is set.
- getRepairHint
  
  public boolean getRepairHint()
  If true, the solver tries to repair the solution given in the hint. This search terminates after the 'hint_conflict_limit' is reached and the solver switches to regular search. If false, then we do a FIXED_SEARCH using the hint until the hint_conflict_limit is reached.
  optional bool repair_hint = 167 [default = false];
  Specified by:
  
  getRepairHint in interface SatParametersOrBuilder
  
  Returns:
  
  The repairHint.
- setRepairHint
  
  public SatParameters.Builder setRepairHint(boolean value)
  If true, the solver tries to repair the solution given in the hint. This search terminates after the 'hint_conflict_limit' is reached and the solver switches to regular search. If false, then we do a FIXED_SEARCH using the hint until the hint_conflict_limit is reached.
  optional bool repair_hint = 167 [default = false];
  Parameters:
  
  value - The repairHint to set.
  
  Returns:
  
  This builder for chaining.
- clearRepairHint
  
  public SatParameters.Builder clearRepairHint()
  If true, the solver tries to repair the solution given in the hint. This search terminates after the 'hint_conflict_limit' is reached and the solver switches to regular search. If false, then we do a FIXED_SEARCH using the hint until the hint_conflict_limit is reached.
  optional bool repair_hint = 167 [default = false];
  Returns:
  
  This builder for chaining.
- hasExploitIntegerLpSolution
  
  public boolean hasExploitIntegerLpSolution()
  If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it. Note that since the LP relaxation may not contain all the constraints, such a solution is not necessarily a solution of the full problem.
  optional bool exploit_integer_lp_solution = 94 [default = true];
  Specified by:
  
  hasExploitIntegerLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitIntegerLpSolution field is set.
- getExploitIntegerLpSolution
  
  public boolean getExploitIntegerLpSolution()
  If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it. Note that since the LP relaxation may not contain all the constraints, such a solution is not necessarily a solution of the full problem.
  optional bool exploit_integer_lp_solution = 94 [default = true];
  Specified by:
  
  getExploitIntegerLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitIntegerLpSolution.
- setExploitIntegerLpSolution
  
  public SatParameters.Builder setExploitIntegerLpSolution(boolean value)
  If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it. Note that since the LP relaxation may not contain all the constraints, such a solution is not necessarily a solution of the full problem.
  optional bool exploit_integer_lp_solution = 94 [default = true];
  Parameters:
  
  value - The exploitIntegerLpSolution to set.
  
  Returns:
  
  This builder for chaining.
- clearExploitIntegerLpSolution
  
  public SatParameters.Builder clearExploitIntegerLpSolution()
  If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it. Note that since the LP relaxation may not contain all the constraints, such a solution is not necessarily a solution of the full problem.
  optional bool exploit_integer_lp_solution = 94 [default = true];
  Returns:
  
  This builder for chaining.
- hasExploitAllLpSolution
  
  public boolean hasExploitAllLpSolution()
  If true and the Lp relaxation of the problem has a solution, try to exploit it. This is same as above except in this case the lp solution might not be an integer solution.
  optional bool exploit_all_lp_solution = 116 [default = true];
  Specified by:
  
  hasExploitAllLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitAllLpSolution field is set.
- getExploitAllLpSolution
  
  public boolean getExploitAllLpSolution()
  If true and the Lp relaxation of the problem has a solution, try to exploit it. This is same as above except in this case the lp solution might not be an integer solution.
  optional bool exploit_all_lp_solution = 116 [default = true];
  Specified by:
  
  getExploitAllLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitAllLpSolution.
- setExploitAllLpSolution
  
  public SatParameters.Builder setExploitAllLpSolution(boolean value)
  If true and the Lp relaxation of the problem has a solution, try to exploit it. This is same as above except in this case the lp solution might not be an integer solution.
  optional bool exploit_all_lp_solution = 116 [default = true];
  Parameters:
  
  value - The exploitAllLpSolution to set.
  
  Returns:
  
  This builder for chaining.
- clearExploitAllLpSolution
  
  public SatParameters.Builder clearExploitAllLpSolution()
  If true and the Lp relaxation of the problem has a solution, try to exploit it. This is same as above except in this case the lp solution might not be an integer solution.
  optional bool exploit_all_lp_solution = 116 [default = true];
  Returns:
  
  This builder for chaining.
- hasExploitBestSolution
  
  public boolean hasExploitBestSolution()
  When branching on a variable, follow the last best solution value.
  optional bool exploit_best_solution = 130 [default = false];
  Specified by:
  
  hasExploitBestSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitBestSolution field is set.
- getExploitBestSolution
  
  public boolean getExploitBestSolution()
  When branching on a variable, follow the last best solution value.
  optional bool exploit_best_solution = 130 [default = false];
  Specified by:
  
  getExploitBestSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitBestSolution.
- setExploitBestSolution
  
  public SatParameters.Builder setExploitBestSolution(boolean value)
  When branching on a variable, follow the last best solution value.
  optional bool exploit_best_solution = 130 [default = false];
  Parameters:
  
  value - The exploitBestSolution to set.
  
  Returns:
  
  This builder for chaining.
- clearExploitBestSolution
  
  public SatParameters.Builder clearExploitBestSolution()
  When branching on a variable, follow the last best solution value.
  optional bool exploit_best_solution = 130 [default = false];
  Returns:
  
  This builder for chaining.
- hasExploitRelaxationSolution
  
  public boolean hasExploitRelaxationSolution()
  When branching on a variable, follow the last best relaxation solution value. We use the relaxation with the tightest bound on the objective as the best relaxation solution.
  optional bool exploit_relaxation_solution = 161 [default = false];
  Specified by:
  
  hasExploitRelaxationSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitRelaxationSolution field is set.
- getExploitRelaxationSolution
  
  public boolean getExploitRelaxationSolution()
  When branching on a variable, follow the last best relaxation solution value. We use the relaxation with the tightest bound on the objective as the best relaxation solution.
  optional bool exploit_relaxation_solution = 161 [default = false];
  Specified by:
  
  getExploitRelaxationSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitRelaxationSolution.
- setExploitRelaxationSolution
  
  public SatParameters.Builder setExploitRelaxationSolution(boolean value)
  When branching on a variable, follow the last best relaxation solution value. We use the relaxation with the tightest bound on the objective as the best relaxation solution.
  optional bool exploit_relaxation_solution = 161 [default = false];
  Parameters:
  
  value - The exploitRelaxationSolution to set.
  
  Returns:
  
  This builder for chaining.
- clearExploitRelaxationSolution
  
  public SatParameters.Builder clearExploitRelaxationSolution()
  When branching on a variable, follow the last best relaxation solution value. We use the relaxation with the tightest bound on the objective as the best relaxation solution.
  optional bool exploit_relaxation_solution = 161 [default = false];
  Returns:
  
  This builder for chaining.
- hasExploitObjective
  
  public boolean hasExploitObjective()
  When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
  optional bool exploit_objective = 131 [default = true];
  Specified by:
  
  hasExploitObjective in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitObjective field is set.
- getExploitObjective
  
  public boolean getExploitObjective()
  When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
  optional bool exploit_objective = 131 [default = true];
  Specified by:
  
  getExploitObjective in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitObjective.
- setExploitObjective
  
  public SatParameters.Builder setExploitObjective(boolean value)
  When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
  optional bool exploit_objective = 131 [default = true];
  Parameters:
  
  value - The exploitObjective to set.
  
  Returns:
  
  This builder for chaining.
- clearExploitObjective
  
  public SatParameters.Builder clearExploitObjective()
  When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
  optional bool exploit_objective = 131 [default = true];
  Returns:
  
  This builder for chaining.
- hasProbingPeriodAtRoot
  
  public boolean hasProbingPeriodAtRoot()
  If set at zero (the default), it is disabled. Otherwise the solver attempts probing at every 'probing_period' root node. Period of 1 enables probing at every root node.
  optional int64 probing_period_at_root = 142 [default = 0];
  Specified by:
  
  hasProbingPeriodAtRoot in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the probingPeriodAtRoot field is set.
- getProbingPeriodAtRoot
  
  public long getProbingPeriodAtRoot()
  If set at zero (the default), it is disabled. Otherwise the solver attempts probing at every 'probing_period' root node. Period of 1 enables probing at every root node.
  optional int64 probing_period_at_root = 142 [default = 0];
  Specified by:
  
  getProbingPeriodAtRoot in interface SatParametersOrBuilder
  
  Returns:
  
  The probingPeriodAtRoot.
- setProbingPeriodAtRoot
  
  public SatParameters.Builder setProbingPeriodAtRoot(long value)
  If set at zero (the default), it is disabled. Otherwise the solver attempts probing at every 'probing_period' root node. Period of 1 enables probing at every root node.
  optional int64 probing_period_at_root = 142 [default = 0];
  Parameters:
  
  value - The probingPeriodAtRoot to set.
  
  Returns:
  
  This builder for chaining.
- clearProbingPeriodAtRoot
  
  public SatParameters.Builder clearProbingPeriodAtRoot()
  If set at zero (the default), it is disabled. Otherwise the solver attempts probing at every 'probing_period' root node. Period of 1 enables probing at every root node.
  optional int64 probing_period_at_root = 142 [default = 0];
  Returns:
  
  This builder for chaining.
- hasUseProbingSearch
  
  public boolean hasUseProbingSearch()
  If true, search will continuously probe Boolean variables, and integer variable bounds.
  optional bool use_probing_search = 176 [default = false];
  Specified by:
  
  hasUseProbingSearch in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useProbingSearch field is set.
- getUseProbingSearch
  
  public boolean getUseProbingSearch()
  If true, search will continuously probe Boolean variables, and integer variable bounds.
  optional bool use_probing_search = 176 [default = false];
  Specified by:
  
  getUseProbingSearch in interface SatParametersOrBuilder
  
  Returns:
  
  The useProbingSearch.
- setUseProbingSearch
  
  public SatParameters.Builder setUseProbingSearch(boolean value)
  If true, search will continuously probe Boolean variables, and integer variable bounds.
  optional bool use_probing_search = 176 [default = false];
  Parameters:
  
  value - The useProbingSearch to set.
  
  Returns:
  
  This builder for chaining.
- clearUseProbingSearch
  
  public SatParameters.Builder clearUseProbingSearch()
  If true, search will continuously probe Boolean variables, and integer variable bounds.
  optional bool use_probing_search = 176 [default = false];
  Returns:
  
  This builder for chaining.
- hasPseudoCostReliabilityThreshold
  
  public boolean hasPseudoCostReliabilityThreshold()
  The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
  optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  Specified by:
  
  hasPseudoCostReliabilityThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the pseudoCostReliabilityThreshold field is set.
- getPseudoCostReliabilityThreshold
  
  public long getPseudoCostReliabilityThreshold()
  The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
  optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  Specified by:
  
  getPseudoCostReliabilityThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  The pseudoCostReliabilityThreshold.
- setPseudoCostReliabilityThreshold
  
  public SatParameters.Builder setPseudoCostReliabilityThreshold(long value)
  The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
  optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  Parameters:
  
  value - The pseudoCostReliabilityThreshold to set.
  
  Returns:
  
  This builder for chaining.
- clearPseudoCostReliabilityThreshold
  
  public SatParameters.Builder clearPseudoCostReliabilityThreshold()
  The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
  optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  Returns:
  
  This builder for chaining.
- hasOptimizeWithCore
  
  public boolean hasOptimizeWithCore()
  The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one. If this is true, then we use a core-based approach (like in max-SAT) when we try to increase the lower bound instead.
  optional bool optimize_with_core = 83 [default = false];
  Specified by:
  
  hasOptimizeWithCore in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the optimizeWithCore field is set.
- getOptimizeWithCore
  
  public boolean getOptimizeWithCore()
  The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one. If this is true, then we use a core-based approach (like in max-SAT) when we try to increase the lower bound instead.
  optional bool optimize_with_core = 83 [default = false];
  Specified by:
  
  getOptimizeWithCore in interface SatParametersOrBuilder
  
  Returns:
  
  The optimizeWithCore.
- setOptimizeWithCore
  
  public SatParameters.Builder setOptimizeWithCore(boolean value)
  The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one. If this is true, then we use a core-based approach (like in max-SAT) when we try to increase the lower bound instead.
  optional bool optimize_with_core = 83 [default = false];
  Parameters:
  
  value - The optimizeWithCore to set.
  
  Returns:
  
  This builder for chaining.
- clearOptimizeWithCore
  
  public SatParameters.Builder clearOptimizeWithCore()
  The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one. If this is true, then we use a core-based approach (like in max-SAT) when we try to increase the lower bound instead.
  optional bool optimize_with_core = 83 [default = false];
  Returns:
  
  This builder for chaining.
- hasBinarySearchNumConflicts
  
  public boolean hasBinarySearchNumConflicts()
  If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict. This can quickly reduce the objective domain on some problems.
  optional int32 binary_search_num_conflicts = 99 [default = -1];
  Specified by:
  
  hasBinarySearchNumConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the binarySearchNumConflicts field is set.
- getBinarySearchNumConflicts
  
  public int getBinarySearchNumConflicts()
  If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict. This can quickly reduce the objective domain on some problems.
  optional int32 binary_search_num_conflicts = 99 [default = -1];
  Specified by:
  
  getBinarySearchNumConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  The binarySearchNumConflicts.
- setBinarySearchNumConflicts
  
  public SatParameters.Builder setBinarySearchNumConflicts(int value)
  If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict. This can quickly reduce the objective domain on some problems.
  optional int32 binary_search_num_conflicts = 99 [default = -1];
  Parameters:
  
  value - The binarySearchNumConflicts to set.
  
  Returns:
  
  This builder for chaining.
- clearBinarySearchNumConflicts
  
  public SatParameters.Builder clearBinarySearchNumConflicts()
  If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict. This can quickly reduce the objective domain on some problems.
  optional int32 binary_search_num_conflicts = 99 [default = -1];
  Returns:
  
  This builder for chaining.
- hasOptimizeWithMaxHs
  
  public boolean hasOptimizeWithMaxHs()
  This has no effect if optimize_with_core is false. If true, use a different core-based algorithm similar to the max-HS algo for max-SAT. This is a hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT one. This is also related to the PhD work of tobyodavies@ "Automatic Logic-Based Benders Decomposition with MiniZinc" http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
  optional bool optimize_with_max_hs = 85 [default = false];
  Specified by:
  
  hasOptimizeWithMaxHs in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the optimizeWithMaxHs field is set.
- getOptimizeWithMaxHs
  
  public boolean getOptimizeWithMaxHs()
  This has no effect if optimize_with_core is false. If true, use a different core-based algorithm similar to the max-HS algo for max-SAT. This is a hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT one. This is also related to the PhD work of tobyodavies@ "Automatic Logic-Based Benders Decomposition with MiniZinc" http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
  optional bool optimize_with_max_hs = 85 [default = false];
  Specified by:
  
  getOptimizeWithMaxHs in interface SatParametersOrBuilder
  
  Returns:
  
  The optimizeWithMaxHs.
- setOptimizeWithMaxHs
  
  public SatParameters.Builder setOptimizeWithMaxHs(boolean value)
  This has no effect if optimize_with_core is false. If true, use a different core-based algorithm similar to the max-HS algo for max-SAT. This is a hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT one. This is also related to the PhD work of tobyodavies@ "Automatic Logic-Based Benders Decomposition with MiniZinc" http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
  optional bool optimize_with_max_hs = 85 [default = false];
  Parameters:
  
  value - The optimizeWithMaxHs to set.
  
  Returns:
  
  This builder for chaining.
- clearOptimizeWithMaxHs
  
  public SatParameters.Builder clearOptimizeWithMaxHs()
  This has no effect if optimize_with_core is false. If true, use a different core-based algorithm similar to the max-HS algo for max-SAT. This is a hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT one. This is also related to the PhD work of tobyodavies@ "Automatic Logic-Based Benders Decomposition with MiniZinc" http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
  optional bool optimize_with_max_hs = 85 [default = false];
  Returns:
  
  This builder for chaining.
- hasEnumerateAllSolutions
  
  public boolean hasEnumerateAllSolutions()
  Whether we enumerate all solutions of a problem without objective. Note that setting this to true automatically disable the presolve. This is because the presolve rules only guarantee the existence of one feasible solution to the presolved problem. TODO(user): Do not disable the presolve and let the user choose what behavior is best by setting keep_all_feasible_solutions_in_presolve.
  optional bool enumerate_all_solutions = 87 [default = false];
  Specified by:
  
  hasEnumerateAllSolutions in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the enumerateAllSolutions field is set.
- getEnumerateAllSolutions
  
  public boolean getEnumerateAllSolutions()
  Whether we enumerate all solutions of a problem without objective. Note that setting this to true automatically disable the presolve. This is because the presolve rules only guarantee the existence of one feasible solution to the presolved problem. TODO(user): Do not disable the presolve and let the user choose what behavior is best by setting keep_all_feasible_solutions_in_presolve.
  optional bool enumerate_all_solutions = 87 [default = false];
  Specified by:
  
  getEnumerateAllSolutions in interface SatParametersOrBuilder
  
  Returns:
  
  The enumerateAllSolutions.
- setEnumerateAllSolutions
  
  public SatParameters.Builder setEnumerateAllSolutions(boolean value)
  Whether we enumerate all solutions of a problem without objective. Note that setting this to true automatically disable the presolve. This is because the presolve rules only guarantee the existence of one feasible solution to the presolved problem. TODO(user): Do not disable the presolve and let the user choose what behavior is best by setting keep_all_feasible_solutions_in_presolve.
  optional bool enumerate_all_solutions = 87 [default = false];
  Parameters:
  
  value - The enumerateAllSolutions to set.
  
  Returns:
  
  This builder for chaining.
- clearEnumerateAllSolutions
  
  public SatParameters.Builder clearEnumerateAllSolutions()
  Whether we enumerate all solutions of a problem without objective. Note that setting this to true automatically disable the presolve. This is because the presolve rules only guarantee the existence of one feasible solution to the presolved problem. TODO(user): Do not disable the presolve and let the user choose what behavior is best by setting keep_all_feasible_solutions_in_presolve.
  optional bool enumerate_all_solutions = 87 [default = false];
  Returns:
  
  This builder for chaining.
- hasKeepAllFeasibleSolutionsInPresolve
  
  public boolean hasKeepAllFeasibleSolutionsInPresolve()
  If true, we disable the presolve reductions that remove feasible solutions from the search space. Such solution are usually dominated by a "better" solution that is kept, but depending on the situation, we might want to keep all solutions. A trivial example is when a variable is unused. If this is true, then the presolve will not fix it to an arbitrary value and it will stay in the search space.
  optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
  Specified by:
  
  hasKeepAllFeasibleSolutionsInPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the keepAllFeasibleSolutionsInPresolve field is set.
- getKeepAllFeasibleSolutionsInPresolve
  
  public boolean getKeepAllFeasibleSolutionsInPresolve()
  If true, we disable the presolve reductions that remove feasible solutions from the search space. Such solution are usually dominated by a "better" solution that is kept, but depending on the situation, we might want to keep all solutions. A trivial example is when a variable is unused. If this is true, then the presolve will not fix it to an arbitrary value and it will stay in the search space.
  optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
  Specified by:
  
  getKeepAllFeasibleSolutionsInPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The keepAllFeasibleSolutionsInPresolve.
- setKeepAllFeasibleSolutionsInPresolve
  
  public SatParameters.Builder setKeepAllFeasibleSolutionsInPresolve(boolean value)
  If true, we disable the presolve reductions that remove feasible solutions from the search space. Such solution are usually dominated by a "better" solution that is kept, but depending on the situation, we might want to keep all solutions. A trivial example is when a variable is unused. If this is true, then the presolve will not fix it to an arbitrary value and it will stay in the search space.
  optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
  Parameters:
  
  value - The keepAllFeasibleSolutionsInPresolve to set.
  
  Returns:
  
  This builder for chaining.
- clearKeepAllFeasibleSolutionsInPresolve
  
  public SatParameters.Builder clearKeepAllFeasibleSolutionsInPresolve()
  If true, we disable the presolve reductions that remove feasible solutions from the search space. Such solution are usually dominated by a "better" solution that is kept, but depending on the situation, we might want to keep all solutions. A trivial example is when a variable is unused. If this is true, then the presolve will not fix it to an arbitrary value and it will stay in the search space.
  optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
  Returns:
  
  This builder for chaining.
- hasFillTightenedDomainsInResponse
  
  public boolean hasFillTightenedDomainsInResponse()
  If true, add information about the derived variable domains to the CpSolverResponse. It is an option because it makes the response slighly bigger and there is a bit more work involved during the postsolve to construct it, but it should still have a low overhead. See the tightened_variables field in CpSolverResponse for more details.
  optional bool fill_tightened_domains_in_response = 132 [default = false];
  Specified by:
  
  hasFillTightenedDomainsInResponse in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the fillTightenedDomainsInResponse field is set.
- getFillTightenedDomainsInResponse
  
  public boolean getFillTightenedDomainsInResponse()
  If true, add information about the derived variable domains to the CpSolverResponse. It is an option because it makes the response slighly bigger and there is a bit more work involved during the postsolve to construct it, but it should still have a low overhead. See the tightened_variables field in CpSolverResponse for more details.
  optional bool fill_tightened_domains_in_response = 132 [default = false];
  Specified by:
  
  getFillTightenedDomainsInResponse in interface SatParametersOrBuilder
  
  Returns:
  
  The fillTightenedDomainsInResponse.
- setFillTightenedDomainsInResponse
  
  public SatParameters.Builder setFillTightenedDomainsInResponse(boolean value)
  If true, add information about the derived variable domains to the CpSolverResponse. It is an option because it makes the response slighly bigger and there is a bit more work involved during the postsolve to construct it, but it should still have a low overhead. See the tightened_variables field in CpSolverResponse for more details.
  optional bool fill_tightened_domains_in_response = 132 [default = false];
  Parameters:
  
  value - The fillTightenedDomainsInResponse to set.
  
  Returns:
  
  This builder for chaining.
- clearFillTightenedDomainsInResponse
  
  public SatParameters.Builder clearFillTightenedDomainsInResponse()
  If true, add information about the derived variable domains to the CpSolverResponse. It is an option because it makes the response slighly bigger and there is a bit more work involved during the postsolve to construct it, but it should still have a low overhead. See the tightened_variables field in CpSolverResponse for more details.
  optional bool fill_tightened_domains_in_response = 132 [default = false];
  Returns:
  
  This builder for chaining.
- hasInstantiateAllVariables
  
  public boolean hasInstantiateAllVariables()
  If true, the solver will add a default integer branching strategy to the already defined search strategy.
  optional bool instantiate_all_variables = 106 [default = true];
  Specified by:
  
  hasInstantiateAllVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the instantiateAllVariables field is set.
- getInstantiateAllVariables
  
  public boolean getInstantiateAllVariables()
  If true, the solver will add a default integer branching strategy to the already defined search strategy.
  optional bool instantiate_all_variables = 106 [default = true];
  Specified by:
  
  getInstantiateAllVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The instantiateAllVariables.
- setInstantiateAllVariables
  
  public SatParameters.Builder setInstantiateAllVariables(boolean value)
  If true, the solver will add a default integer branching strategy to the already defined search strategy.
  optional bool instantiate_all_variables = 106 [default = true];
  Parameters:
  
  value - The instantiateAllVariables to set.
  
  Returns:
  
  This builder for chaining.
- clearInstantiateAllVariables
  
  public SatParameters.Builder clearInstantiateAllVariables()
  If true, the solver will add a default integer branching strategy to the already defined search strategy.
  optional bool instantiate_all_variables = 106 [default = true];
  Returns:
  
  This builder for chaining.
- hasAutoDetectGreaterThanAtLeastOneOf
  
  public boolean hasAutoDetectGreaterThanAtLeastOneOf()
  If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present. This is usually useful to have but can be slow on model with a lot of precedence.
  optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  Specified by:
  
  hasAutoDetectGreaterThanAtLeastOneOf in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the autoDetectGreaterThanAtLeastOneOf field is set.
- getAutoDetectGreaterThanAtLeastOneOf
  
  public boolean getAutoDetectGreaterThanAtLeastOneOf()
  If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present. This is usually useful to have but can be slow on model with a lot of precedence.
  optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  Specified by:
  
  getAutoDetectGreaterThanAtLeastOneOf in interface SatParametersOrBuilder
  
  Returns:
  
  The autoDetectGreaterThanAtLeastOneOf.
- setAutoDetectGreaterThanAtLeastOneOf
  
  public SatParameters.Builder setAutoDetectGreaterThanAtLeastOneOf(boolean value)
  If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present. This is usually useful to have but can be slow on model with a lot of precedence.
  optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  Parameters:
  
  value - The autoDetectGreaterThanAtLeastOneOf to set.
  
  Returns:
  
  This builder for chaining.
- clearAutoDetectGreaterThanAtLeastOneOf
  
  public SatParameters.Builder clearAutoDetectGreaterThanAtLeastOneOf()
  If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present. This is usually useful to have but can be slow on model with a lot of precedence.
  optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  Returns:
  
  This builder for chaining.
- hasStopAfterFirstSolution
  
  public boolean hasStopAfterFirstSolution()
  For an optimization problem, stop the solver as soon as we have a solution.
  optional bool stop_after_first_solution = 98 [default = false];
  Specified by:
  
  hasStopAfterFirstSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the stopAfterFirstSolution field is set.
- getStopAfterFirstSolution
  
  public boolean getStopAfterFirstSolution()
  For an optimization problem, stop the solver as soon as we have a solution.
  optional bool stop_after_first_solution = 98 [default = false];
  Specified by:
  
  getStopAfterFirstSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The stopAfterFirstSolution.
- setStopAfterFirstSolution
  
  public SatParameters.Builder setStopAfterFirstSolution(boolean value)
  For an optimization problem, stop the solver as soon as we have a solution.
  optional bool stop_after_first_solution = 98 [default = false];
  Parameters:
  
  value - The stopAfterFirstSolution to set.
  
  Returns:
  
  This builder for chaining.
- clearStopAfterFirstSolution
  
  public SatParameters.Builder clearStopAfterFirstSolution()
  For an optimization problem, stop the solver as soon as we have a solution.
  optional bool stop_after_first_solution = 98 [default = false];
  Returns:
  
  This builder for chaining.
- hasStopAfterPresolve
  
  public boolean hasStopAfterPresolve()
  Mainly used when improving the presolver. When true, stops the solver after the presolve is complete.
  optional bool stop_after_presolve = 149 [default = false];
  Specified by:
  
  hasStopAfterPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the stopAfterPresolve field is set.
- getStopAfterPresolve
  
  public boolean getStopAfterPresolve()
  Mainly used when improving the presolver. When true, stops the solver after the presolve is complete.
  optional bool stop_after_presolve = 149 [default = false];
  Specified by:
  
  getStopAfterPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The stopAfterPresolve.
- setStopAfterPresolve
  
  public SatParameters.Builder setStopAfterPresolve(boolean value)
  Mainly used when improving the presolver. When true, stops the solver after the presolve is complete.
  optional bool stop_after_presolve = 149 [default = false];
  Parameters:
  
  value - The stopAfterPresolve to set.
  
  Returns:
  
  This builder for chaining.
- clearStopAfterPresolve
  
  public SatParameters.Builder clearStopAfterPresolve()
  Mainly used when improving the presolver. When true, stops the solver after the presolve is complete.
  optional bool stop_after_presolve = 149 [default = false];
  Returns:
  
  This builder for chaining.
- hasNumSearchWorkers
  
  public boolean hasNumSearchWorkers()
  Specify the number of parallel workers to use during search. A number <= 1 means no parallelism. As of 2020-04-10, if you're using SAT via MPSolver (to solve integer programs) this field is overridden with a value of 8, if the field is not set *explicitly*. Thus, always set this field explicitly or via MPSolver::SetNumThreads().
  optional int32 num_search_workers = 100 [default = 1];
  Specified by:
  
  hasNumSearchWorkers in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the numSearchWorkers field is set.
- getNumSearchWorkers
  
  public int getNumSearchWorkers()
  Specify the number of parallel workers to use during search. A number <= 1 means no parallelism. As of 2020-04-10, if you're using SAT via MPSolver (to solve integer programs) this field is overridden with a value of 8, if the field is not set *explicitly*. Thus, always set this field explicitly or via MPSolver::SetNumThreads().
  optional int32 num_search_workers = 100 [default = 1];
  Specified by:
  
  getNumSearchWorkers in interface SatParametersOrBuilder
  
  Returns:
  
  The numSearchWorkers.
- setNumSearchWorkers
  
  public SatParameters.Builder setNumSearchWorkers(int value)
  Specify the number of parallel workers to use during search. A number <= 1 means no parallelism. As of 2020-04-10, if you're using SAT via MPSolver (to solve integer programs) this field is overridden with a value of 8, if the field is not set *explicitly*. Thus, always set this field explicitly or via MPSolver::SetNumThreads().
  optional int32 num_search_workers = 100 [default = 1];
  Parameters:
  
  value - The numSearchWorkers to set.
  
  Returns:
  
  This builder for chaining.
- clearNumSearchWorkers
  
  public SatParameters.Builder clearNumSearchWorkers()
  Specify the number of parallel workers to use during search. A number <= 1 means no parallelism. As of 2020-04-10, if you're using SAT via MPSolver (to solve integer programs) this field is overridden with a value of 8, if the field is not set *explicitly*. Thus, always set this field explicitly or via MPSolver::SetNumThreads().
  optional int32 num_search_workers = 100 [default = 1];
  Returns:
  
  This builder for chaining.
- hasInterleaveSearch
  
  public boolean hasInterleaveSearch()
  Experimental. If this is true, then we interleave all our major search strategy and distribute the work amongst num_search_workers. The search is deterministic (independently of num_search_workers!), and we schedule and wait for interleave_batch_size task to be completed before synchronizing and scheduling the next batch of tasks.
  optional bool interleave_search = 136 [default = false];
  Specified by:
  
  hasInterleaveSearch in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the interleaveSearch field is set.
- getInterleaveSearch
  
  public boolean getInterleaveSearch()
  Experimental. If this is true, then we interleave all our major search strategy and distribute the work amongst num_search_workers. The search is deterministic (independently of num_search_workers!), and we schedule and wait for interleave_batch_size task to be completed before synchronizing and scheduling the next batch of tasks.
  optional bool interleave_search = 136 [default = false];
  Specified by:
  
  getInterleaveSearch in interface SatParametersOrBuilder
  
  Returns:
  
  The interleaveSearch.
- setInterleaveSearch
  
  public SatParameters.Builder setInterleaveSearch(boolean value)
  Experimental. If this is true, then we interleave all our major search strategy and distribute the work amongst num_search_workers. The search is deterministic (independently of num_search_workers!), and we schedule and wait for interleave_batch_size task to be completed before synchronizing and scheduling the next batch of tasks.
  optional bool interleave_search = 136 [default = false];
  Parameters:
  
  value - The interleaveSearch to set.
  
  Returns:
  
  This builder for chaining.
- clearInterleaveSearch
  
  public SatParameters.Builder clearInterleaveSearch()
  Experimental. If this is true, then we interleave all our major search strategy and distribute the work amongst num_search_workers. The search is deterministic (independently of num_search_workers!), and we schedule and wait for interleave_batch_size task to be completed before synchronizing and scheduling the next batch of tasks.
  optional bool interleave_search = 136 [default = false];
  Returns:
  
  This builder for chaining.
- hasInterleaveBatchSize
  
  public boolean hasInterleaveBatchSize()
  
  optional int32 interleave_batch_size = 134 [default = 1];
  
  Specified by:
  
  hasInterleaveBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the interleaveBatchSize field is set.
- getInterleaveBatchSize
  
  public int getInterleaveBatchSize()
  
  optional int32 interleave_batch_size = 134 [default = 1];
  
  Specified by:
  
  getInterleaveBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  The interleaveBatchSize.
- setInterleaveBatchSize
  
  public SatParameters.Builder setInterleaveBatchSize(int value)
  
  optional int32 interleave_batch_size = 134 [default = 1];
  
  Parameters:
  
  value - The interleaveBatchSize to set.
  
  Returns:
  
  This builder for chaining.
- clearInterleaveBatchSize
  
  public SatParameters.Builder clearInterleaveBatchSize()
  
  optional int32 interleave_batch_size = 134 [default = 1];
  
  Returns:
  
  This builder for chaining.
- hasReduceMemoryUsageInInterleaveMode
  
  public boolean hasReduceMemoryUsageInInterleaveMode()
  Temporary parameter until the memory usage is more optimized.
  optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  Specified by:
  
  hasReduceMemoryUsageInInterleaveMode in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the reduceMemoryUsageInInterleaveMode field is set.
- getReduceMemoryUsageInInterleaveMode
  
  public boolean getReduceMemoryUsageInInterleaveMode()
  Temporary parameter until the memory usage is more optimized.
  optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  Specified by:
  
  getReduceMemoryUsageInInterleaveMode in interface SatParametersOrBuilder
  
  Returns:
  
  The reduceMemoryUsageInInterleaveMode.
- setReduceMemoryUsageInInterleaveMode
  
  public SatParameters.Builder setReduceMemoryUsageInInterleaveMode(boolean value)
  Temporary parameter until the memory usage is more optimized.
  optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  Parameters:
  
  value - The reduceMemoryUsageInInterleaveMode to set.
  
  Returns:
  
  This builder for chaining.
- clearReduceMemoryUsageInInterleaveMode
  
  public SatParameters.Builder clearReduceMemoryUsageInInterleaveMode()
  Temporary parameter until the memory usage is more optimized.
  optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  Returns:
  
  This builder for chaining.
- hasShareObjectiveBounds
  
  public boolean hasShareObjectiveBounds()
  Allows objective sharing between workers.
  optional bool share_objective_bounds = 113 [default = true];
  Specified by:
  
  hasShareObjectiveBounds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the shareObjectiveBounds field is set.
- getShareObjectiveBounds
  
  public boolean getShareObjectiveBounds()
  Allows objective sharing between workers.
  optional bool share_objective_bounds = 113 [default = true];
  Specified by:
  
  getShareObjectiveBounds in interface SatParametersOrBuilder
  
  Returns:
  
  The shareObjectiveBounds.
- setShareObjectiveBounds
  
  public SatParameters.Builder setShareObjectiveBounds(boolean value)
  Allows objective sharing between workers.
  optional bool share_objective_bounds = 113 [default = true];
  Parameters:
  
  value - The shareObjectiveBounds to set.
  
  Returns:
  
  This builder for chaining.
- clearShareObjectiveBounds
  
  public SatParameters.Builder clearShareObjectiveBounds()
  Allows objective sharing between workers.
  optional bool share_objective_bounds = 113 [default = true];
  Returns:
  
  This builder for chaining.
- hasShareLevelZeroBounds
  
  public boolean hasShareLevelZeroBounds()
  Allows sharing of the bounds of modified variables at level 0.
  optional bool share_level_zero_bounds = 114 [default = true];
  Specified by:
  
  hasShareLevelZeroBounds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the shareLevelZeroBounds field is set.
- getShareLevelZeroBounds
  
  public boolean getShareLevelZeroBounds()
  Allows sharing of the bounds of modified variables at level 0.
  optional bool share_level_zero_bounds = 114 [default = true];
  Specified by:
  
  getShareLevelZeroBounds in interface SatParametersOrBuilder
  
  Returns:
  
  The shareLevelZeroBounds.
- setShareLevelZeroBounds
  
  public SatParameters.Builder setShareLevelZeroBounds(boolean value)
  Allows sharing of the bounds of modified variables at level 0.
  optional bool share_level_zero_bounds = 114 [default = true];
  Parameters:
  
  value - The shareLevelZeroBounds to set.
  
  Returns:
  
  This builder for chaining.
- clearShareLevelZeroBounds
  
  public SatParameters.Builder clearShareLevelZeroBounds()
  Allows sharing of the bounds of modified variables at level 0.
  optional bool share_level_zero_bounds = 114 [default = true];
  Returns:
  
  This builder for chaining.
- hasUseLnsOnly
  
  public boolean hasUseLnsOnly()
  LNS parameters.
  optional bool use_lns_only = 101 [default = false];
  Specified by:
  
  hasUseLnsOnly in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useLnsOnly field is set.
- getUseLnsOnly
  
  public boolean getUseLnsOnly()
  LNS parameters.
  optional bool use_lns_only = 101 [default = false];
  Specified by:
  
  getUseLnsOnly in interface SatParametersOrBuilder
  
  Returns:
  
  The useLnsOnly.
- setUseLnsOnly
  
  public SatParameters.Builder setUseLnsOnly(boolean value)
  LNS parameters.
  optional bool use_lns_only = 101 [default = false];
  Parameters:
  
  value - The useLnsOnly to set.
  
  Returns:
  
  This builder for chaining.
- clearUseLnsOnly
  
  public SatParameters.Builder clearUseLnsOnly()
  LNS parameters.
  optional bool use_lns_only = 101 [default = false];
  Returns:
  
  This builder for chaining.
- hasLnsFocusOnDecisionVariables
  
  public boolean hasLnsFocusOnDecisionVariables()
  
  optional bool lns_focus_on_decision_variables = 105 [default = false];
  
  Specified by:
  
  hasLnsFocusOnDecisionVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the lnsFocusOnDecisionVariables field is set.
- getLnsFocusOnDecisionVariables
  
  public boolean getLnsFocusOnDecisionVariables()
  
  optional bool lns_focus_on_decision_variables = 105 [default = false];
  
  Specified by:
  
  getLnsFocusOnDecisionVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The lnsFocusOnDecisionVariables.
- setLnsFocusOnDecisionVariables
  
  public SatParameters.Builder setLnsFocusOnDecisionVariables(boolean value)
  
  optional bool lns_focus_on_decision_variables = 105 [default = false];
  
  Parameters:
  
  value - The lnsFocusOnDecisionVariables to set.
  
  Returns:
  
  This builder for chaining.
- clearLnsFocusOnDecisionVariables
  
  public SatParameters.Builder clearLnsFocusOnDecisionVariables()
  
  optional bool lns_focus_on_decision_variables = 105 [default = false];
  
  Returns:
  
  This builder for chaining.
- hasLnsExpandIntervalsInConstraintGraph
  
  public boolean hasLnsExpandIntervalsInConstraintGraph()
  
  optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
  
  Specified by:
  
  hasLnsExpandIntervalsInConstraintGraph in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the lnsExpandIntervalsInConstraintGraph field is set.
- getLnsExpandIntervalsInConstraintGraph
  
  public boolean getLnsExpandIntervalsInConstraintGraph()
  
  optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
  
  Specified by:
  
  getLnsExpandIntervalsInConstraintGraph in interface SatParametersOrBuilder
  
  Returns:
  
  The lnsExpandIntervalsInConstraintGraph.
- setLnsExpandIntervalsInConstraintGraph
  
  public SatParameters.Builder setLnsExpandIntervalsInConstraintGraph(boolean value)
  
  optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
  
  Parameters:
  
  value - The lnsExpandIntervalsInConstraintGraph to set.
  
  Returns:
  
  This builder for chaining.
- clearLnsExpandIntervalsInConstraintGraph
  
  public SatParameters.Builder clearLnsExpandIntervalsInConstraintGraph()
  
  optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
  
  Returns:
  
  This builder for chaining.
- hasUseRinsLns
  
  public boolean hasUseRinsLns()
  Turns on relaxation induced neighborhood generator.
  optional bool use_rins_lns = 129 [default = true];
  Specified by:
  
  hasUseRinsLns in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useRinsLns field is set.
- getUseRinsLns
  
  public boolean getUseRinsLns()
  Turns on relaxation induced neighborhood generator.
  optional bool use_rins_lns = 129 [default = true];
  Specified by:
  
  getUseRinsLns in interface SatParametersOrBuilder
  
  Returns:
  
  The useRinsLns.
- setUseRinsLns
  
  public SatParameters.Builder setUseRinsLns(boolean value)
  Turns on relaxation induced neighborhood generator.
  optional bool use_rins_lns = 129 [default = true];
  Parameters:
  
  value - The useRinsLns to set.
  
  Returns:
  
  This builder for chaining.
- clearUseRinsLns
  
  public SatParameters.Builder clearUseRinsLns()
  Turns on relaxation induced neighborhood generator.
  optional bool use_rins_lns = 129 [default = true];
  Returns:
  
  This builder for chaining.
- hasUseFeasibilityPump
  
  public boolean hasUseFeasibilityPump()
  Adds a feasibility pump subsolver along with lns subsolvers.
  optional bool use_feasibility_pump = 164 [default = true];
  Specified by:
  
  hasUseFeasibilityPump in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useFeasibilityPump field is set.
- getUseFeasibilityPump
  
  public boolean getUseFeasibilityPump()
  Adds a feasibility pump subsolver along with lns subsolvers.
  optional bool use_feasibility_pump = 164 [default = true];
  Specified by:
  
  getUseFeasibilityPump in interface SatParametersOrBuilder
  
  Returns:
  
  The useFeasibilityPump.
- setUseFeasibilityPump
  
  public SatParameters.Builder setUseFeasibilityPump(boolean value)
  Adds a feasibility pump subsolver along with lns subsolvers.
  optional bool use_feasibility_pump = 164 [default = true];
  Parameters:
  
  value - The useFeasibilityPump to set.
  
  Returns:
  
  This builder for chaining.
- clearUseFeasibilityPump
  
  public SatParameters.Builder clearUseFeasibilityPump()
  Adds a feasibility pump subsolver along with lns subsolvers.
  optional bool use_feasibility_pump = 164 [default = true];
  Returns:
  
  This builder for chaining.
- hasFpRounding
  
  public boolean hasFpRounding()
  
  optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  
  Specified by:
  
  hasFpRounding in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the fpRounding field is set.
- getFpRounding
  
  public SatParameters.FPRoundingMethod getFpRounding()
  
  optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  
  Specified by:
  
  getFpRounding in interface SatParametersOrBuilder
  
  Returns:
  
  The fpRounding.
- setFpRounding
  
  public SatParameters.Builder setFpRounding(SatParameters.FPRoundingMethod value)
  
  optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  
  Parameters:
  
  value - The fpRounding to set.
  
  Returns:
  
  This builder for chaining.
- clearFpRounding
  
  public SatParameters.Builder clearFpRounding()
  
  optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  
  Returns:
  
  This builder for chaining.
- hasUseRelaxationLns
  
  public boolean hasUseRelaxationLns()
  Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
  optional bool use_relaxation_lns = 150 [default = false];
  Specified by:
  
  hasUseRelaxationLns in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useRelaxationLns field is set.
- getUseRelaxationLns
  
  public boolean getUseRelaxationLns()
  Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
  optional bool use_relaxation_lns = 150 [default = false];
  Specified by:
  
  getUseRelaxationLns in interface SatParametersOrBuilder
  
  Returns:
  
  The useRelaxationLns.
- setUseRelaxationLns
  
  public SatParameters.Builder setUseRelaxationLns(boolean value)
  Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
  optional bool use_relaxation_lns = 150 [default = false];
  Parameters:
  
  value - The useRelaxationLns to set.
  
  Returns:
  
  This builder for chaining.
- clearUseRelaxationLns
  
  public SatParameters.Builder clearUseRelaxationLns()
  Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
  optional bool use_relaxation_lns = 150 [default = false];
  Returns:
  
  This builder for chaining.
- hasDiversifyLnsParams
  
  public boolean hasDiversifyLnsParams()
  If true, registers more lns subsolvers with different parameters.
  optional bool diversify_lns_params = 137 [default = false];
  Specified by:
  
  hasDiversifyLnsParams in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the diversifyLnsParams field is set.
- getDiversifyLnsParams
  
  public boolean getDiversifyLnsParams()
  If true, registers more lns subsolvers with different parameters.
  optional bool diversify_lns_params = 137 [default = false];
  Specified by:
  
  getDiversifyLnsParams in interface SatParametersOrBuilder
  
  Returns:
  
  The diversifyLnsParams.
- setDiversifyLnsParams
  
  public SatParameters.Builder setDiversifyLnsParams(boolean value)
  If true, registers more lns subsolvers with different parameters.
  optional bool diversify_lns_params = 137 [default = false];
  Parameters:
  
  value - The diversifyLnsParams to set.
  
  Returns:
  
  This builder for chaining.
- clearDiversifyLnsParams
  
  public SatParameters.Builder clearDiversifyLnsParams()
  If true, registers more lns subsolvers with different parameters.
  optional bool diversify_lns_params = 137 [default = false];
  Returns:
  
  This builder for chaining.
- hasRandomizeSearch
  
  public boolean hasRandomizeSearch()
  Randomize fixed search.
  optional bool randomize_search = 103 [default = false];
  Specified by:
  
  hasRandomizeSearch in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomizeSearch field is set.
- getRandomizeSearch
  
  public boolean getRandomizeSearch()
  Randomize fixed search.
  optional bool randomize_search = 103 [default = false];
  Specified by:
  
  getRandomizeSearch in interface SatParametersOrBuilder
  
  Returns:
  
  The randomizeSearch.
- setRandomizeSearch
  
  public SatParameters.Builder setRandomizeSearch(boolean value)
  Randomize fixed search.
  optional bool randomize_search = 103 [default = false];
  Parameters:
  
  value - The randomizeSearch to set.
  
  Returns:
  
  This builder for chaining.
- clearRandomizeSearch
  
  public SatParameters.Builder clearRandomizeSearch()
  Randomize fixed search.
  optional bool randomize_search = 103 [default = false];
  Returns:
  
  This builder for chaining.
- hasSearchRandomizationTolerance
  
  public boolean hasSearchRandomizationTolerance()
  Search randomization will collect equivalent 'max valued' variables, and pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST, all unassigned variables are equivalent. If the variable strategy is CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned variables, then the set of max valued variables will be all unassigned variables where lm <= variable min <= lm + search_randomization_tolerance
  optional int64 search_randomization_tolerance = 104 [default = 0];
  Specified by:
  
  hasSearchRandomizationTolerance in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the searchRandomizationTolerance field is set.
- getSearchRandomizationTolerance
  
  public long getSearchRandomizationTolerance()
  Search randomization will collect equivalent 'max valued' variables, and pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST, all unassigned variables are equivalent. If the variable strategy is CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned variables, then the set of max valued variables will be all unassigned variables where lm <= variable min <= lm + search_randomization_tolerance
  optional int64 search_randomization_tolerance = 104 [default = 0];
  Specified by:
  
  getSearchRandomizationTolerance in interface SatParametersOrBuilder
  
  Returns:
  
  The searchRandomizationTolerance.
- setSearchRandomizationTolerance
  
  public SatParameters.Builder setSearchRandomizationTolerance(long value)
  Search randomization will collect equivalent 'max valued' variables, and pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST, all unassigned variables are equivalent. If the variable strategy is CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned variables, then the set of max valued variables will be all unassigned variables where lm <= variable min <= lm + search_randomization_tolerance
  optional int64 search_randomization_tolerance = 104 [default = 0];
  Parameters:
  
  value - The searchRandomizationTolerance to set.
  
  Returns:
  
  This builder for chaining.
- clearSearchRandomizationTolerance
  
  public SatParameters.Builder clearSearchRandomizationTolerance()
  Search randomization will collect equivalent 'max valued' variables, and pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST, all unassigned variables are equivalent. If the variable strategy is CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned variables, then the set of max valued variables will be all unassigned variables where lm <= variable min <= lm + search_randomization_tolerance
  optional int64 search_randomization_tolerance = 104 [default = 0];
  Returns:
  
  This builder for chaining.
- hasUseOptionalVariables
  
  public boolean hasUseOptionalVariables()
  If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional. This allows to propagate them as if they were present in some situation.
  optional bool use_optional_variables = 108 [default = true];
  Specified by:
  
  hasUseOptionalVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useOptionalVariables field is set.
- getUseOptionalVariables
  
  public boolean getUseOptionalVariables()
  If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional. This allows to propagate them as if they were present in some situation.
  optional bool use_optional_variables = 108 [default = true];
  Specified by:
  
  getUseOptionalVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The useOptionalVariables.
- setUseOptionalVariables
  
  public SatParameters.Builder setUseOptionalVariables(boolean value)
  If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional. This allows to propagate them as if they were present in some situation.
  optional bool use_optional_variables = 108 [default = true];
  Parameters:
  
  value - The useOptionalVariables to set.
  
  Returns:
  
  This builder for chaining.
- clearUseOptionalVariables
  
  public SatParameters.Builder clearUseOptionalVariables()
  If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional. This allows to propagate them as if they were present in some situation.
  optional bool use_optional_variables = 108 [default = true];
  Returns:
  
  This builder for chaining.
- hasUseExactLpReason
  
  public boolean hasUseExactLpReason()
  The solver usually exploit the LP relaxation of a model. If this option is true, then whatever is infered by the LP will be used like an heuristic to compute EXACT propagation on the IP. So with this option, there is no numerical imprecision issues.
  optional bool use_exact_lp_reason = 109 [default = true];
  Specified by:
  
  hasUseExactLpReason in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useExactLpReason field is set.
- getUseExactLpReason
  
  public boolean getUseExactLpReason()
  The solver usually exploit the LP relaxation of a model. If this option is true, then whatever is infered by the LP will be used like an heuristic to compute EXACT propagation on the IP. So with this option, there is no numerical imprecision issues.
  optional bool use_exact_lp_reason = 109 [default = true];
  Specified by:
  
  getUseExactLpReason in interface SatParametersOrBuilder
  
  Returns:
  
  The useExactLpReason.
- setUseExactLpReason
  
  public SatParameters.Builder setUseExactLpReason(boolean value)
  The solver usually exploit the LP relaxation of a model. If this option is true, then whatever is infered by the LP will be used like an heuristic to compute EXACT propagation on the IP. So with this option, there is no numerical imprecision issues.
  optional bool use_exact_lp_reason = 109 [default = true];
  Parameters:
  
  value - The useExactLpReason to set.
  
  Returns:
  
  This builder for chaining.
- clearUseExactLpReason
  
  public SatParameters.Builder clearUseExactLpReason()
  The solver usually exploit the LP relaxation of a model. If this option is true, then whatever is infered by the LP will be used like an heuristic to compute EXACT propagation on the IP. So with this option, there is no numerical imprecision issues.
  optional bool use_exact_lp_reason = 109 [default = true];
  Returns:
  
  This builder for chaining.
- hasUseBranchingInLp
  
  public boolean hasUseBranchingInLp()
  If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
  optional bool use_branching_in_lp = 139 [default = false];
  Specified by:
  
  hasUseBranchingInLp in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useBranchingInLp field is set.
- getUseBranchingInLp
  
  public boolean getUseBranchingInLp()
  If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
  optional bool use_branching_in_lp = 139 [default = false];
  Specified by:
  
  getUseBranchingInLp in interface SatParametersOrBuilder
  
  Returns:
  
  The useBranchingInLp.
- setUseBranchingInLp
  
  public SatParameters.Builder setUseBranchingInLp(boolean value)
  If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
  optional bool use_branching_in_lp = 139 [default = false];
  Parameters:
  
  value - The useBranchingInLp to set.
  
  Returns:
  
  This builder for chaining.
- clearUseBranchingInLp
  
  public SatParameters.Builder clearUseBranchingInLp()
  If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
  optional bool use_branching_in_lp = 139 [default = false];
  Returns:
  
  This builder for chaining.
- hasUseCombinedNoOverlap
  
  public boolean hasUseCombinedNoOverlap()
  This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem. Like 1000 intervals, but 1M intervals in the no-overlap constraints covering them.
  optional bool use_combined_no_overlap = 133 [default = false];
  Specified by:
  
  hasUseCombinedNoOverlap in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useCombinedNoOverlap field is set.
- getUseCombinedNoOverlap
  
  public boolean getUseCombinedNoOverlap()
  This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem. Like 1000 intervals, but 1M intervals in the no-overlap constraints covering them.
  optional bool use_combined_no_overlap = 133 [default = false];
  Specified by:
  
  getUseCombinedNoOverlap in interface SatParametersOrBuilder
  
  Returns:
  
  The useCombinedNoOverlap.
- setUseCombinedNoOverlap
  
  public SatParameters.Builder setUseCombinedNoOverlap(boolean value)
  This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem. Like 1000 intervals, but 1M intervals in the no-overlap constraints covering them.
  optional bool use_combined_no_overlap = 133 [default = false];
  Parameters:
  
  value - The useCombinedNoOverlap to set.
  
  Returns:
  
  This builder for chaining.
- clearUseCombinedNoOverlap
  
  public SatParameters.Builder clearUseCombinedNoOverlap()
  This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem. Like 1000 intervals, but 1M intervals in the no-overlap constraints covering them.
  optional bool use_combined_no_overlap = 133 [default = false];
  Returns:
  
  This builder for chaining.
- hasCatchSigintSignal
  
  public boolean hasCatchSigintSignal()
  Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve. If set, catching the SIGINT signal will terminate the search gracefully, as if a time limit was reached.
  optional bool catch_sigint_signal = 135 [default = true];
  Specified by:
  
  hasCatchSigintSignal in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the catchSigintSignal field is set.
- getCatchSigintSignal
  
  public boolean getCatchSigintSignal()
  Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve. If set, catching the SIGINT signal will terminate the search gracefully, as if a time limit was reached.
  optional bool catch_sigint_signal = 135 [default = true];
  Specified by:
  
  getCatchSigintSignal in interface SatParametersOrBuilder
  
  Returns:
  
  The catchSigintSignal.
- setCatchSigintSignal
  
  public SatParameters.Builder setCatchSigintSignal(boolean value)
  Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve. If set, catching the SIGINT signal will terminate the search gracefully, as if a time limit was reached.
  optional bool catch_sigint_signal = 135 [default = true];
  Parameters:
  
  value - The catchSigintSignal to set.
  
  Returns:
  
  This builder for chaining.
- clearCatchSigintSignal
  
  public SatParameters.Builder clearCatchSigintSignal()
  Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve. If set, catching the SIGINT signal will terminate the search gracefully, as if a time limit was reached.
  optional bool catch_sigint_signal = 135 [default = true];
  Returns:
  
  This builder for chaining.
- hasUseImpliedBounds
  
  public boolean hasUseImpliedBounds()
  Stores and exploits "implied-bounds" in the solver. That is, relations of the form literal => (var >= bound). This is currently used to derive stronger cuts.
  optional bool use_implied_bounds = 144 [default = true];
  Specified by:
  
  hasUseImpliedBounds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useImpliedBounds field is set.
- getUseImpliedBounds
  
  public boolean getUseImpliedBounds()
  Stores and exploits "implied-bounds" in the solver. That is, relations of the form literal => (var >= bound). This is currently used to derive stronger cuts.
  optional bool use_implied_bounds = 144 [default = true];
  Specified by:
  
  getUseImpliedBounds in interface SatParametersOrBuilder
  
  Returns:
  
  The useImpliedBounds.
- setUseImpliedBounds
  
  public SatParameters.Builder setUseImpliedBounds(boolean value)
  Stores and exploits "implied-bounds" in the solver. That is, relations of the form literal => (var >= bound). This is currently used to derive stronger cuts.
  optional bool use_implied_bounds = 144 [default = true];
  Parameters:
  
  value - The useImpliedBounds to set.
  
  Returns:
  
  This builder for chaining.
- clearUseImpliedBounds
  
  public SatParameters.Builder clearUseImpliedBounds()
  Stores and exploits "implied-bounds" in the solver. That is, relations of the form literal => (var >= bound). This is currently used to derive stronger cuts.
  optional bool use_implied_bounds = 144 [default = true];
  Returns:
  
  This builder for chaining.
- hasPolishLpSolution
  
  public boolean hasPolishLpSolution()
  Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis. This helps on some problems, but not so much on others. It also cost of bit of time to do such polish step.
  optional bool polish_lp_solution = 175 [default = false];
  Specified by:
  
  hasPolishLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the polishLpSolution field is set.
- getPolishLpSolution
  
  public boolean getPolishLpSolution()
  Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis. This helps on some problems, but not so much on others. It also cost of bit of time to do such polish step.
  optional bool polish_lp_solution = 175 [default = false];
  Specified by:
  
  getPolishLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The polishLpSolution.
- setPolishLpSolution
  
  public SatParameters.Builder setPolishLpSolution(boolean value)
  Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis. This helps on some problems, but not so much on others. It also cost of bit of time to do such polish step.
  optional bool polish_lp_solution = 175 [default = false];
  Parameters:
  
  value - The polishLpSolution to set.
  
  Returns:
  
  This builder for chaining.
- clearPolishLpSolution
  
  public SatParameters.Builder clearPolishLpSolution()
  Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis. This helps on some problems, but not so much on others. It also cost of bit of time to do such polish step.
  optional bool polish_lp_solution = 175 [default = false];
  Returns:
  
  This builder for chaining.
- hasConvertIntervals
  
  public boolean hasConvertIntervals()
  Temporary flag util the feature is more mature. This convert intervals to the newer proto format that support affine start/var/end instead of just variables. It changes a bit the search and is not always better currently.
  optional bool convert_intervals = 177 [default = false];
  Specified by:
  
  hasConvertIntervals in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the convertIntervals field is set.
- getConvertIntervals
  
  public boolean getConvertIntervals()
  Temporary flag util the feature is more mature. This convert intervals to the newer proto format that support affine start/var/end instead of just variables. It changes a bit the search and is not always better currently.
  optional bool convert_intervals = 177 [default = false];
  Specified by:
  
  getConvertIntervals in interface SatParametersOrBuilder
  
  Returns:
  
  The convertIntervals.
- setConvertIntervals
  
  public SatParameters.Builder setConvertIntervals(boolean value)
  Temporary flag util the feature is more mature. This convert intervals to the newer proto format that support affine start/var/end instead of just variables. It changes a bit the search and is not always better currently.
  optional bool convert_intervals = 177 [default = false];
  Parameters:
  
  value - The convertIntervals to set.
  
  Returns:
  
  This builder for chaining.
- clearConvertIntervals
  
  public SatParameters.Builder clearConvertIntervals()
  Temporary flag util the feature is more mature. This convert intervals to the newer proto format that support affine start/var/end instead of just variables. It changes a bit the search and is not always better currently.
  optional bool convert_intervals = 177 [default = false];
  Returns:
  
  This builder for chaining.
- hasSymmetryLevel
  
  public boolean hasSymmetryLevel()
  Whether we try to automatically detect the symmetries in a model and exploit them. Currently, at level 1 we detect them in presolve and try to fix Booleans. At level 2, we also do some form of dynamic symmetry breaking during search.
  optional int32 symmetry_level = 183 [default = 2];
  Specified by:
  
  hasSymmetryLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the symmetryLevel field is set.
- getSymmetryLevel
  
  public int getSymmetryLevel()
  Whether we try to automatically detect the symmetries in a model and exploit them. Currently, at level 1 we detect them in presolve and try to fix Booleans. At level 2, we also do some form of dynamic symmetry breaking during search.
  optional int32 symmetry_level = 183 [default = 2];
  Specified by:
  
  getSymmetryLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The symmetryLevel.
- setSymmetryLevel
  
  public SatParameters.Builder setSymmetryLevel(int value)
  Whether we try to automatically detect the symmetries in a model and exploit them. Currently, at level 1 we detect them in presolve and try to fix Booleans. At level 2, we also do some form of dynamic symmetry breaking during search.
  optional int32 symmetry_level = 183 [default = 2];
  Parameters:
  
  value - The symmetryLevel to set.
  
  Returns:
  
  This builder for chaining.
- clearSymmetryLevel
  
  public SatParameters.Builder clearSymmetryLevel()
  Whether we try to automatically detect the symmetries in a model and exploit them. Currently, at level 1 we detect them in presolve and try to fix Booleans. At level 2, we also do some form of dynamic symmetry breaking during search.
  optional int32 symmetry_level = 183 [default = 2];
  Returns:
  
  This builder for chaining.
- hasMipMaxBound
  
  public boolean hasMipMaxBound()
  We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use. If the MIP model expect larger variable value in the solution, then the converted model will likely not be relevant.
  optional double mip_max_bound = 124 [default = 10000000];
  Specified by:
  
  hasMipMaxBound in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipMaxBound field is set.
- getMipMaxBound
  
  public double getMipMaxBound()
  We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use. If the MIP model expect larger variable value in the solution, then the converted model will likely not be relevant.
  optional double mip_max_bound = 124 [default = 10000000];
  Specified by:
  
  getMipMaxBound in interface SatParametersOrBuilder
  
  Returns:
  
  The mipMaxBound.
- setMipMaxBound
  
  public SatParameters.Builder setMipMaxBound(double value)
  We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use. If the MIP model expect larger variable value in the solution, then the converted model will likely not be relevant.
  optional double mip_max_bound = 124 [default = 10000000];
  Parameters:
  
  value - The mipMaxBound to set.
  
  Returns:
  
  This builder for chaining.
- clearMipMaxBound
  
  public SatParameters.Builder clearMipMaxBound()
  We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use. If the MIP model expect larger variable value in the solution, then the converted model will likely not be relevant.
  optional double mip_max_bound = 124 [default = 10000000];
  Returns:
  
  This builder for chaining.
- hasMipVarScaling
  
  public boolean hasMipVarScaling()
  All continuous variable of the problem will be multiplied by this factor. By default, we don't do any variable scaling and rely on the MIP model to specify continuous variable domain with the wanted precision.
  optional double mip_var_scaling = 125 [default = 1];
  Specified by:
  
  hasMipVarScaling in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipVarScaling field is set.
- getMipVarScaling
  
  public double getMipVarScaling()
  All continuous variable of the problem will be multiplied by this factor. By default, we don't do any variable scaling and rely on the MIP model to specify continuous variable domain with the wanted precision.
  optional double mip_var_scaling = 125 [default = 1];
  Specified by:
  
  getMipVarScaling in interface SatParametersOrBuilder
  
  Returns:
  
  The mipVarScaling.
- setMipVarScaling
  
  public SatParameters.Builder setMipVarScaling(double value)
  All continuous variable of the problem will be multiplied by this factor. By default, we don't do any variable scaling and rely on the MIP model to specify continuous variable domain with the wanted precision.
  optional double mip_var_scaling = 125 [default = 1];
  Parameters:
  
  value - The mipVarScaling to set.
  
  Returns:
  
  This builder for chaining.
- clearMipVarScaling
  
  public SatParameters.Builder clearMipVarScaling()
  All continuous variable of the problem will be multiplied by this factor. By default, we don't do any variable scaling and rely on the MIP model to specify continuous variable domain with the wanted precision.
  optional double mip_var_scaling = 125 [default = 1];
  Returns:
  
  This builder for chaining.
- hasMipAutomaticallyScaleVariables
  
  public boolean hasMipAutomaticallyScaleVariables()
  If true, some continuous variable might be automatially scaled. For now, this is only the case where we detect that a variable is actually an integer multiple of a constant. For instance, variables of the form k * 0.5 are quite frequent, and if we detect this, we will scale such variable domain by 2 to make it implied integer.
  optional bool mip_automatically_scale_variables = 166 [default = true];
  Specified by:
  
  hasMipAutomaticallyScaleVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipAutomaticallyScaleVariables field is set.
- getMipAutomaticallyScaleVariables
  
  public boolean getMipAutomaticallyScaleVariables()
  If true, some continuous variable might be automatially scaled. For now, this is only the case where we detect that a variable is actually an integer multiple of a constant. For instance, variables of the form k * 0.5 are quite frequent, and if we detect this, we will scale such variable domain by 2 to make it implied integer.
  optional bool mip_automatically_scale_variables = 166 [default = true];
  Specified by:
  
  getMipAutomaticallyScaleVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The mipAutomaticallyScaleVariables.
- setMipAutomaticallyScaleVariables
  
  public SatParameters.Builder setMipAutomaticallyScaleVariables(boolean value)
  If true, some continuous variable might be automatially scaled. For now, this is only the case where we detect that a variable is actually an integer multiple of a constant. For instance, variables of the form k * 0.5 are quite frequent, and if we detect this, we will scale such variable domain by 2 to make it implied integer.
  optional bool mip_automatically_scale_variables = 166 [default = true];
  Parameters:
  
  value - The mipAutomaticallyScaleVariables to set.
  
  Returns:
  
  This builder for chaining.
- clearMipAutomaticallyScaleVariables
  
  public SatParameters.Builder clearMipAutomaticallyScaleVariables()
  If true, some continuous variable might be automatially scaled. For now, this is only the case where we detect that a variable is actually an integer multiple of a constant. For instance, variables of the form k * 0.5 are quite frequent, and if we detect this, we will scale such variable domain by 2 to make it implied integer.
  optional bool mip_automatically_scale_variables = 166 [default = true];
  Returns:
  
  This builder for chaining.
- hasMipWantedPrecision
  
  public boolean hasMipWantedPrecision()
  When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients. We will choose the lowest power such that we have no potential overflow and the worst case constraint activity error do not exceed this threshold relative to the constraint bounds. We also use this to decide by how much we relax the constraint bounds so that we can have a feasible integer solution of constraints involving continuous variable. This is required for instance when you have an == rhs constraint as in many situation you cannot have a perfect equality with integer variables and coefficients.
  optional double mip_wanted_precision = 126 [default = 1e-06];
  Specified by:
  
  hasMipWantedPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipWantedPrecision field is set.
- getMipWantedPrecision
  
  public double getMipWantedPrecision()
  When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients. We will choose the lowest power such that we have no potential overflow and the worst case constraint activity error do not exceed this threshold relative to the constraint bounds. We also use this to decide by how much we relax the constraint bounds so that we can have a feasible integer solution of constraints involving continuous variable. This is required for instance when you have an == rhs constraint as in many situation you cannot have a perfect equality with integer variables and coefficients.
  optional double mip_wanted_precision = 126 [default = 1e-06];
  Specified by:
  
  getMipWantedPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  The mipWantedPrecision.
- setMipWantedPrecision
  
  public SatParameters.Builder setMipWantedPrecision(double value)
  When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients. We will choose the lowest power such that we have no potential overflow and the worst case constraint activity error do not exceed this threshold relative to the constraint bounds. We also use this to decide by how much we relax the constraint bounds so that we can have a feasible integer solution of constraints involving continuous variable. This is required for instance when you have an == rhs constraint as in many situation you cannot have a perfect equality with integer variables and coefficients.
  optional double mip_wanted_precision = 126 [default = 1e-06];
  Parameters:
  
  value - The mipWantedPrecision to set.
  
  Returns:
  
  This builder for chaining.
- clearMipWantedPrecision
  
  public SatParameters.Builder clearMipWantedPrecision()
  When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients. We will choose the lowest power such that we have no potential overflow and the worst case constraint activity error do not exceed this threshold relative to the constraint bounds. We also use this to decide by how much we relax the constraint bounds so that we can have a feasible integer solution of constraints involving continuous variable. This is required for instance when you have an == rhs constraint as in many situation you cannot have a perfect equality with integer variables and coefficients.
  optional double mip_wanted_precision = 126 [default = 1e-06];
  Returns:
  
  This builder for chaining.
- hasMipMaxActivityExponent
  
  public boolean hasMipMaxActivityExponent()
  To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power. Because of this, we cannot always reach the "mip_wanted_precision" parameter above. This can go as high as 62, but some internal algo currently abort early if they might run into integer overflow, so it is better to keep it a bit lower than this.
  optional int32 mip_max_activity_exponent = 127 [default = 53];
  Specified by:
  
  hasMipMaxActivityExponent in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipMaxActivityExponent field is set.
- getMipMaxActivityExponent
  
  public int getMipMaxActivityExponent()
  To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power. Because of this, we cannot always reach the "mip_wanted_precision" parameter above. This can go as high as 62, but some internal algo currently abort early if they might run into integer overflow, so it is better to keep it a bit lower than this.
  optional int32 mip_max_activity_exponent = 127 [default = 53];
  Specified by:
  
  getMipMaxActivityExponent in interface SatParametersOrBuilder
  
  Returns:
  
  The mipMaxActivityExponent.
- setMipMaxActivityExponent
  
  public SatParameters.Builder setMipMaxActivityExponent(int value)
  To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power. Because of this, we cannot always reach the "mip_wanted_precision" parameter above. This can go as high as 62, but some internal algo currently abort early if they might run into integer overflow, so it is better to keep it a bit lower than this.
  optional int32 mip_max_activity_exponent = 127 [default = 53];
  Parameters:
  
  value - The mipMaxActivityExponent to set.
  
  Returns:
  
  This builder for chaining.
- clearMipMaxActivityExponent
  
  public SatParameters.Builder clearMipMaxActivityExponent()
  To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power. Because of this, we cannot always reach the "mip_wanted_precision" parameter above. This can go as high as 62, but some internal algo currently abort early if they might run into integer overflow, so it is better to keep it a bit lower than this.
  optional int32 mip_max_activity_exponent = 127 [default = 53];
  Returns:
  
  This builder for chaining.
- hasMipCheckPrecision
  
  public boolean hasMipCheckPrecision()
  As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling. We use this threshold to enphasize in the logs when the precision seems bad.
  optional double mip_check_precision = 128 [default = 0.0001];
  Specified by:
  
  hasMipCheckPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipCheckPrecision field is set.
- getMipCheckPrecision
  
  public double getMipCheckPrecision()
  As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling. We use this threshold to enphasize in the logs when the precision seems bad.
  optional double mip_check_precision = 128 [default = 0.0001];
  Specified by:
  
  getMipCheckPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  The mipCheckPrecision.
- setMipCheckPrecision
  
  public SatParameters.Builder setMipCheckPrecision(double value)
  As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling. We use this threshold to enphasize in the logs when the precision seems bad.
  optional double mip_check_precision = 128 [default = 0.0001];
  Parameters:
  
  value - The mipCheckPrecision to set.
  
  Returns:
  
  This builder for chaining.
- clearMipCheckPrecision
  
  public SatParameters.Builder clearMipCheckPrecision()
  As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling. We use this threshold to enphasize in the logs when the precision seems bad.
  optional double mip_check_precision = 128 [default = 0.0001];
  Returns:
  
  This builder for chaining.
- setUnknownFields
  
  public final SatParameters.Builder setUnknownFields(com.google.protobuf.UnknownFieldSet unknownFields)
  
  Specified by:
  
  setUnknownFields in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  setUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>
- mergeUnknownFields
  
  public final SatParameters.Builder mergeUnknownFields(com.google.protobuf.UnknownFieldSet unknownFields)
  
  Specified by:
  
  mergeUnknownFields in interface com.google.protobuf.Message.Builder
  
  Overrides:
  
  mergeUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<SatParameters.Builder>

Class SatParameters.Builder

Method Summary

Methods inherited from class com.google.protobuf.GeneratedMessageV3.Builder

Methods inherited from class com.google.protobuf.AbstractMessage.Builder

Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder

Methods inherited from class java.lang.Object

Methods inherited from interface com.google.protobuf.MessageLite.Builder

Methods inherited from interface com.google.protobuf.MessageOrBuilder

Method Details

getDescriptor

internalGetFieldAccessorTable

clear

getDescriptorForType

getDefaultInstanceForType

build

buildPartial

clone

setField

clearField

clearOneof

setRepeatedField

addRepeatedField

mergeFrom

mergeFrom

isInitialized

mergeFrom

hasName

getName

getNameBytes

setName

clearName

setNameBytes

hasPreferredVariableOrder

getPreferredVariableOrder

setPreferredVariableOrder

clearPreferredVariableOrder

hasInitialPolarity

getInitialPolarity

setInitialPolarity

clearInitialPolarity

hasUsePhaseSaving

getUsePhaseSaving

setUsePhaseSaving

clearUsePhaseSaving

hasPolarityRephaseIncrement

getPolarityRephaseIncrement

setPolarityRephaseIncrement

clearPolarityRephaseIncrement

hasRandomPolarityRatio

getRandomPolarityRatio

setRandomPolarityRatio

clearRandomPolarityRatio

hasRandomBranchesRatio

getRandomBranchesRatio

setRandomBranchesRatio

clearRandomBranchesRatio

hasUseErwaHeuristic

getUseErwaHeuristic

setUseErwaHeuristic

clearUseErwaHeuristic

hasInitialVariablesActivity

getInitialVariablesActivity

setInitialVariablesActivity

clearInitialVariablesActivity

hasAlsoBumpVariablesInConflictReasons

getAlsoBumpVariablesInConflictReasons

setAlsoBumpVariablesInConflictReasons

clearAlsoBumpVariablesInConflictReasons

hasMinimizationAlgorithm

getMinimizationAlgorithm

setMinimizationAlgorithm

clearMinimizationAlgorithm

hasBinaryMinimizationAlgorithm

getBinaryMinimizationAlgorithm

setBinaryMinimizationAlgorithm

clearBinaryMinimizationAlgorithm

hasSubsumptionDuringConflictAnalysis

getSubsumptionDuringConflictAnalysis

setSubsumptionDuringConflictAnalysis

clearSubsumptionDuringConflictAnalysis