SatParameters.Builder (com.google.ortools:ortools-java 9.10.4067 API)

java.lang.Object
- com.google.protobuf.AbstractMessageLite.Builder
- - com.google.protobuf.AbstractMessage.Builder<BuilderT>
  - - com.google.protobuf.GeneratedMessage.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.GeneratedMessage.Builder<SatParameters.Builder>
implements SatParametersOrBuilder
```
```
 Contains the definitions for all the sat algorithm parameters and their
 default values.

 NEXT TAG: 284
 
```
Protobuf type operations_research.sat.SatParameters

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SatParameters.Builder`	`addAllExtraSubsolvers(java.lang.Iterable<java.lang.String> values)` A convenient way to add more workers types.
`SatParameters.Builder`	`addAllIgnoreSubsolvers(java.lang.Iterable<java.lang.String> values)` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`SatParameters.Builder`	`addAllRestartAlgorithms(java.lang.Iterable<? extends SatParameters.RestartAlgorithm> values)` The restart strategies will change each time the strategy_counter is increased.
`SatParameters.Builder`	`addAllSubsolverParams(java.lang.Iterable<? extends SatParameters> values)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`addAllSubsolvers(java.lang.Iterable<java.lang.String> values)` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`SatParameters.Builder`	`addExtraSubsolvers(java.lang.String value)` A convenient way to add more workers types.
`SatParameters.Builder`	`addExtraSubsolversBytes(com.google.protobuf.ByteString value)` A convenient way to add more workers types.
`SatParameters.Builder`	`addIgnoreSubsolvers(java.lang.String value)` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`SatParameters.Builder`	`addIgnoreSubsolversBytes(com.google.protobuf.ByteString value)` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`SatParameters.Builder`	`addRestartAlgorithms(SatParameters.RestartAlgorithm value)` The restart strategies will change each time the strategy_counter is increased.
`SatParameters.Builder`	`addSubsolverParams(int index, SatParameters.Builder builderForValue)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`addSubsolverParams(int index, SatParameters value)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`addSubsolverParams(SatParameters.Builder builderForValue)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`addSubsolverParams(SatParameters value)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`addSubsolverParamsBuilder()` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`addSubsolverParamsBuilder(int index)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`addSubsolvers(java.lang.String value)` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`SatParameters.Builder`	`addSubsolversBytes(com.google.protobuf.ByteString value)` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`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`	`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`	`clearAddObjectiveCut()` When the LP objective is fractional, do we add the cut that forces the linear objective expression to be greater or equal to this fractional value rounded up? We can always do that since our objective is integer, and combined with MIR heuristic to reduce the coefficient of such cut, it can help.
`SatParameters.Builder`	`clearAddRltCuts()` Whether we generate RLT cuts.
`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`	`clearAtMostOneMaxExpansionSize()` All at_most_one constraints with a size <= param will be replaced by a quadratic number of binary implications.
`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`	`clearClauseCleanupRatio()` During a cleanup, if clause_cleanup_target is 0, we will delete the clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed target of clauses to keep.
`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`	`clearCoreMinimizationLevel()` If positive, we spend some effort on each core: - At level 1, we use a simple heuristic to try to minimize an UNSAT core.
`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`	`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`	`clearCutLevel()` Control the global cut effort.
`SatParameters.Builder`	`clearCutMaxActiveCountValue()` These parameters are similar to sat clause management activity parameters.
`SatParameters.Builder`	`clearDebugCrashOnBadHint()` Crash if we do not manage to complete the hint into a full solution.
`SatParameters.Builder`	`clearDebugMaxNumPresolveOperations()` If positive, try to stop just after that many presolve rules have been applied.
`SatParameters.Builder`	`clearDebugPostsolveWithFullSolver()` We have two different postsolve code.
`SatParameters.Builder`	`clearDefaultRestartAlgorithms()` `optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`SatParameters.Builder`	`clearDetectLinearizedProduct()` Infer products of Boolean or of Boolean time IntegerVariable from the linear constrainst in the problem.
`SatParameters.Builder`	`clearDetectTableWithCost()` If true, we detect variable that are unique to a table constraint and only there to encode a cost on each tuple.
`SatParameters.Builder`	`clearDisableConstraintExpansion()` If true, it disable all constraint expansion.
`SatParameters.Builder`	`clearDiversifyLnsParams()` If true, registers more lns subsolvers with different parameters.
`SatParameters.Builder`	`clearEncodeComplexLinearConstraintWithInteger()` Linear constraint with a complex right hand side (more than a single interval) need to be expanded, there is a couple of way to do that.
`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`	`clearExpandReservoirConstraints()` If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`SatParameters.Builder`	`clearExploitAllLpSolution()` If true and the Lp relaxation of the problem has a solution, try to exploit it.
`SatParameters.Builder`	`clearExploitAllPrecedences()` `optional bool exploit_all_precedences = 220 [default = false];`
`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`	`clearExtraSubsolvers()` A convenient way to add more workers types.
`SatParameters.Builder`	`clearFeasibilityJumpDecay()` On each restart, we randomly choose if we use decay (with this parameter) or no decay.
`SatParameters.Builder`	`clearFeasibilityJumpEnableRestarts()` When stagnating, feasibility jump will either restart from a default solution (with some possible randomization), or randomly pertubate the current solution.
`SatParameters.Builder`	`clearFeasibilityJumpLinearizationLevel()` How much do we linearize the problem in the local search code.
`SatParameters.Builder`	`clearFeasibilityJumpMaxExpandedConstraintSize()` Maximum size of no_overlap or no_overlap_2d constraint for a quadratic expansion.
`SatParameters.Builder`	`clearFeasibilityJumpRestartFactor()` This is a factor that directly influence the work before each restart.
`SatParameters.Builder`	`clearFeasibilityJumpVarPerburbationRangeRatio()` Max distance between the default value and the pertubated value relative to the range of the domain of the variable.
`SatParameters.Builder`	`clearFeasibilityJumpVarRandomizationProbability()` Probability for a variable to have a non default value upon restarts or perturbations.
`SatParameters.Builder`	`clearFillAdditionalSolutionsInResponse()` If true, the final response addition_solutions field will be filled with all solutions from our solutions pool.
`SatParameters.Builder`	`clearFillTightenedDomainsInResponse()` If true, add information about the derived variable domains to the CpSolverResponse.
`SatParameters.Builder`	`clearFindBigLinearOverlap()` Try to find large "rectangle" in the linear constraint matrix with identical lines.
`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`	`clearFixVariablesToTheirHintedValue()` If true, variables appearing in the solution hints will be fixed to their hinted value.
`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`	`clearIgnoreNames()` If true, we don't keep names in our internal copy of the user given model.
`SatParameters.Builder`	`clearIgnoreSubsolvers()` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`SatParameters.Builder`	`clearInferAllDiffs()` Run a max-clique code amongst all the x != y we can find and try to infer set of variables that are all different.
`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`	`clearInprocessingDtimeRatio()` Proportion of deterministic time we should spend on inprocessing.
`SatParameters.Builder`	`clearInprocessingMinimizationDtime()` Parameters for an heuristic similar to the one described in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf This is the amount of dtime we should spend on this technique during each inprocessing phase.
`SatParameters.Builder`	`clearInprocessingProbingDtime()` The amount of dtime we should spend on probing for each inprocessing round.
`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 = 0];`
`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`	`clearLinearSplitSize()` Linear constraints that are not pseudo-Boolean and that are longer than this size will be split into sqrt(size) intermediate sums in order to have faster propation in the CP engine.
`SatParameters.Builder`	`clearLogPrefix()` Add a prefix to all logs.
`SatParameters.Builder`	`clearLogSearchProgress()` Whether the solver should log the search progress.
`SatParameters.Builder`	`clearLogSubsolverStatistics()` Whether the solver should display per sub-solver search statistics.
`SatParameters.Builder`	`clearLogToResponse()` Log to response proto.
`SatParameters.Builder`	`clearLogToStdout()` Log to stdout.
`SatParameters.Builder`	`clearLpDualTolerance()` `optional double lp_dual_tolerance = 267 [default = 1e-07];`
`SatParameters.Builder`	`clearLpPrimalTolerance()` The internal LP tolerances used by CP-SAT.
`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`	`clearMaxDomainSizeWhenEncodingEqNeqConstraints()` When loading ax + by ==/!= c when x and y are both fully encoded.
`SatParameters.Builder`	`clearMaxIntegerRoundingScaling()` In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`SatParameters.Builder`	`clearMaxLinMaxSizeForExpansion()` If the number of expressions in the lin_max is less that the max size parameter, model expansion replaces target = max(xi) by linear constraint with the introduction of new booleans bi such that bi => target == xi.
`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`	`clearMaxNumIntervalsForTimetableEdgeFinding()` Max number of intervals for the timetable_edge_finding algorithm to propagate.
`SatParameters.Builder`	`clearMaxPairsPairwiseReasoningInNoOverlap2D()` If the number of pairs to look is below this threshold, do an extra step of propagation in the no_overlap_2d constraint by looking at all pairs of intervals.
`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`	`clearMaxSizeToCreatePrecedenceLiteralsInDisjunctive()` Create one literal for each disjunction of two pairs of tasks.
`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`	`clearMinimizeReductionDuringPbResolution()` A different algorithm during PB resolution.
`SatParameters.Builder`	`clearMinNumLnsWorkers()` Obsolete parameter.
`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 automatically 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`	`clearMipComputeTrueObjectiveBound()` Even if we make big error when scaling the objective, we can always derive a correct lower bound on the original objective by using the exact lower bound on the scaled integer version of the objective.
`SatParameters.Builder`	`clearMipDropTolerance()` Any value in the input mip with a magnitude lower than this will be set to zero.
`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`	`clearMipMaxValidMagnitude()` Any finite values in the input MIP must be below this threshold, otherwise the model will be reported invalid.
`SatParameters.Builder`	`clearMipPresolveLevel()` When solving a MIP, we do some basic floating point presolving before scaling the problem to integer to be handled by CP-SAT.
`SatParameters.Builder`	`clearMipScaleLargeDomain()` If this is false, then mip_var_scaling is only applied to variables with "small" domain.
`SatParameters.Builder`	`clearMipTreatHighMagnitudeBoundsAsInfinity()` By default, any variable/constraint bound with a finite value and a magnitude greater than the mip_max_valid_magnitude will result with a invalid model.
`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`	`clearNewLinearPropagation()` The new linear propagation code treat all constraints at once and use an adaptation of Bellman-Ford-Tarjan to propagate constraint in a smarter order and potentially detect propagation cycle earlier.
`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()` `optional int32 num_search_workers = 100 [default = 0];`
`SatParameters.Builder`	`clearNumViolationLs()` This will create incomplete subsolvers (that are not LNS subsolvers) that use the feasibility jump code to find improving solution, treating the objective improvement as a hard constraint.
`SatParameters.Builder`	`clearNumWorkers()` Specify the number of parallel workers (i.e.
`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`	`clearOnlySolveIp()` If one try to solve a MIP model with CP-SAT, because we assume all variable to be integer after scaling, we will not necessarily have the correct optimal.
`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`	`clearOptimizeWithLbTreeSearch()` Do a more conventional tree search (by opposition to SAT based one) where we keep all the explored node in a tree.
`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`	`clearPresolveInclusionWorkLimit()` A few presolve operations involve detecting constraints included in other constraint.
`SatParameters.Builder`	`clearPresolveProbingDeterministicTimeLimit()` `optional double presolve_probing_deterministic_time_limit = 57 [default = 30];`
`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`	`clearProbingDeterministicTimeLimit()` The maximum "deterministic" time limit to spend in probing.
`SatParameters.Builder`	`clearProbingNumCombinationsLimit()` How many combinations of pairs or triplets of variables we want to scan.
`SatParameters.Builder`	`clearPropagationLoopDetectionFactor()` Some search decisions might cause a really large number of propagations to happen when integer variables with large domains are only reduced by 1 at each step.
`SatParameters.Builder`	`clearPseudoCostReliabilityThreshold()` The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`SatParameters.Builder`	`clearPushAllTasksTowardStart()` Experimental code: specify if the objective pushes all tasks toward the start of the schedule.
`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`	`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`	`clearRootLpIterations()` Even at the root node, we do not want to spend too much time on the LP if it is "difficult".
`SatParameters.Builder`	`clearSearchBranching()` `optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`SatParameters.Builder`	`clearSearchRandomVariablePoolSize()` Search randomization will collect the top 'search_random_variable_pool_size' valued variables, and pick one randomly.
`SatParameters.Builder`	`clearShareBinaryClauses()` Allows sharing of new learned binary clause between workers.
`SatParameters.Builder`	`clearSharedTreeMaxNodesPerWorker()` In order to limit total shared memory and communication overhead, limit the total number of nodes that may be generated in the shared tree.
`SatParameters.Builder`	`clearSharedTreeNumWorkers()` Enables experimental workstealing-like shared tree search.
`SatParameters.Builder`	`clearSharedTreeOpenLeavesPerWorker()` How many open leaf nodes should the shared tree maintain per worker.
`SatParameters.Builder`	`clearSharedTreeSplitStrategy()` `optional .operations_research.sat.SatParameters.SharedTreeSplitStrategy shared_tree_split_strategy = 239 [default = SPLIT_STRATEGY_AUTO];`
`SatParameters.Builder`	`clearSharedTreeWorkerMinRestartsPerSubtree()` Minimum number of restarts before a worker will replace a subtree that looks "bad" based on the average LBD of learned clauses.
`SatParameters.Builder`	`clearSharedTreeWorkerObjectiveSplitProbability()` After their assigned prefix, shared tree workers will branch on the objective with this probability.
`SatParameters.Builder`	`clearShareLevelZeroBounds()` Allows sharing of the bounds of modified variables at level 0.
`SatParameters.Builder`	`clearShareObjectiveBounds()` Allows objective sharing between workers.
`SatParameters.Builder`	`clearShavingSearchDeterministicTime()` Specifies the amount of deterministic time spent of each try at shaving a bound in the shaving search.
`SatParameters.Builder`	`clearSolutionPoolSize()` Size of the top-n different solutions kept by the solver.
`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`	`clearStopAfterRootPropagation()` `optional bool stop_after_root_propagation = 252 [default = false];`
`SatParameters.Builder`	`clearStrategyChangeIncreaseRatio()` The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`SatParameters.Builder`	`clearSubsolverParams()` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`clearSubsolvers()` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`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`	`clearTableCompressionLevel()` How much we try to "compress" a table constraint.
`SatParameters.Builder`	`clearTestFeasibilityJump()` Disable every other type of subsolver, setting this turns CP-SAT into a pure local-search solver.
`SatParameters.Builder`	`clearUseAbslRandom()` `optional bool use_absl_random = 180 [default = false];`
`SatParameters.Builder`	`clearUseAreaEnergeticReasoningInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with an energetic reasoning that uses an area-based energy.
`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`	`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`	`clearUseDisjunctiveConstraintInCumulative()` 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`	`clearUseDualSchedulingHeuristics()` When set, it activates a few scheduling parameters to improve the lower bound of scheduling problems.
`SatParameters.Builder`	`clearUseDynamicPrecedenceInCumulative()` `optional bool use_dynamic_precedence_in_cumulative = 268 [default = false];`
`SatParameters.Builder`	`clearUseDynamicPrecedenceInDisjunctive()` Whether we try to branch on decision "interval A before interval B" rather than on intervals bounds.
`SatParameters.Builder`	`clearUseEnergeticReasoningInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with energetic reasoning.
`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`	`clearUseExtendedProbing()` Use extended probing (probe bool_or, at_most_one, exactly_one).
`SatParameters.Builder`	`clearUseFeasibilityJump()` Parameters for an heuristic similar to the one described in the paper: "Feasibility Jump: an LP-free Lagrangian MIP heuristic", Bjørnar Luteberget, Giorgio Sartor, 2023, Mathematical Programming Computation.
`SatParameters.Builder`	`clearUseFeasibilityPump()` Adds a feasibility pump subsolver along with lns subsolvers.
`SatParameters.Builder`	`clearUseHardPrecedencesInCumulative()` If true, detect and create constraint for integer variable that are "after" a set of intervals in the same cumulative constraint.
`SatParameters.Builder`	`clearUseImpliedBounds()` Stores and exploits "implied-bounds" in the solver.
`SatParameters.Builder`	`clearUseLbRelaxLns()` Turns on neighborhood generator based on local branching LP.
`SatParameters.Builder`	`clearUseLns()` Testing parameters used to disable all lns workers.
`SatParameters.Builder`	`clearUseLnsOnly()` Experimental parameters to disable everything but lns.
`SatParameters.Builder`	`clearUseObjectiveLbSearch()` If true, search will search in ascending max objective value (when minimizing) starting from the lower bound of the objective.
`SatParameters.Builder`	`clearUseObjectiveShavingSearch()` This search differs from the previous search as it will not use assumptions to bound the objective, and it will recreate a full model with the hardcoded objective value.
`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`	`clearUseOverloadCheckerInCumulative()` 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`	`clearUseRinsLns()` Turns on relaxation induced neighborhood generator.
`SatParameters.Builder`	`clearUseSatInprocessing()` Enable or disable "inprocessing" which is some SAT presolving done at each restart to the root level.
`SatParameters.Builder`	`clearUseSharedTreeSearch()` Set on shared subtree workers.
`SatParameters.Builder`	`clearUseShavingInProbingSearch()` Add a shaving phase (where the solver tries to prove that the lower or upper bound of a variable are infeasible) to the probing search.
`SatParameters.Builder`	`clearUseStrongPropagationInDisjunctive()` Enable stronger and more expensive propagation on no_overlap constraint.
`SatParameters.Builder`	`clearUseTimetableEdgeFindingInCumulative()` 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`	`clearUseTimetablingInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with propagators from the cumulative constraints.
`SatParameters.Builder`	`clearVariableActivityDecay()` Each time a conflict is found, the activities of some variables are increased by one.
`SatParameters.Builder`	`clearViolationLsCompoundMoveProbability()` Probability of using compound move search each restart.
`SatParameters.Builder`	`clearViolationLsPerturbationPeriod()` How long violation_ls should wait before perturbating a solution.
`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`	`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`	`getAddObjectiveCut()` When the LP objective is fractional, do we add the cut that forces the linear objective expression to be greater or equal to this fractional value rounded up? We can always do that since our objective is integer, and combined with MIR heuristic to reduce the coefficient of such cut, it can help.
`boolean`	`getAddRltCuts()` Whether we generate RLT cuts.
`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.
`int`	`getAtMostOneMaxExpansionSize()` All at_most_one constraints with a size <= param will be replaced by a quadratic number of binary implications.
`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];`
`double`	`getClauseCleanupRatio()` During a cleanup, if clause_cleanup_target is 0, we will delete the clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed target of clauses to keep.
`int`	`getClauseCleanupTarget()` During a cleanup, we will always keep that number of "deletable" clauses.
`boolean`	`getConvertIntervals()` Temporary flag util the feature is more mature.
`int`	`getCoreMinimizationLevel()` If positive, we spend some effort on each core: - At level 1, we use a simple heuristic to try to minimize an UNSAT core.
`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.
`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.
`int`	`getCutLevel()` Control the global cut effort.
`double`	`getCutMaxActiveCountValue()` These parameters are similar to sat clause management activity parameters.
`boolean`	`getDebugCrashOnBadHint()` Crash if we do not manage to complete the hint into a full solution.
`int`	`getDebugMaxNumPresolveOperations()` If positive, try to stop just after that many presolve rules have been applied.
`boolean`	`getDebugPostsolveWithFullSolver()` We have two different postsolve code.
`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`	`getDetectLinearizedProduct()` Infer products of Boolean or of Boolean time IntegerVariable from the linear constrainst in the problem.
`boolean`	`getDetectTableWithCost()` If true, we detect variable that are unique to a table constraint and only there to encode a cost on each tuple.
`boolean`	`getDisableConstraintExpansion()` If true, it disable all constraint expansion.
`boolean`	`getDiversifyLnsParams()` If true, registers more lns subsolvers with different parameters.
`boolean`	`getEncodeComplexLinearConstraintWithInteger()` Linear constraint with a complex right hand side (more than a single interval) need to be expanded, there is a couple of way to do that.
`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`	`getExpandReservoirConstraints()` If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`boolean`	`getExploitAllLpSolution()` If true and the Lp relaxation of the problem has a solution, try to exploit it.
`boolean`	`getExploitAllPrecedences()` `optional bool exploit_all_precedences = 220 [default = false];`
`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.
`java.lang.String`	`getExtraSubsolvers(int index)` A convenient way to add more workers types.
`com.google.protobuf.ByteString`	`getExtraSubsolversBytes(int index)` A convenient way to add more workers types.
`int`	`getExtraSubsolversCount()` A convenient way to add more workers types.
`com.google.protobuf.ProtocolStringList`	`getExtraSubsolversList()` A convenient way to add more workers types.
`double`	`getFeasibilityJumpDecay()` On each restart, we randomly choose if we use decay (with this parameter) or no decay.
`boolean`	`getFeasibilityJumpEnableRestarts()` When stagnating, feasibility jump will either restart from a default solution (with some possible randomization), or randomly pertubate the current solution.
`int`	`getFeasibilityJumpLinearizationLevel()` How much do we linearize the problem in the local search code.
`int`	`getFeasibilityJumpMaxExpandedConstraintSize()` Maximum size of no_overlap or no_overlap_2d constraint for a quadratic expansion.
`int`	`getFeasibilityJumpRestartFactor()` This is a factor that directly influence the work before each restart.
`double`	`getFeasibilityJumpVarPerburbationRangeRatio()` Max distance between the default value and the pertubated value relative to the range of the domain of the variable.
`double`	`getFeasibilityJumpVarRandomizationProbability()` Probability for a variable to have a non default value upon restarts or perturbations.
`boolean`	`getFillAdditionalSolutionsInResponse()` If true, the final response addition_solutions field will be filled with all solutions from our solutions pool.
`boolean`	`getFillTightenedDomainsInResponse()` If true, add information about the derived variable domains to the CpSolverResponse.
`boolean`	`getFindBigLinearOverlap()` Try to find large "rectangle" in the linear constraint matrix with identical lines.
`boolean`	`getFindMultipleCores()` Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`boolean`	`getFixVariablesToTheirHintedValue()` If true, variables appearing in the solution hints will be fixed to their hinted value.
`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.
`boolean`	`getIgnoreNames()` If true, we don't keep names in our internal copy of the user given model.
`java.lang.String`	`getIgnoreSubsolvers(int index)` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`com.google.protobuf.ByteString`	`getIgnoreSubsolversBytes(int index)` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`int`	`getIgnoreSubsolversCount()` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`com.google.protobuf.ProtocolStringList`	`getIgnoreSubsolversList()` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`boolean`	`getInferAllDiffs()` Run a max-clique code amongst all the x != y we can find and try to infer set of variables that are all different.
`SatParameters.Polarity`	`getInitialPolarity()` `optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`double`	`getInitialVariablesActivity()` The initial value of the variables activity.
`double`	`getInprocessingDtimeRatio()` Proportion of deterministic time we should spend on inprocessing.
`double`	`getInprocessingMinimizationDtime()` Parameters for an heuristic similar to the one described in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf This is the amount of dtime we should spend on this technique during each inprocessing phase.
`double`	`getInprocessingProbingDtime()` The amount of dtime we should spend on probing for each inprocessing round.
`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 = 0];`
`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.
`int`	`getLinearSplitSize()` Linear constraints that are not pseudo-Boolean and that are longer than this size will be split into sqrt(size) intermediate sums in order to have faster propation in the CP engine.
`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`	`getLogSubsolverStatistics()` Whether the solver should display per sub-solver search statistics.
`boolean`	`getLogToResponse()` Log to response proto.
`boolean`	`getLogToStdout()` Log to stdout.
`double`	`getLpDualTolerance()` `optional double lp_dual_tolerance = 267 [default = 1e-07];`
`double`	`getLpPrimalTolerance()` The internal LP tolerances used by CP-SAT.
`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`	`getMaxDomainSizeWhenEncodingEqNeqConstraints()` When loading ax + by ==/!= c when x and y are both fully encoded.
`int`	`getMaxIntegerRoundingScaling()` In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`int`	`getMaxLinMaxSizeForExpansion()` If the number of expressions in the lin_max is less that the max size parameter, model expansion replaces target = max(xi) by linear constraint with the introduction of new booleans bi such that bi => target == xi.
`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`	`getMaxNumIntervalsForTimetableEdgeFinding()` Max number of intervals for the timetable_edge_finding algorithm to propagate.
`int`	`getMaxPairsPairwiseReasoningInNoOverlap2D()` If the number of pairs to look is below this threshold, do an extra step of propagation in the no_overlap_2d constraint by looking at all pairs of intervals.
`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];`
`int`	`getMaxSizeToCreatePrecedenceLiteralsInDisjunctive()` Create one literal for each disjunction of two pairs of tasks.
`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`	`getMinimizeReductionDuringPbResolution()` A different algorithm during PB resolution.
`int`	`getMinNumLnsWorkers()` Obsolete parameter.
`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 automatically scaled.
`double`	`getMipCheckPrecision()` As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`boolean`	`getMipComputeTrueObjectiveBound()` Even if we make big error when scaling the objective, we can always derive a correct lower bound on the original objective by using the exact lower bound on the scaled integer version of the objective.
`double`	`getMipDropTolerance()` Any value in the input mip with a magnitude lower than this will be set to zero.
`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`	`getMipMaxValidMagnitude()` Any finite values in the input MIP must be below this threshold, otherwise the model will be reported invalid.
`int`	`getMipPresolveLevel()` When solving a MIP, we do some basic floating point presolving before scaling the problem to integer to be handled by CP-SAT.
`boolean`	`getMipScaleLargeDomain()` If this is false, then mip_var_scaling is only applied to variables with "small" domain.
`boolean`	`getMipTreatHighMagnitudeBoundsAsInfinity()` By default, any variable/constraint bound with a finite value and a magnitude greater than the mip_max_valid_magnitude will result with a invalid model.
`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.
`boolean`	`getNewLinearPropagation()` The new linear propagation code treat all constraints at once and use an adaptation of Bellman-Ford-Tarjan to propagate constraint in a smarter order and potentially detect propagation cycle earlier.
`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()` `optional int32 num_search_workers = 100 [default = 0];`
`int`	`getNumViolationLs()` This will create incomplete subsolvers (that are not LNS subsolvers) that use the feasibility jump code to find improving solution, treating the objective improvement as a hard constraint.
`int`	`getNumWorkers()` Specify the number of parallel workers (i.e.
`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`	`getOnlySolveIp()` If one try to solve a MIP model with CP-SAT, because we assume all variable to be integer after scaling, we will not necessarily have the correct optimal.
`boolean`	`getOptimizeWithCore()` The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`boolean`	`getOptimizeWithLbTreeSearch()` Do a more conventional tree search (by opposition to SAT based one) where we keep all the explored node in a tree.
`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".
`long`	`getPresolveInclusionWorkLimit()` A few presolve operations involve detecting constraints included in other constraint.
`double`	`getPresolveProbingDeterministicTimeLimit()` `optional double presolve_probing_deterministic_time_limit = 57 [default = 30];`
`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.
`double`	`getProbingDeterministicTimeLimit()` The maximum "deterministic" time limit to spend in probing.
`int`	`getProbingNumCombinationsLimit()` How many combinations of pairs or triplets of variables we want to scan.
`double`	`getPropagationLoopDetectionFactor()` Some search decisions might cause a really large number of propagations to happen when integer variables with large domains are only reduced by 1 at each step.
`long`	`getPseudoCostReliabilityThreshold()` The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`boolean`	`getPushAllTasksTowardStart()` Experimental code: specify if the objective pushes all tasks toward the start of the schedule.
`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.
`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.
`int`	`getRootLpIterations()` Even at the root node, we do not want to spend too much time on the LP if it is "difficult".
`SatParameters.SearchBranching`	`getSearchBranching()` `optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`long`	`getSearchRandomVariablePoolSize()` Search randomization will collect the top 'search_random_variable_pool_size' valued variables, and pick one randomly.
`boolean`	`getShareBinaryClauses()` Allows sharing of new learned binary clause between workers.
`int`	`getSharedTreeMaxNodesPerWorker()` In order to limit total shared memory and communication overhead, limit the total number of nodes that may be generated in the shared tree.
`int`	`getSharedTreeNumWorkers()` Enables experimental workstealing-like shared tree search.
`double`	`getSharedTreeOpenLeavesPerWorker()` How many open leaf nodes should the shared tree maintain per worker.
`SatParameters.SharedTreeSplitStrategy`	`getSharedTreeSplitStrategy()` `optional .operations_research.sat.SatParameters.SharedTreeSplitStrategy shared_tree_split_strategy = 239 [default = SPLIT_STRATEGY_AUTO];`
`int`	`getSharedTreeWorkerMinRestartsPerSubtree()` Minimum number of restarts before a worker will replace a subtree that looks "bad" based on the average LBD of learned clauses.
`double`	`getSharedTreeWorkerObjectiveSplitProbability()` After their assigned prefix, shared tree workers will branch on the objective with this probability.
`boolean`	`getShareLevelZeroBounds()` Allows sharing of the bounds of modified variables at level 0.
`boolean`	`getShareObjectiveBounds()` Allows objective sharing between workers.
`double`	`getShavingSearchDeterministicTime()` Specifies the amount of deterministic time spent of each try at shaving a bound in the shaving search.
`int`	`getSolutionPoolSize()` Size of the top-n different solutions kept by the solver.
`boolean`	`getStopAfterFirstSolution()` For an optimization problem, stop the solver as soon as we have a solution.
`boolean`	`getStopAfterPresolve()` Mainly used when improving the presolver.
`boolean`	`getStopAfterRootPropagation()` `optional bool stop_after_root_propagation = 252 [default = false];`
`double`	`getStrategyChangeIncreaseRatio()` The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`SatParameters`	`getSubsolverParams(int index)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`getSubsolverParamsBuilder(int index)` It is possible to specify additional subsolver configuration.
`java.util.List<SatParameters.Builder>`	`getSubsolverParamsBuilderList()` It is possible to specify additional subsolver configuration.
`int`	`getSubsolverParamsCount()` It is possible to specify additional subsolver configuration.
`java.util.List<SatParameters>`	`getSubsolverParamsList()` It is possible to specify additional subsolver configuration.
`SatParametersOrBuilder`	`getSubsolverParamsOrBuilder(int index)` It is possible to specify additional subsolver configuration.
`java.util.List<? extends SatParametersOrBuilder>`	`getSubsolverParamsOrBuilderList()` It is possible to specify additional subsolver configuration.
`java.lang.String`	`getSubsolvers(int index)` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`com.google.protobuf.ByteString`	`getSubsolversBytes(int index)` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`int`	`getSubsolversCount()` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`com.google.protobuf.ProtocolStringList`	`getSubsolversList()` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`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.
`int`	`getTableCompressionLevel()` How much we try to "compress" a table constraint.
`boolean`	`getTestFeasibilityJump()` Disable every other type of subsolver, setting this turns CP-SAT into a pure local-search solver.
`boolean`	`getUseAbslRandom()` `optional bool use_absl_random = 180 [default = false];`
`boolean`	`getUseAreaEnergeticReasoningInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with an energetic reasoning that uses an area-based energy.
`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`	`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`	`getUseDisjunctiveConstraintInCumulative()` 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`	`getUseDualSchedulingHeuristics()` When set, it activates a few scheduling parameters to improve the lower bound of scheduling problems.
`boolean`	`getUseDynamicPrecedenceInCumulative()` `optional bool use_dynamic_precedence_in_cumulative = 268 [default = false];`
`boolean`	`getUseDynamicPrecedenceInDisjunctive()` Whether we try to branch on decision "interval A before interval B" rather than on intervals bounds.
`boolean`	`getUseEnergeticReasoningInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with energetic reasoning.
`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`	`getUseExtendedProbing()` Use extended probing (probe bool_or, at_most_one, exactly_one).
`boolean`	`getUseFeasibilityJump()` Parameters for an heuristic similar to the one described in the paper: "Feasibility Jump: an LP-free Lagrangian MIP heuristic", Bjørnar Luteberget, Giorgio Sartor, 2023, Mathematical Programming Computation.
`boolean`	`getUseFeasibilityPump()` Adds a feasibility pump subsolver along with lns subsolvers.
`boolean`	`getUseHardPrecedencesInCumulative()` If true, detect and create constraint for integer variable that are "after" a set of intervals in the same cumulative constraint.
`boolean`	`getUseImpliedBounds()` Stores and exploits "implied-bounds" in the solver.
`boolean`	`getUseLbRelaxLns()` Turns on neighborhood generator based on local branching LP.
`boolean`	`getUseLns()` Testing parameters used to disable all lns workers.
`boolean`	`getUseLnsOnly()` Experimental parameters to disable everything but lns.
`boolean`	`getUseObjectiveLbSearch()` If true, search will search in ascending max objective value (when minimizing) starting from the lower bound of the objective.
`boolean`	`getUseObjectiveShavingSearch()` This search differs from the previous search as it will not use assumptions to bound the objective, and it will recreate a full model with the hardcoded objective value.
`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`	`getUseOverloadCheckerInCumulative()` 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`	`getUseRinsLns()` Turns on relaxation induced neighborhood generator.
`boolean`	`getUseSatInprocessing()` Enable or disable "inprocessing" which is some SAT presolving done at each restart to the root level.
`boolean`	`getUseSharedTreeSearch()` Set on shared subtree workers.
`boolean`	`getUseShavingInProbingSearch()` Add a shaving phase (where the solver tries to prove that the lower or upper bound of a variable are infeasible) to the probing search.
`boolean`	`getUseStrongPropagationInDisjunctive()` Enable stronger and more expensive propagation on no_overlap constraint.
`boolean`	`getUseTimetableEdgeFindingInCumulative()` 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`	`getUseTimetablingInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with propagators from the cumulative constraints.
`double`	`getVariableActivityDecay()` Each time a conflict is found, the activities of some variables are increased by one.
`double`	`getViolationLsCompoundMoveProbability()` Probability of using compound move search each restart.
`int`	`getViolationLsPerturbationPeriod()` How long violation_ls should wait before perturbating a solution.
`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`	`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`	`hasAddObjectiveCut()` When the LP objective is fractional, do we add the cut that forces the linear objective expression to be greater or equal to this fractional value rounded up? We can always do that since our objective is integer, and combined with MIR heuristic to reduce the coefficient of such cut, it can help.
`boolean`	`hasAddRltCuts()` Whether we generate RLT cuts.
`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`	`hasAtMostOneMaxExpansionSize()` All at_most_one constraints with a size <= param will be replaced by a quadratic number of binary implications.
`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`	`hasClauseCleanupRatio()` During a cleanup, if clause_cleanup_target is 0, we will delete the clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed target of clauses to keep.
`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`	`hasCoreMinimizationLevel()` If positive, we spend some effort on each core: - At level 1, we use a simple heuristic to try to minimize an UNSAT core.
`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`	`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`	`hasCutLevel()` Control the global cut effort.
`boolean`	`hasCutMaxActiveCountValue()` These parameters are similar to sat clause management activity parameters.
`boolean`	`hasDebugCrashOnBadHint()` Crash if we do not manage to complete the hint into a full solution.
`boolean`	`hasDebugMaxNumPresolveOperations()` If positive, try to stop just after that many presolve rules have been applied.
`boolean`	`hasDebugPostsolveWithFullSolver()` We have two different postsolve code.
`boolean`	`hasDefaultRestartAlgorithms()` `optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`boolean`	`hasDetectLinearizedProduct()` Infer products of Boolean or of Boolean time IntegerVariable from the linear constrainst in the problem.
`boolean`	`hasDetectTableWithCost()` If true, we detect variable that are unique to a table constraint and only there to encode a cost on each tuple.
`boolean`	`hasDisableConstraintExpansion()` If true, it disable all constraint expansion.
`boolean`	`hasDiversifyLnsParams()` If true, registers more lns subsolvers with different parameters.
`boolean`	`hasEncodeComplexLinearConstraintWithInteger()` Linear constraint with a complex right hand side (more than a single interval) need to be expanded, there is a couple of way to do that.
`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`	`hasExpandReservoirConstraints()` If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`boolean`	`hasExploitAllLpSolution()` If true and the Lp relaxation of the problem has a solution, try to exploit it.
`boolean`	`hasExploitAllPrecedences()` `optional bool exploit_all_precedences = 220 [default = false];`
`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`	`hasFeasibilityJumpDecay()` On each restart, we randomly choose if we use decay (with this parameter) or no decay.
`boolean`	`hasFeasibilityJumpEnableRestarts()` When stagnating, feasibility jump will either restart from a default solution (with some possible randomization), or randomly pertubate the current solution.
`boolean`	`hasFeasibilityJumpLinearizationLevel()` How much do we linearize the problem in the local search code.
`boolean`	`hasFeasibilityJumpMaxExpandedConstraintSize()` Maximum size of no_overlap or no_overlap_2d constraint for a quadratic expansion.
`boolean`	`hasFeasibilityJumpRestartFactor()` This is a factor that directly influence the work before each restart.
`boolean`	`hasFeasibilityJumpVarPerburbationRangeRatio()` Max distance between the default value and the pertubated value relative to the range of the domain of the variable.
`boolean`	`hasFeasibilityJumpVarRandomizationProbability()` Probability for a variable to have a non default value upon restarts or perturbations.
`boolean`	`hasFillAdditionalSolutionsInResponse()` If true, the final response addition_solutions field will be filled with all solutions from our solutions pool.
`boolean`	`hasFillTightenedDomainsInResponse()` If true, add information about the derived variable domains to the CpSolverResponse.
`boolean`	`hasFindBigLinearOverlap()` Try to find large "rectangle" in the linear constraint matrix with identical lines.
`boolean`	`hasFindMultipleCores()` Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`boolean`	`hasFixVariablesToTheirHintedValue()` If true, variables appearing in the solution hints will be fixed to their hinted value.
`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`	`hasIgnoreNames()` If true, we don't keep names in our internal copy of the user given model.
`boolean`	`hasInferAllDiffs()` Run a max-clique code amongst all the x != y we can find and try to infer set of variables that are all different.
`boolean`	`hasInitialPolarity()` `optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`boolean`	`hasInitialVariablesActivity()` The initial value of the variables activity.
`boolean`	`hasInprocessingDtimeRatio()` Proportion of deterministic time we should spend on inprocessing.
`boolean`	`hasInprocessingMinimizationDtime()` Parameters for an heuristic similar to the one described in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf This is the amount of dtime we should spend on this technique during each inprocessing phase.
`boolean`	`hasInprocessingProbingDtime()` The amount of dtime we should spend on probing for each inprocessing round.
`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 = 0];`
`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`	`hasLinearSplitSize()` Linear constraints that are not pseudo-Boolean and that are longer than this size will be split into sqrt(size) intermediate sums in order to have faster propation in the CP engine.
`boolean`	`hasLogPrefix()` Add a prefix to all logs.
`boolean`	`hasLogSearchProgress()` Whether the solver should log the search progress.
`boolean`	`hasLogSubsolverStatistics()` Whether the solver should display per sub-solver search statistics.
`boolean`	`hasLogToResponse()` Log to response proto.
`boolean`	`hasLogToStdout()` Log to stdout.
`boolean`	`hasLpDualTolerance()` `optional double lp_dual_tolerance = 267 [default = 1e-07];`
`boolean`	`hasLpPrimalTolerance()` The internal LP tolerances used by CP-SAT.
`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`	`hasMaxDomainSizeWhenEncodingEqNeqConstraints()` When loading ax + by ==/!= c when x and y are both fully encoded.
`boolean`	`hasMaxIntegerRoundingScaling()` In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`boolean`	`hasMaxLinMaxSizeForExpansion()` If the number of expressions in the lin_max is less that the max size parameter, model expansion replaces target = max(xi) by linear constraint with the introduction of new booleans bi such that bi => target == xi.
`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`	`hasMaxNumIntervalsForTimetableEdgeFinding()` Max number of intervals for the timetable_edge_finding algorithm to propagate.
`boolean`	`hasMaxPairsPairwiseReasoningInNoOverlap2D()` If the number of pairs to look is below this threshold, do an extra step of propagation in the no_overlap_2d constraint by looking at all pairs of intervals.
`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`	`hasMaxSizeToCreatePrecedenceLiteralsInDisjunctive()` Create one literal for each disjunction of two pairs of tasks.
`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`	`hasMinimizeReductionDuringPbResolution()` A different algorithm during PB resolution.
`boolean`	`hasMinNumLnsWorkers()` Obsolete parameter.
`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 automatically scaled.
`boolean`	`hasMipCheckPrecision()` As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`boolean`	`hasMipComputeTrueObjectiveBound()` Even if we make big error when scaling the objective, we can always derive a correct lower bound on the original objective by using the exact lower bound on the scaled integer version of the objective.
`boolean`	`hasMipDropTolerance()` Any value in the input mip with a magnitude lower than this will be set to zero.
`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`	`hasMipMaxValidMagnitude()` Any finite values in the input MIP must be below this threshold, otherwise the model will be reported invalid.
`boolean`	`hasMipPresolveLevel()` When solving a MIP, we do some basic floating point presolving before scaling the problem to integer to be handled by CP-SAT.
`boolean`	`hasMipScaleLargeDomain()` If this is false, then mip_var_scaling is only applied to variables with "small" domain.
`boolean`	`hasMipTreatHighMagnitudeBoundsAsInfinity()` By default, any variable/constraint bound with a finite value and a magnitude greater than the mip_max_valid_magnitude will result with a invalid model.
`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`	`hasNewLinearPropagation()` The new linear propagation code treat all constraints at once and use an adaptation of Bellman-Ford-Tarjan to propagate constraint in a smarter order and potentially detect propagation cycle earlier.
`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()` `optional int32 num_search_workers = 100 [default = 0];`
`boolean`	`hasNumViolationLs()` This will create incomplete subsolvers (that are not LNS subsolvers) that use the feasibility jump code to find improving solution, treating the objective improvement as a hard constraint.
`boolean`	`hasNumWorkers()` Specify the number of parallel workers (i.e.
`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`	`hasOnlySolveIp()` If one try to solve a MIP model with CP-SAT, because we assume all variable to be integer after scaling, we will not necessarily have the correct optimal.
`boolean`	`hasOptimizeWithCore()` The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`boolean`	`hasOptimizeWithLbTreeSearch()` Do a more conventional tree search (by opposition to SAT based one) where we keep all the explored node in a tree.
`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`	`hasPresolveInclusionWorkLimit()` A few presolve operations involve detecting constraints included in other constraint.
`boolean`	`hasPresolveProbingDeterministicTimeLimit()` `optional double presolve_probing_deterministic_time_limit = 57 [default = 30];`
`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`	`hasProbingDeterministicTimeLimit()` The maximum "deterministic" time limit to spend in probing.
`boolean`	`hasProbingNumCombinationsLimit()` How many combinations of pairs or triplets of variables we want to scan.
`boolean`	`hasPropagationLoopDetectionFactor()` Some search decisions might cause a really large number of propagations to happen when integer variables with large domains are only reduced by 1 at each step.
`boolean`	`hasPseudoCostReliabilityThreshold()` The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`boolean`	`hasPushAllTasksTowardStart()` Experimental code: specify if the objective pushes all tasks toward the start of the schedule.
`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`	`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`	`hasRootLpIterations()` Even at the root node, we do not want to spend too much time on the LP if it is "difficult".
`boolean`	`hasSearchBranching()` `optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`boolean`	`hasSearchRandomVariablePoolSize()` Search randomization will collect the top 'search_random_variable_pool_size' valued variables, and pick one randomly.
`boolean`	`hasShareBinaryClauses()` Allows sharing of new learned binary clause between workers.
`boolean`	`hasSharedTreeMaxNodesPerWorker()` In order to limit total shared memory and communication overhead, limit the total number of nodes that may be generated in the shared tree.
`boolean`	`hasSharedTreeNumWorkers()` Enables experimental workstealing-like shared tree search.
`boolean`	`hasSharedTreeOpenLeavesPerWorker()` How many open leaf nodes should the shared tree maintain per worker.
`boolean`	`hasSharedTreeSplitStrategy()` `optional .operations_research.sat.SatParameters.SharedTreeSplitStrategy shared_tree_split_strategy = 239 [default = SPLIT_STRATEGY_AUTO];`
`boolean`	`hasSharedTreeWorkerMinRestartsPerSubtree()` Minimum number of restarts before a worker will replace a subtree that looks "bad" based on the average LBD of learned clauses.
`boolean`	`hasSharedTreeWorkerObjectiveSplitProbability()` After their assigned prefix, shared tree workers will branch on the objective with this probability.
`boolean`	`hasShareLevelZeroBounds()` Allows sharing of the bounds of modified variables at level 0.
`boolean`	`hasShareObjectiveBounds()` Allows objective sharing between workers.
`boolean`	`hasShavingSearchDeterministicTime()` Specifies the amount of deterministic time spent of each try at shaving a bound in the shaving search.
`boolean`	`hasSolutionPoolSize()` Size of the top-n different solutions kept by the solver.
`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`	`hasStopAfterRootPropagation()` `optional bool stop_after_root_propagation = 252 [default = false];`
`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`	`hasTableCompressionLevel()` How much we try to "compress" a table constraint.
`boolean`	`hasTestFeasibilityJump()` Disable every other type of subsolver, setting this turns CP-SAT into a pure local-search solver.
`boolean`	`hasUseAbslRandom()` `optional bool use_absl_random = 180 [default = false];`
`boolean`	`hasUseAreaEnergeticReasoningInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with an energetic reasoning that uses an area-based energy.
`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`	`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`	`hasUseDisjunctiveConstraintInCumulative()` 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`	`hasUseDualSchedulingHeuristics()` When set, it activates a few scheduling parameters to improve the lower bound of scheduling problems.
`boolean`	`hasUseDynamicPrecedenceInCumulative()` `optional bool use_dynamic_precedence_in_cumulative = 268 [default = false];`
`boolean`	`hasUseDynamicPrecedenceInDisjunctive()` Whether we try to branch on decision "interval A before interval B" rather than on intervals bounds.
`boolean`	`hasUseEnergeticReasoningInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with energetic reasoning.
`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`	`hasUseExtendedProbing()` Use extended probing (probe bool_or, at_most_one, exactly_one).
`boolean`	`hasUseFeasibilityJump()` Parameters for an heuristic similar to the one described in the paper: "Feasibility Jump: an LP-free Lagrangian MIP heuristic", Bjørnar Luteberget, Giorgio Sartor, 2023, Mathematical Programming Computation.
`boolean`	`hasUseFeasibilityPump()` Adds a feasibility pump subsolver along with lns subsolvers.
`boolean`	`hasUseHardPrecedencesInCumulative()` If true, detect and create constraint for integer variable that are "after" a set of intervals in the same cumulative constraint.
`boolean`	`hasUseImpliedBounds()` Stores and exploits "implied-bounds" in the solver.
`boolean`	`hasUseLbRelaxLns()` Turns on neighborhood generator based on local branching LP.
`boolean`	`hasUseLns()` Testing parameters used to disable all lns workers.
`boolean`	`hasUseLnsOnly()` Experimental parameters to disable everything but lns.
`boolean`	`hasUseObjectiveLbSearch()` If true, search will search in ascending max objective value (when minimizing) starting from the lower bound of the objective.
`boolean`	`hasUseObjectiveShavingSearch()` This search differs from the previous search as it will not use assumptions to bound the objective, and it will recreate a full model with the hardcoded objective value.
`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`	`hasUseOverloadCheckerInCumulative()` 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`	`hasUseRinsLns()` Turns on relaxation induced neighborhood generator.
`boolean`	`hasUseSatInprocessing()` Enable or disable "inprocessing" which is some SAT presolving done at each restart to the root level.
`boolean`	`hasUseSharedTreeSearch()` Set on shared subtree workers.
`boolean`	`hasUseShavingInProbingSearch()` Add a shaving phase (where the solver tries to prove that the lower or upper bound of a variable are infeasible) to the probing search.
`boolean`	`hasUseStrongPropagationInDisjunctive()` Enable stronger and more expensive propagation on no_overlap constraint.
`boolean`	`hasUseTimetableEdgeFindingInCumulative()` 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`	`hasUseTimetablingInNoOverlap2D()` When this is true, the no_overlap_2d constraint is reinforced with propagators from the cumulative constraints.
`boolean`	`hasVariableActivityDecay()` Each time a conflict is found, the activities of some variables are increased by one.
`boolean`	`hasViolationLsCompoundMoveProbability()` Probability of using compound move search each restart.
`boolean`	`hasViolationLsPerturbationPeriod()` How long violation_ls should wait before perturbating a solution.
`protected com.google.protobuf.GeneratedMessage.FieldAccessorTable`	`internalGetFieldAccessorTable()`
`boolean`	`isInitialized()`
`SatParameters.Builder`	`mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`SatParameters.Builder`	`mergeFrom(com.google.protobuf.Message other)`
`SatParameters.Builder`	`mergeFrom(SatParameters other)`
`SatParameters.Builder`	`removeSubsolverParams(int index)` It is possible to specify additional subsolver configuration.
`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`	`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`	`setAddObjectiveCut(boolean value)` When the LP objective is fractional, do we add the cut that forces the linear objective expression to be greater or equal to this fractional value rounded up? We can always do that since our objective is integer, and combined with MIR heuristic to reduce the coefficient of such cut, it can help.
`SatParameters.Builder`	`setAddRltCuts(boolean value)` Whether we generate RLT cuts.
`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`	`setAtMostOneMaxExpansionSize(int value)` All at_most_one constraints with a size <= param will be replaced by a quadratic number of binary implications.
`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`	`setClauseCleanupRatio(double value)` During a cleanup, if clause_cleanup_target is 0, we will delete the clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed target of clauses to keep.
`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`	`setCoreMinimizationLevel(int value)` If positive, we spend some effort on each core: - At level 1, we use a simple heuristic to try to minimize an UNSAT core.
`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`	`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`	`setCutLevel(int value)` Control the global cut effort.
`SatParameters.Builder`	`setCutMaxActiveCountValue(double value)` These parameters are similar to sat clause management activity parameters.
`SatParameters.Builder`	`setDebugCrashOnBadHint(boolean value)` Crash if we do not manage to complete the hint into a full solution.
`SatParameters.Builder`	`setDebugMaxNumPresolveOperations(int value)` If positive, try to stop just after that many presolve rules have been applied.
`SatParameters.Builder`	`setDebugPostsolveWithFullSolver(boolean value)` We have two different postsolve code.
`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`	`setDetectLinearizedProduct(boolean value)` Infer products of Boolean or of Boolean time IntegerVariable from the linear constrainst in the problem.
`SatParameters.Builder`	`setDetectTableWithCost(boolean value)` If true, we detect variable that are unique to a table constraint and only there to encode a cost on each tuple.
`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`	`setEncodeComplexLinearConstraintWithInteger(boolean value)` Linear constraint with a complex right hand side (more than a single interval) need to be expanded, there is a couple of way to do that.
`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`	`setExpandReservoirConstraints(boolean value)` If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`SatParameters.Builder`	`setExploitAllLpSolution(boolean value)` If true and the Lp relaxation of the problem has a solution, try to exploit it.
`SatParameters.Builder`	`setExploitAllPrecedences(boolean value)` `optional bool exploit_all_precedences = 220 [default = false];`
`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`	`setExtraSubsolvers(int index, java.lang.String value)` A convenient way to add more workers types.
`SatParameters.Builder`	`setFeasibilityJumpDecay(double value)` On each restart, we randomly choose if we use decay (with this parameter) or no decay.
`SatParameters.Builder`	`setFeasibilityJumpEnableRestarts(boolean value)` When stagnating, feasibility jump will either restart from a default solution (with some possible randomization), or randomly pertubate the current solution.
`SatParameters.Builder`	`setFeasibilityJumpLinearizationLevel(int value)` How much do we linearize the problem in the local search code.
`SatParameters.Builder`	`setFeasibilityJumpMaxExpandedConstraintSize(int value)` Maximum size of no_overlap or no_overlap_2d constraint for a quadratic expansion.
`SatParameters.Builder`	`setFeasibilityJumpRestartFactor(int value)` This is a factor that directly influence the work before each restart.
`SatParameters.Builder`	`setFeasibilityJumpVarPerburbationRangeRatio(double value)` Max distance between the default value and the pertubated value relative to the range of the domain of the variable.
`SatParameters.Builder`	`setFeasibilityJumpVarRandomizationProbability(double value)` Probability for a variable to have a non default value upon restarts or perturbations.
`SatParameters.Builder`	`setFillAdditionalSolutionsInResponse(boolean value)` If true, the final response addition_solutions field will be filled with all solutions from our solutions pool.
`SatParameters.Builder`	`setFillTightenedDomainsInResponse(boolean value)` If true, add information about the derived variable domains to the CpSolverResponse.
`SatParameters.Builder`	`setFindBigLinearOverlap(boolean value)` Try to find large "rectangle" in the linear constraint matrix with identical lines.
`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`	`setFixVariablesToTheirHintedValue(boolean value)` If true, variables appearing in the solution hints will be fixed to their hinted value.
`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`	`setIgnoreNames(boolean value)` If true, we don't keep names in our internal copy of the user given model.
`SatParameters.Builder`	`setIgnoreSubsolvers(int index, java.lang.String value)` Rather than fully specifying subsolvers, it is often convenient to just remove the ones that are not useful on a given problem.
`SatParameters.Builder`	`setInferAllDiffs(boolean value)` Run a max-clique code amongst all the x != y we can find and try to infer set of variables that are all different.
`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`	`setInprocessingDtimeRatio(double value)` Proportion of deterministic time we should spend on inprocessing.
`SatParameters.Builder`	`setInprocessingMinimizationDtime(double value)` Parameters for an heuristic similar to the one described in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf This is the amount of dtime we should spend on this technique during each inprocessing phase.
`SatParameters.Builder`	`setInprocessingProbingDtime(double value)` The amount of dtime we should spend on probing for each inprocessing round.
`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 = 0];`
`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`	`setLinearSplitSize(int value)` Linear constraints that are not pseudo-Boolean and that are longer than this size will be split into sqrt(size) intermediate sums in order to have faster propation in the CP engine.
`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`	`setLogSubsolverStatistics(boolean value)` Whether the solver should display per sub-solver search statistics.
`SatParameters.Builder`	`setLogToResponse(boolean value)` Log to response proto.
`SatParameters.Builder`	`setLogToStdout(boolean value)` Log to stdout.
`SatParameters.Builder`	`setLpDualTolerance(double value)` `optional double lp_dual_tolerance = 267 [default = 1e-07];`
`SatParameters.Builder`	`setLpPrimalTolerance(double value)` The internal LP tolerances used by CP-SAT.
`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`	`setMaxDomainSizeWhenEncodingEqNeqConstraints(int value)` When loading ax + by ==/!= c when x and y are both fully encoded.
`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`	`setMaxLinMaxSizeForExpansion(int value)` If the number of expressions in the lin_max is less that the max size parameter, model expansion replaces target = max(xi) by linear constraint with the introduction of new booleans bi such that bi => target == xi.
`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`	`setMaxNumIntervalsForTimetableEdgeFinding(int value)` Max number of intervals for the timetable_edge_finding algorithm to propagate.
`SatParameters.Builder`	`setMaxPairsPairwiseReasoningInNoOverlap2D(int value)` If the number of pairs to look is below this threshold, do an extra step of propagation in the no_overlap_2d constraint by looking at all pairs of intervals.
`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`	`setMaxSizeToCreatePrecedenceLiteralsInDisjunctive(int value)` Create one literal for each disjunction of two pairs of tasks.
`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`	`setMinimizeReductionDuringPbResolution(boolean value)` A different algorithm during PB resolution.
`SatParameters.Builder`	`setMinNumLnsWorkers(int value)` Obsolete parameter.
`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 automatically 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`	`setMipComputeTrueObjectiveBound(boolean value)` Even if we make big error when scaling the objective, we can always derive a correct lower bound on the original objective by using the exact lower bound on the scaled integer version of the objective.
`SatParameters.Builder`	`setMipDropTolerance(double value)` Any value in the input mip with a magnitude lower than this will be set to zero.
`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`	`setMipMaxValidMagnitude(double value)` Any finite values in the input MIP must be below this threshold, otherwise the model will be reported invalid.
`SatParameters.Builder`	`setMipPresolveLevel(int value)` When solving a MIP, we do some basic floating point presolving before scaling the problem to integer to be handled by CP-SAT.
`SatParameters.Builder`	`setMipScaleLargeDomain(boolean value)` If this is false, then mip_var_scaling is only applied to variables with "small" domain.
`SatParameters.Builder`	`setMipTreatHighMagnitudeBoundsAsInfinity(boolean value)` By default, any variable/constraint bound with a finite value and a magnitude greater than the mip_max_valid_magnitude will result with a invalid model.
`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`	`setNewLinearPropagation(boolean value)` The new linear propagation code treat all constraints at once and use an adaptation of Bellman-Ford-Tarjan to propagate constraint in a smarter order and potentially detect propagation cycle earlier.
`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)` `optional int32 num_search_workers = 100 [default = 0];`
`SatParameters.Builder`	`setNumViolationLs(int value)` This will create incomplete subsolvers (that are not LNS subsolvers) that use the feasibility jump code to find improving solution, treating the objective improvement as a hard constraint.
`SatParameters.Builder`	`setNumWorkers(int value)` Specify the number of parallel workers (i.e.
`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`	`setOnlySolveIp(boolean value)` If one try to solve a MIP model with CP-SAT, because we assume all variable to be integer after scaling, we will not necessarily have the correct optimal.
`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`	`setOptimizeWithLbTreeSearch(boolean value)` Do a more conventional tree search (by opposition to SAT based one) where we keep all the explored node in a tree.
`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`	`setPresolveInclusionWorkLimit(long value)` A few presolve operations involve detecting constraints included in other constraint.
`SatParameters.Builder`	`setPresolveProbingDeterministicTimeLimit(double value)` `optional double presolve_probing_deterministic_time_limit = 57 [default = 30];`
`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`	`setProbingDeterministicTimeLimit(double value)` The maximum "deterministic" time limit to spend in probing.
`SatParameters.Builder`	`setProbingNumCombinationsLimit(int value)` How many combinations of pairs or triplets of variables we want to scan.
`SatParameters.Builder`	`setPropagationLoopDetectionFactor(double value)` Some search decisions might cause a really large number of propagations to happen when integer variables with large domains are only reduced by 1 at each step.
`SatParameters.Builder`	`setPseudoCostReliabilityThreshold(long value)` The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`SatParameters.Builder`	`setPushAllTasksTowardStart(boolean value)` Experimental code: specify if the objective pushes all tasks toward the start of the schedule.
`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`	`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`	`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`	`setRootLpIterations(int value)` Even at the root node, we do not want to spend too much time on the LP if it is "difficult".
`SatParameters.Builder`	`setSearchBranching(SatParameters.SearchBranching value)` `optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`SatParameters.Builder`	`setSearchRandomVariablePoolSize(long value)` Search randomization will collect the top 'search_random_variable_pool_size' valued variables, and pick one randomly.
`SatParameters.Builder`	`setShareBinaryClauses(boolean value)` Allows sharing of new learned binary clause between workers.
`SatParameters.Builder`	`setSharedTreeMaxNodesPerWorker(int value)` In order to limit total shared memory and communication overhead, limit the total number of nodes that may be generated in the shared tree.
`SatParameters.Builder`	`setSharedTreeNumWorkers(int value)` Enables experimental workstealing-like shared tree search.
`SatParameters.Builder`	`setSharedTreeOpenLeavesPerWorker(double value)` How many open leaf nodes should the shared tree maintain per worker.
`SatParameters.Builder`	`setSharedTreeSplitStrategy(SatParameters.SharedTreeSplitStrategy value)` `optional .operations_research.sat.SatParameters.SharedTreeSplitStrategy shared_tree_split_strategy = 239 [default = SPLIT_STRATEGY_AUTO];`
`SatParameters.Builder`	`setSharedTreeWorkerMinRestartsPerSubtree(int value)` Minimum number of restarts before a worker will replace a subtree that looks "bad" based on the average LBD of learned clauses.
`SatParameters.Builder`	`setSharedTreeWorkerObjectiveSplitProbability(double value)` After their assigned prefix, shared tree workers will branch on the objective with this probability.
`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`	`setShavingSearchDeterministicTime(double value)` Specifies the amount of deterministic time spent of each try at shaving a bound in the shaving search.
`SatParameters.Builder`	`setSolutionPoolSize(int value)` Size of the top-n different solutions kept by the solver.
`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`	`setStopAfterRootPropagation(boolean value)` `optional bool stop_after_root_propagation = 252 [default = false];`
`SatParameters.Builder`	`setStrategyChangeIncreaseRatio(double value)` The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`SatParameters.Builder`	`setSubsolverParams(int index, SatParameters.Builder builderForValue)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`setSubsolverParams(int index, SatParameters value)` It is possible to specify additional subsolver configuration.
`SatParameters.Builder`	`setSubsolvers(int index, java.lang.String value)` In multi-thread, the solver can be mainly seen as a portfolio of solvers with different parameters.
`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`	`setTableCompressionLevel(int value)` How much we try to "compress" a table constraint.
`SatParameters.Builder`	`setTestFeasibilityJump(boolean value)` Disable every other type of subsolver, setting this turns CP-SAT into a pure local-search solver.
`SatParameters.Builder`	`setUseAbslRandom(boolean value)` `optional bool use_absl_random = 180 [default = false];`
`SatParameters.Builder`	`setUseAreaEnergeticReasoningInNoOverlap2D(boolean value)` When this is true, the no_overlap_2d constraint is reinforced with an energetic reasoning that uses an area-based energy.
`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`	`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`	`setUseDisjunctiveConstraintInCumulative(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`	`setUseDualSchedulingHeuristics(boolean value)` When set, it activates a few scheduling parameters to improve the lower bound of scheduling problems.
`SatParameters.Builder`	`setUseDynamicPrecedenceInCumulative(boolean value)` `optional bool use_dynamic_precedence_in_cumulative = 268 [default = false];`
`SatParameters.Builder`	`setUseDynamicPrecedenceInDisjunctive(boolean value)` Whether we try to branch on decision "interval A before interval B" rather than on intervals bounds.
`SatParameters.Builder`	`setUseEnergeticReasoningInNoOverlap2D(boolean value)` When this is true, the no_overlap_2d constraint is reinforced with energetic reasoning.
`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`	`setUseExtendedProbing(boolean value)` Use extended probing (probe bool_or, at_most_one, exactly_one).
`SatParameters.Builder`	`setUseFeasibilityJump(boolean value)` Parameters for an heuristic similar to the one described in the paper: "Feasibility Jump: an LP-free Lagrangian MIP heuristic", Bjørnar Luteberget, Giorgio Sartor, 2023, Mathematical Programming Computation.
`SatParameters.Builder`	`setUseFeasibilityPump(boolean value)` Adds a feasibility pump subsolver along with lns subsolvers.
`SatParameters.Builder`	`setUseHardPrecedencesInCumulative(boolean value)` If true, detect and create constraint for integer variable that are "after" a set of intervals in the same cumulative constraint.
`SatParameters.Builder`	`setUseImpliedBounds(boolean value)` Stores and exploits "implied-bounds" in the solver.
`SatParameters.Builder`	`setUseLbRelaxLns(boolean value)` Turns on neighborhood generator based on local branching LP.
`SatParameters.Builder`	`setUseLns(boolean value)` Testing parameters used to disable all lns workers.
`SatParameters.Builder`	`setUseLnsOnly(boolean value)` Experimental parameters to disable everything but lns.
`SatParameters.Builder`	`setUseObjectiveLbSearch(boolean value)` If true, search will search in ascending max objective value (when minimizing) starting from the lower bound of the objective.
`SatParameters.Builder`	`setUseObjectiveShavingSearch(boolean value)` This search differs from the previous search as it will not use assumptions to bound the objective, and it will recreate a full model with the hardcoded objective value.
`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`	`setUseOverloadCheckerInCumulative(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`	`setUseRinsLns(boolean value)` Turns on relaxation induced neighborhood generator.
`SatParameters.Builder`	`setUseSatInprocessing(boolean value)` Enable or disable "inprocessing" which is some SAT presolving done at each restart to the root level.
`SatParameters.Builder`	`setUseSharedTreeSearch(boolean value)` Set on shared subtree workers.
`SatParameters.Builder`	`setUseShavingInProbingSearch(boolean value)` Add a shaving phase (where the solver tries to prove that the lower or upper bound of a variable are infeasible) to the probing search.
`SatParameters.Builder`	`setUseStrongPropagationInDisjunctive(boolean value)` Enable stronger and more expensive propagation on no_overlap constraint.
`SatParameters.Builder`	`setUseTimetableEdgeFindingInCumulative(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`	`setUseTimetablingInNoOverlap2D(boolean value)` When this is true, the no_overlap_2d constraint is reinforced with propagators from the cumulative constraints.
`SatParameters.Builder`	`setVariableActivityDecay(double value)` Each time a conflict is found, the activities of some variables are increased by one.
`SatParameters.Builder`	`setViolationLsCompoundMoveProbability(double value)` Probability of using compound move search each restart.
`SatParameters.Builder`	`setViolationLsPerturbationPeriod(int value)` How long violation_ls should wait before perturbating a solution.

Methods inherited from class com.google.protobuf.GeneratedMessage.Builder
addRepeatedField, clearField, clearOneof, clone, getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, getUnknownFieldSetBuilder, hasField, hasOneof, internalGetMapField, internalGetMapFieldReflection, internalGetMutableMapField, internalGetMutableMapFieldReflection, isClean, markClean, mergeUnknownFields, mergeUnknownLengthDelimitedField, mergeUnknownVarintField, newBuilderForField, onBuilt, onChanged, parseUnknownField, setField, setRepeatedField, setUnknownFields, setUnknownFieldSetBuilder, setUnknownFieldsProto3

Methods inherited from class com.google.protobuf.AbstractMessage.Builder
findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString

Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder
addAll, addAll, mergeDelimitedFrom, mergeDelimitedFrom, newUninitializedMessageException

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.google.protobuf.MessageOrBuilder
findInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

Methods inherited from interface com.google.protobuf.Message.Builder
mergeDelimitedFrom, mergeDelimitedFrom

Method Detail

getDescriptor

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

internalGetFieldAccessorTable
```
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
```
Specified by:

internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage.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.GeneratedMessage.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.GeneratedMessage.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

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.GeneratedMessage.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 = 0];
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 = 0];
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 = 0];

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 = 0];

Returns:: This builder for chaining.

hasClauseCleanupRatio

public boolean hasClauseCleanupRatio()

 During a cleanup, if clause_cleanup_target is 0, we will delete the
 clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed
 target of clauses to keep.

optional double clause_cleanup_ratio = 190 [default = 0.5];

Specified by:: hasClauseCleanupRatio in interface SatParametersOrBuilder
Returns:: Whether the clauseCleanupRatio field is set.

getClauseCleanupRatio

public double getClauseCleanupRatio()

 During a cleanup, if clause_cleanup_target is 0, we will delete the
 clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed
 target of clauses to keep.

optional double clause_cleanup_ratio = 190 [default = 0.5];

Specified by:: getClauseCleanupRatio in interface SatParametersOrBuilder
Returns:: The clauseCleanupRatio.

setClauseCleanupRatio

public SatParameters.Builder setClauseCleanupRatio(double value)

 During a cleanup, if clause_cleanup_target is 0, we will delete the
 clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed
 target of clauses to keep.

optional double clause_cleanup_ratio = 190 [default = 0.5];

Parameters:: value - The clauseCleanupRatio to set.
Returns:: This builder for chaining.

clearClauseCleanupRatio

public SatParameters.Builder clearClauseCleanupRatio()

 During a cleanup, if clause_cleanup_target is 0, we will delete the
 clause_cleanup_ratio of "deletable" clauses instead of aiming for a fixed
 target of clauses to keep.

optional double clause_cleanup_ratio = 190 [default = 0.5];

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.

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): 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): 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): 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): 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.

 TODO(user): This is only used by the pure SAT solver, generalize to CP-SAT.

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.

 TODO(user): This is only used by the pure SAT solver, generalize to CP-SAT.

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.

 TODO(user): This is only used by the pure SAT solver, generalize to CP-SAT.

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.

 TODO(user): This is only used by the pure SAT solver, generalize to CP-SAT.

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.

 If the objective is integer, then any absolute gap < 1 will lead to a true
 optimal. If the objective is floating point, a gap of zero make little
 sense so is is why we use a non-zero default value. At the end of the
 search, we will display a warning if OPTIMAL is reported yet the gap is
 greater than this absolute gap.

optional double absolute_gap_limit = 159 [default = 0.0001];

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.

 If the objective is integer, then any absolute gap < 1 will lead to a true
 optimal. If the objective is floating point, a gap of zero make little
 sense so is is why we use a non-zero default value. At the end of the
 search, we will display a warning if OPTIMAL is reported yet the gap is
 greater than this absolute gap.

optional double absolute_gap_limit = 159 [default = 0.0001];

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.

 If the objective is integer, then any absolute gap < 1 will lead to a true
 optimal. If the objective is floating point, a gap of zero make little
 sense so is is why we use a non-zero default value. At the end of the
 search, we will display a warning if OPTIMAL is reported yet the gap is
 greater than this absolute gap.

optional double absolute_gap_limit = 159 [default = 0.0001];

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.

 If the objective is integer, then any absolute gap < 1 will lead to a true
 optimal. If the objective is floating point, a gap of zero make little
 sense so is is why we use a non-zero default value. At the end of the
 search, we will display a warning if OPTIMAL is reported yet the gap is
 greater than this absolute gap.

optional double absolute_gap_limit = 159 [default = 0.0001];

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.

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. This is the maing
 logging parameter and if this is false, none of the logging (callbacks,
 log_to_stdout, log_to_response, ...) will do anything.

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. This is the maing
 logging parameter and if this is false, none of the logging (callbacks,
 log_to_stdout, log_to_response, ...) will do anything.

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. This is the maing
 logging parameter and if this is false, none of the logging (callbacks,
 log_to_stdout, log_to_response, ...) will do anything.

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. This is the maing
 logging parameter and if this is false, none of the logging (callbacks,
 log_to_stdout, log_to_response, ...) will do anything.

optional bool log_search_progress = 41 [default = false];

Returns:: This builder for chaining.

hasLogSubsolverStatistics

public boolean hasLogSubsolverStatistics()

 Whether the solver should display per sub-solver search statistics.
 This is only useful is log_search_progress is set to true, and if the
 number of search workers is > 1. Note that in all case we display a bit
 of stats with one line per subsolver.

optional bool log_subsolver_statistics = 189 [default = false];

Specified by:: hasLogSubsolverStatistics in interface SatParametersOrBuilder
Returns:: Whether the logSubsolverStatistics field is set.

getLogSubsolverStatistics

public boolean getLogSubsolverStatistics()

 Whether the solver should display per sub-solver search statistics.
 This is only useful is log_search_progress is set to true, and if the
 number of search workers is > 1. Note that in all case we display a bit
 of stats with one line per subsolver.

optional bool log_subsolver_statistics = 189 [default = false];

Specified by:: getLogSubsolverStatistics in interface SatParametersOrBuilder
Returns:: The logSubsolverStatistics.

setLogSubsolverStatistics

public SatParameters.Builder setLogSubsolverStatistics(boolean value)

 Whether the solver should display per sub-solver search statistics.
 This is only useful is log_search_progress is set to true, and if the
 number of search workers is > 1. Note that in all case we display a bit
 of stats with one line per subsolver.

optional bool log_subsolver_statistics = 189 [default = false];

Parameters:: value - The logSubsolverStatistics to set.
Returns:: This builder for chaining.

clearLogSubsolverStatistics

public SatParameters.Builder clearLogSubsolverStatistics()

 Whether the solver should display per sub-solver search statistics.
 This is only useful is log_search_progress is set to true, and if the
 number of search workers is > 1. Note that in all case we display a bit
 of stats with one line per subsolver.

optional bool log_subsolver_statistics = 189 [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.

hasProbingDeterministicTimeLimit

public boolean hasProbingDeterministicTimeLimit()

 The maximum "deterministic" time limit to spend in probing. A value of
 zero will disable the probing.

 TODO(user): Clean up. The first one is used in CP-SAT, the other in pure
 SAT presolve.

optional double probing_deterministic_time_limit = 226 [default = 1];

Specified by:: hasProbingDeterministicTimeLimit in interface SatParametersOrBuilder
Returns:: Whether the probingDeterministicTimeLimit field is set.

getProbingDeterministicTimeLimit

public double getProbingDeterministicTimeLimit()

 The maximum "deterministic" time limit to spend in probing. A value of
 zero will disable the probing.

 TODO(user): Clean up. The first one is used in CP-SAT, the other in pure
 SAT presolve.

optional double probing_deterministic_time_limit = 226 [default = 1];

Specified by:: getProbingDeterministicTimeLimit in interface SatParametersOrBuilder
Returns:: The probingDeterministicTimeLimit.

setProbingDeterministicTimeLimit

public SatParameters.Builder setProbingDeterministicTimeLimit(double value)

 The maximum "deterministic" time limit to spend in probing. A value of
 zero will disable the probing.

 TODO(user): Clean up. The first one is used in CP-SAT, the other in pure
 SAT presolve.

optional double probing_deterministic_time_limit = 226 [default = 1];

Parameters:: value - The probingDeterministicTimeLimit to set.
Returns:: This builder for chaining.

clearProbingDeterministicTimeLimit

public SatParameters.Builder clearProbingDeterministicTimeLimit()

 The maximum "deterministic" time limit to spend in probing. A value of
 zero will disable the probing.

 TODO(user): Clean up. The first one is used in CP-SAT, the other in pure
 SAT presolve.

optional double probing_deterministic_time_limit = 226 [default = 1];

Returns:: This builder for chaining.

hasPresolveProbingDeterministicTimeLimit
```
public boolean hasPresolveProbingDeterministicTimeLimit()
```
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()
```
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)
```
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()
```
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.

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.

hasDetectTableWithCost

public boolean hasDetectTableWithCost()

 If true, we detect variable that are unique to a table constraint and only
 there to encode a cost on each tuple. This is usually the case when a WCSP
 (weighted constraint program) is encoded into CP-SAT format.

 This can lead to a dramatic speed-up for such problems but is still
 experimental at this point.

optional bool detect_table_with_cost = 216 [default = false];

Specified by:: hasDetectTableWithCost in interface SatParametersOrBuilder
Returns:: Whether the detectTableWithCost field is set.

getDetectTableWithCost

public boolean getDetectTableWithCost()

 If true, we detect variable that are unique to a table constraint and only
 there to encode a cost on each tuple. This is usually the case when a WCSP
 (weighted constraint program) is encoded into CP-SAT format.

 This can lead to a dramatic speed-up for such problems but is still
 experimental at this point.

optional bool detect_table_with_cost = 216 [default = false];

Specified by:: getDetectTableWithCost in interface SatParametersOrBuilder
Returns:: The detectTableWithCost.

setDetectTableWithCost

public SatParameters.Builder setDetectTableWithCost(boolean value)

 If true, we detect variable that are unique to a table constraint and only
 there to encode a cost on each tuple. This is usually the case when a WCSP
 (weighted constraint program) is encoded into CP-SAT format.

 This can lead to a dramatic speed-up for such problems but is still
 experimental at this point.

optional bool detect_table_with_cost = 216 [default = false];

Parameters:: value - The detectTableWithCost to set.
Returns:: This builder for chaining.

clearDetectTableWithCost

public SatParameters.Builder clearDetectTableWithCost()

 If true, we detect variable that are unique to a table constraint and only
 there to encode a cost on each tuple. This is usually the case when a WCSP
 (weighted constraint program) is encoded into CP-SAT format.

 This can lead to a dramatic speed-up for such problems but is still
 experimental at this point.

optional bool detect_table_with_cost = 216 [default = false];

Returns:: This builder for chaining.

hasTableCompressionLevel

public boolean hasTableCompressionLevel()

 How much we try to "compress" a table constraint. Compressing more leads to
 less Booleans and faster propagation but can reduced the quality of the lp
 relaxation. Values goes from 0 to 3 where we always try to fully compress a
 table. At 2, we try to automatically decide if it is worth it.

optional int32 table_compression_level = 217 [default = 2];

Specified by:: hasTableCompressionLevel in interface SatParametersOrBuilder
Returns:: Whether the tableCompressionLevel field is set.

getTableCompressionLevel

public int getTableCompressionLevel()

 How much we try to "compress" a table constraint. Compressing more leads to
 less Booleans and faster propagation but can reduced the quality of the lp
 relaxation. Values goes from 0 to 3 where we always try to fully compress a
 table. At 2, we try to automatically decide if it is worth it.

optional int32 table_compression_level = 217 [default = 2];

Specified by:: getTableCompressionLevel in interface SatParametersOrBuilder
Returns:: The tableCompressionLevel.

setTableCompressionLevel

public SatParameters.Builder setTableCompressionLevel(int value)

 How much we try to "compress" a table constraint. Compressing more leads to
 less Booleans and faster propagation but can reduced the quality of the lp
 relaxation. Values goes from 0 to 3 where we always try to fully compress a
 table. At 2, we try to automatically decide if it is worth it.

optional int32 table_compression_level = 217 [default = 2];

Parameters:: value - The tableCompressionLevel to set.
Returns:: This builder for chaining.

clearTableCompressionLevel

public SatParameters.Builder clearTableCompressionLevel()

 How much we try to "compress" a table constraint. Compressing more leads to
 less Booleans and faster propagation but can reduced the quality of the lp
 relaxation. Values goes from 0 to 3 where we always try to fully compress a
 table. At 2, we try to automatically decide if it is worth it.

optional int32 table_compression_level = 217 [default = 2];

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.

hasMaxLinMaxSizeForExpansion

public boolean hasMaxLinMaxSizeForExpansion()

 If the number of expressions in the lin_max is less that the max size
 parameter, model expansion replaces target = max(xi) by linear constraint
 with the introduction of new booleans bi such that bi => target == xi.

 This is mainly for experimenting compared to a custom lin_max propagator.

optional int32 max_lin_max_size_for_expansion = 280 [default = 0];

Specified by:: hasMaxLinMaxSizeForExpansion in interface SatParametersOrBuilder
Returns:: Whether the maxLinMaxSizeForExpansion field is set.

getMaxLinMaxSizeForExpansion

public int getMaxLinMaxSizeForExpansion()

 If the number of expressions in the lin_max is less that the max size
 parameter, model expansion replaces target = max(xi) by linear constraint
 with the introduction of new booleans bi such that bi => target == xi.

 This is mainly for experimenting compared to a custom lin_max propagator.

optional int32 max_lin_max_size_for_expansion = 280 [default = 0];

Specified by:: getMaxLinMaxSizeForExpansion in interface SatParametersOrBuilder
Returns:: The maxLinMaxSizeForExpansion.

setMaxLinMaxSizeForExpansion

public SatParameters.Builder setMaxLinMaxSizeForExpansion(int value)

 If the number of expressions in the lin_max is less that the max size
 parameter, model expansion replaces target = max(xi) by linear constraint
 with the introduction of new booleans bi such that bi => target == xi.

 This is mainly for experimenting compared to a custom lin_max propagator.

optional int32 max_lin_max_size_for_expansion = 280 [default = 0];

Parameters:: value - The maxLinMaxSizeForExpansion to set.
Returns:: This builder for chaining.

clearMaxLinMaxSizeForExpansion

public SatParameters.Builder clearMaxLinMaxSizeForExpansion()

 If the number of expressions in the lin_max is less that the max size
 parameter, model expansion replaces target = max(xi) by linear constraint
 with the introduction of new booleans bi such that bi => target == xi.

 This is mainly for experimenting compared to a custom lin_max propagator.

optional int32 max_lin_max_size_for_expansion = 280 [default = 0];

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.

hasEncodeComplexLinearConstraintWithInteger
```
public boolean hasEncodeComplexLinearConstraintWithInteger()
```
```
 Linear constraint with a complex right hand side (more than a single
 interval) need to be expanded, there is a couple of way to do that.
 
```
optional bool encode_complex_linear_constraint_with_integer = 223 [default = false];
Specified by:

hasEncodeComplexLinearConstraintWithInteger in interface SatParametersOrBuilder

Returns:

Whether the encodeComplexLinearConstraintWithInteger field is set.

getEncodeComplexLinearConstraintWithInteger
```
public boolean getEncodeComplexLinearConstraintWithInteger()
```
```
 Linear constraint with a complex right hand side (more than a single
 interval) need to be expanded, there is a couple of way to do that.
 
```
optional bool encode_complex_linear_constraint_with_integer = 223 [default = false];
Specified by:

getEncodeComplexLinearConstraintWithInteger in interface SatParametersOrBuilder

Returns:

The encodeComplexLinearConstraintWithInteger.

setEncodeComplexLinearConstraintWithInteger

public SatParameters.Builder setEncodeComplexLinearConstraintWithInteger(boolean value)

 Linear constraint with a complex right hand side (more than a single
 interval) need to be expanded, there is a couple of way to do that.

optional bool encode_complex_linear_constraint_with_integer = 223 [default = false];

Parameters:: value - The encodeComplexLinearConstraintWithInteger to set.
Returns:: This builder for chaining.

clearEncodeComplexLinearConstraintWithInteger

public SatParameters.Builder clearEncodeComplexLinearConstraintWithInteger()

 Linear constraint with a complex right hand side (more than a single
 interval) need to be expanded, there is a couple of way to do that.

optional bool encode_complex_linear_constraint_with_integer = 223 [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.

hasPresolveInclusionWorkLimit

public boolean hasPresolveInclusionWorkLimit()

 A few presolve operations involve detecting constraints included in other
 constraint. Since there can be a quadratic number of such pairs, and
 processing them usually involve scanning them, the complexity of these
 operations can be big. This enforce a local deterministic limit on the
 number of entries scanned. Default is 1e8.

 A value of zero will disable these presolve rules completely.

optional int64 presolve_inclusion_work_limit = 201 [default = 100000000];

Specified by:: hasPresolveInclusionWorkLimit in interface SatParametersOrBuilder
Returns:: Whether the presolveInclusionWorkLimit field is set.

getPresolveInclusionWorkLimit

public long getPresolveInclusionWorkLimit()

 A few presolve operations involve detecting constraints included in other
 constraint. Since there can be a quadratic number of such pairs, and
 processing them usually involve scanning them, the complexity of these
 operations can be big. This enforce a local deterministic limit on the
 number of entries scanned. Default is 1e8.

 A value of zero will disable these presolve rules completely.

optional int64 presolve_inclusion_work_limit = 201 [default = 100000000];

Specified by:: getPresolveInclusionWorkLimit in interface SatParametersOrBuilder
Returns:: The presolveInclusionWorkLimit.

setPresolveInclusionWorkLimit

public SatParameters.Builder setPresolveInclusionWorkLimit(long value)

 A few presolve operations involve detecting constraints included in other
 constraint. Since there can be a quadratic number of such pairs, and
 processing them usually involve scanning them, the complexity of these
 operations can be big. This enforce a local deterministic limit on the
 number of entries scanned. Default is 1e8.

 A value of zero will disable these presolve rules completely.

optional int64 presolve_inclusion_work_limit = 201 [default = 100000000];

Parameters:: value - The presolveInclusionWorkLimit to set.
Returns:: This builder for chaining.

clearPresolveInclusionWorkLimit

public SatParameters.Builder clearPresolveInclusionWorkLimit()

 A few presolve operations involve detecting constraints included in other
 constraint. Since there can be a quadratic number of such pairs, and
 processing them usually involve scanning them, the complexity of these
 operations can be big. This enforce a local deterministic limit on the
 number of entries scanned. Default is 1e8.

 A value of zero will disable these presolve rules completely.

optional int64 presolve_inclusion_work_limit = 201 [default = 100000000];

Returns:: This builder for chaining.

hasIgnoreNames
```
public boolean hasIgnoreNames()
```
```
 If true, we don't keep names in our internal copy of the user given model.
 
```
optional bool ignore_names = 202 [default = true];
Specified by:

hasIgnoreNames in interface SatParametersOrBuilder

Returns:

Whether the ignoreNames field is set.

getIgnoreNames
```
public boolean getIgnoreNames()
```
```
 If true, we don't keep names in our internal copy of the user given model.
 
```
optional bool ignore_names = 202 [default = true];
Specified by:

getIgnoreNames in interface SatParametersOrBuilder

Returns:

The ignoreNames.

setIgnoreNames

public SatParameters.Builder setIgnoreNames(boolean value)

 If true, we don't keep names in our internal copy of the user given model.

optional bool ignore_names = 202 [default = true];

Parameters:: value - The ignoreNames to set.
Returns:: This builder for chaining.

clearIgnoreNames

public SatParameters.Builder clearIgnoreNames()

 If true, we don't keep names in our internal copy of the user given model.

optional bool ignore_names = 202 [default = true];

Returns:: This builder for chaining.

hasInferAllDiffs

public boolean hasInferAllDiffs()

 Run a max-clique code amongst all the x != y we can find and try to infer
 set of variables that are all different. This allows to close neos16.mps
 for instance. Note that we only run this code if there is no all_diff
 already in the model so that if a user want to add some all_diff, we assume
 it is well done and do not try to add more.

 This will also detect and add no_overlap constraints, if all the relations
 x != y have "offsets" between them. I.e. x > y + offset.

optional bool infer_all_diffs = 233 [default = true];

Specified by:: hasInferAllDiffs in interface SatParametersOrBuilder
Returns:: Whether the inferAllDiffs field is set.

getInferAllDiffs

public boolean getInferAllDiffs()

 Run a max-clique code amongst all the x != y we can find and try to infer
 set of variables that are all different. This allows to close neos16.mps
 for instance. Note that we only run this code if there is no all_diff
 already in the model so that if a user want to add some all_diff, we assume
 it is well done and do not try to add more.

 This will also detect and add no_overlap constraints, if all the relations
 x != y have "offsets" between them. I.e. x > y + offset.

optional bool infer_all_diffs = 233 [default = true];

Specified by:: getInferAllDiffs in interface SatParametersOrBuilder
Returns:: The inferAllDiffs.

setInferAllDiffs

public SatParameters.Builder setInferAllDiffs(boolean value)

 Run a max-clique code amongst all the x != y we can find and try to infer
 set of variables that are all different. This allows to close neos16.mps
 for instance. Note that we only run this code if there is no all_diff
 already in the model so that if a user want to add some all_diff, we assume
 it is well done and do not try to add more.

 This will also detect and add no_overlap constraints, if all the relations
 x != y have "offsets" between them. I.e. x > y + offset.

optional bool infer_all_diffs = 233 [default = true];

Parameters:: value - The inferAllDiffs to set.
Returns:: This builder for chaining.

clearInferAllDiffs

public SatParameters.Builder clearInferAllDiffs()

 Run a max-clique code amongst all the x != y we can find and try to infer
 set of variables that are all different. This allows to close neos16.mps
 for instance. Note that we only run this code if there is no all_diff
 already in the model so that if a user want to add some all_diff, we assume
 it is well done and do not try to add more.

 This will also detect and add no_overlap constraints, if all the relations
 x != y have "offsets" between them. I.e. x > y + offset.

optional bool infer_all_diffs = 233 [default = true];

Returns:: This builder for chaining.

hasFindBigLinearOverlap

public boolean hasFindBigLinearOverlap()

 Try to find large "rectangle" in the linear constraint matrix with
 identical lines. If such rectangle is big enough, we can introduce a new
 integer variable corresponding to the common expression and greatly reduce
 the number of non-zero.

optional bool find_big_linear_overlap = 234 [default = true];

Specified by:: hasFindBigLinearOverlap in interface SatParametersOrBuilder
Returns:: Whether the findBigLinearOverlap field is set.

getFindBigLinearOverlap

public boolean getFindBigLinearOverlap()

 Try to find large "rectangle" in the linear constraint matrix with
 identical lines. If such rectangle is big enough, we can introduce a new
 integer variable corresponding to the common expression and greatly reduce
 the number of non-zero.

optional bool find_big_linear_overlap = 234 [default = true];

Specified by:: getFindBigLinearOverlap in interface SatParametersOrBuilder
Returns:: The findBigLinearOverlap.

setFindBigLinearOverlap

public SatParameters.Builder setFindBigLinearOverlap(boolean value)

 Try to find large "rectangle" in the linear constraint matrix with
 identical lines. If such rectangle is big enough, we can introduce a new
 integer variable corresponding to the common expression and greatly reduce
 the number of non-zero.

optional bool find_big_linear_overlap = 234 [default = true];

Parameters:: value - The findBigLinearOverlap to set.
Returns:: This builder for chaining.

clearFindBigLinearOverlap

public SatParameters.Builder clearFindBigLinearOverlap()

 Try to find large "rectangle" in the linear constraint matrix with
 identical lines. If such rectangle is big enough, we can introduce a new
 integer variable corresponding to the common expression and greatly reduce
 the number of non-zero.

optional bool find_big_linear_overlap = 234 [default = true];

Returns:: This builder for chaining.

hasUseSatInprocessing
```
public boolean hasUseSatInprocessing()
```
```
 Enable or disable "inprocessing" which is some SAT presolving done at
 each restart to the root level.
 
```
optional bool use_sat_inprocessing = 163 [default = true];
Specified by:

hasUseSatInprocessing in interface SatParametersOrBuilder

Returns:

Whether the useSatInprocessing field is set.

getUseSatInprocessing
```
public boolean getUseSatInprocessing()
```
```
 Enable or disable "inprocessing" which is some SAT presolving done at
 each restart to the root level.
 
```
optional bool use_sat_inprocessing = 163 [default = true];
Specified by:

getUseSatInprocessing in interface SatParametersOrBuilder

Returns:

The useSatInprocessing.

setUseSatInprocessing

public SatParameters.Builder setUseSatInprocessing(boolean value)

 Enable or disable "inprocessing" which is some SAT presolving done at
 each restart to the root level.

optional bool use_sat_inprocessing = 163 [default = true];

Parameters:: value - The useSatInprocessing to set.
Returns:: This builder for chaining.

clearUseSatInprocessing

public SatParameters.Builder clearUseSatInprocessing()

 Enable or disable "inprocessing" which is some SAT presolving done at
 each restart to the root level.

optional bool use_sat_inprocessing = 163 [default = true];

Returns:: This builder for chaining.

hasInprocessingDtimeRatio

public boolean hasInprocessingDtimeRatio()

 Proportion of deterministic time we should spend on inprocessing.
 At each "restart", if the proportion is below this ratio, we will do some
 inprocessing, otherwise, we skip it for this restart.

optional double inprocessing_dtime_ratio = 273 [default = 0.2];

Specified by:: hasInprocessingDtimeRatio in interface SatParametersOrBuilder
Returns:: Whether the inprocessingDtimeRatio field is set.

getInprocessingDtimeRatio

public double getInprocessingDtimeRatio()

 Proportion of deterministic time we should spend on inprocessing.
 At each "restart", if the proportion is below this ratio, we will do some
 inprocessing, otherwise, we skip it for this restart.

optional double inprocessing_dtime_ratio = 273 [default = 0.2];

Specified by:: getInprocessingDtimeRatio in interface SatParametersOrBuilder
Returns:: The inprocessingDtimeRatio.

setInprocessingDtimeRatio

public SatParameters.Builder setInprocessingDtimeRatio(double value)

 Proportion of deterministic time we should spend on inprocessing.
 At each "restart", if the proportion is below this ratio, we will do some
 inprocessing, otherwise, we skip it for this restart.

optional double inprocessing_dtime_ratio = 273 [default = 0.2];

Parameters:: value - The inprocessingDtimeRatio to set.
Returns:: This builder for chaining.

clearInprocessingDtimeRatio

public SatParameters.Builder clearInprocessingDtimeRatio()

 Proportion of deterministic time we should spend on inprocessing.
 At each "restart", if the proportion is below this ratio, we will do some
 inprocessing, otherwise, we skip it for this restart.

optional double inprocessing_dtime_ratio = 273 [default = 0.2];

Returns:: This builder for chaining.

hasInprocessingProbingDtime
```
public boolean hasInprocessingProbingDtime()
```
```
 The amount of dtime we should spend on probing for each inprocessing round.
 
```
optional double inprocessing_probing_dtime = 274 [default = 1];
Specified by:

hasInprocessingProbingDtime in interface SatParametersOrBuilder

Returns:

Whether the inprocessingProbingDtime field is set.

getInprocessingProbingDtime
```
public double getInprocessingProbingDtime()
```
```
 The amount of dtime we should spend on probing for each inprocessing round.
 
```
optional double inprocessing_probing_dtime = 274 [default = 1];
Specified by:

getInprocessingProbingDtime in interface SatParametersOrBuilder

Returns:

The inprocessingProbingDtime.

setInprocessingProbingDtime
```
public SatParameters.Builder setInprocessingProbingDtime(double value)
```
```
 The amount of dtime we should spend on probing for each inprocessing round.
 
```
optional double inprocessing_probing_dtime = 274 [default = 1];
Parameters:

value - The inprocessingProbingDtime to set.

Returns:

This builder for chaining.

clearInprocessingProbingDtime

public SatParameters.Builder clearInprocessingProbingDtime()

 The amount of dtime we should spend on probing for each inprocessing round.

optional double inprocessing_probing_dtime = 274 [default = 1];

Returns:: This builder for chaining.

hasInprocessingMinimizationDtime

public boolean hasInprocessingMinimizationDtime()

 Parameters for an heuristic similar to the one described in "An effective
 learnt clause minimization approach for CDCL Sat Solvers",
 https://www.ijcai.org/proceedings/2017/0098.pdf

 This is the amount of dtime we should spend on this technique during each
 inprocessing phase.

 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.

optional double inprocessing_minimization_dtime = 275 [default = 1];

Specified by:: hasInprocessingMinimizationDtime in interface SatParametersOrBuilder
Returns:: Whether the inprocessingMinimizationDtime field is set.

getInprocessingMinimizationDtime

public double getInprocessingMinimizationDtime()

 Parameters for an heuristic similar to the one described in "An effective
 learnt clause minimization approach for CDCL Sat Solvers",
 https://www.ijcai.org/proceedings/2017/0098.pdf

 This is the amount of dtime we should spend on this technique during each
 inprocessing phase.

 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.

optional double inprocessing_minimization_dtime = 275 [default = 1];

Specified by:: getInprocessingMinimizationDtime in interface SatParametersOrBuilder
Returns:: The inprocessingMinimizationDtime.

setInprocessingMinimizationDtime

public SatParameters.Builder setInprocessingMinimizationDtime(double value)

 Parameters for an heuristic similar to the one described in "An effective
 learnt clause minimization approach for CDCL Sat Solvers",
 https://www.ijcai.org/proceedings/2017/0098.pdf

 This is the amount of dtime we should spend on this technique during each
 inprocessing phase.

 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.

optional double inprocessing_minimization_dtime = 275 [default = 1];

Parameters:: value - The inprocessingMinimizationDtime to set.
Returns:: This builder for chaining.

clearInprocessingMinimizationDtime

public SatParameters.Builder clearInprocessingMinimizationDtime()

 Parameters for an heuristic similar to the one described in "An effective
 learnt clause minimization approach for CDCL Sat Solvers",
 https://www.ijcai.org/proceedings/2017/0098.pdf

 This is the amount of dtime we should spend on this technique during each
 inprocessing phase.

 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.

optional double inprocessing_minimization_dtime = 275 [default = 1];

Returns:: This builder for chaining.

hasNumWorkers

public boolean hasNumWorkers()

 Specify the number of parallel workers (i.e. threads) to use during search.
 This should usually be lower than your number of available cpus +
 hyperthread in your machine.

 A value of 0 means the solver will try to use all cores on the machine.
 A number of 1 means no parallelism.

 Note that 'num_workers' is the preferred name, but if it is set to zero,
 we will still read the deprecated 'num_search_worker'.

 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_workers = 206 [default = 0];

Specified by:: hasNumWorkers in interface SatParametersOrBuilder
Returns:: Whether the numWorkers field is set.

getNumWorkers

public int getNumWorkers()

 Specify the number of parallel workers (i.e. threads) to use during search.
 This should usually be lower than your number of available cpus +
 hyperthread in your machine.

 A value of 0 means the solver will try to use all cores on the machine.
 A number of 1 means no parallelism.

 Note that 'num_workers' is the preferred name, but if it is set to zero,
 we will still read the deprecated 'num_search_worker'.

 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_workers = 206 [default = 0];

Specified by:: getNumWorkers in interface SatParametersOrBuilder
Returns:: The numWorkers.

setNumWorkers

public SatParameters.Builder setNumWorkers(int value)

 Specify the number of parallel workers (i.e. threads) to use during search.
 This should usually be lower than your number of available cpus +
 hyperthread in your machine.

 A value of 0 means the solver will try to use all cores on the machine.
 A number of 1 means no parallelism.

 Note that 'num_workers' is the preferred name, but if it is set to zero,
 we will still read the deprecated 'num_search_worker'.

 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_workers = 206 [default = 0];

Parameters:: value - The numWorkers to set.
Returns:: This builder for chaining.

clearNumWorkers

public SatParameters.Builder clearNumWorkers()

 Specify the number of parallel workers (i.e. threads) to use during search.
 This should usually be lower than your number of available cpus +
 hyperthread in your machine.

 A value of 0 means the solver will try to use all cores on the machine.
 A number of 1 means no parallelism.

 Note that 'num_workers' is the preferred name, but if it is set to zero,
 we will still read the deprecated 'num_search_worker'.

 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_workers = 206 [default = 0];

Returns:: This builder for chaining.

hasNumSearchWorkers
```
public boolean hasNumSearchWorkers()
```
optional int32 num_search_workers = 100 [default = 0];

Specified by:

hasNumSearchWorkers in interface SatParametersOrBuilder

Returns:

Whether the numSearchWorkers field is set.

getNumSearchWorkers
```
public int getNumSearchWorkers()
```
optional int32 num_search_workers = 100 [default = 0];

Specified by:

getNumSearchWorkers in interface SatParametersOrBuilder

Returns:

The numSearchWorkers.

setNumSearchWorkers
```
public SatParameters.Builder setNumSearchWorkers(int value)
```
optional int32 num_search_workers = 100 [default = 0];

Parameters:

value - The numSearchWorkers to set.

Returns:

This builder for chaining.

clearNumSearchWorkers
```
public SatParameters.Builder clearNumSearchWorkers()
```
optional int32 num_search_workers = 100 [default = 0];

Returns:

This builder for chaining.

hasMinNumLnsWorkers
```
public boolean hasMinNumLnsWorkers()
```
```
 Obsolete parameter. No-op.
 
```
optional int32 min_num_lns_workers = 211 [default = 2];
Specified by:

hasMinNumLnsWorkers in interface SatParametersOrBuilder

Returns:

Whether the minNumLnsWorkers field is set.

getMinNumLnsWorkers
```
public int getMinNumLnsWorkers()
```
```
 Obsolete parameter. No-op.
 
```
optional int32 min_num_lns_workers = 211 [default = 2];
Specified by:

getMinNumLnsWorkers in interface SatParametersOrBuilder

Returns:

The minNumLnsWorkers.

setMinNumLnsWorkers
```
public SatParameters.Builder setMinNumLnsWorkers(int value)
```
```
 Obsolete parameter. No-op.
 
```
optional int32 min_num_lns_workers = 211 [default = 2];
Parameters:

value - The minNumLnsWorkers to set.

Returns:

This builder for chaining.

clearMinNumLnsWorkers
```
public SatParameters.Builder clearMinNumLnsWorkers()
```
```
 Obsolete parameter. No-op.
 
```
optional int32 min_num_lns_workers = 211 [default = 2];
Returns:

This builder for chaining.

getSubsolversList

public com.google.protobuf.ProtocolStringList getSubsolversList()

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Specified by:: getSubsolversList in interface SatParametersOrBuilder
Returns:: A list containing the subsolvers.

getSubsolversCount

public int getSubsolversCount()

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Specified by:: getSubsolversCount in interface SatParametersOrBuilder
Returns:: The count of subsolvers.

getSubsolvers

public java.lang.String getSubsolvers(int index)

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Specified by:: getSubsolvers in interface SatParametersOrBuilder
Parameters:: index - The index of the element to return.
Returns:: The subsolvers at the given index.

getSubsolversBytes

public com.google.protobuf.ByteString getSubsolversBytes(int index)

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Specified by:: getSubsolversBytes in interface SatParametersOrBuilder
Parameters:: index - The index of the value to return.
Returns:: The bytes of the subsolvers at the given index.

setSubsolvers

public SatParameters.Builder setSubsolvers(int index,
                                           java.lang.String value)

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Parameters:: index - The index to set the value at.; value - The subsolvers to set.
Returns:: This builder for chaining.

addSubsolvers

public SatParameters.Builder addSubsolvers(java.lang.String value)

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Parameters:: value - The subsolvers to add.
Returns:: This builder for chaining.

addAllSubsolvers

public SatParameters.Builder addAllSubsolvers(java.lang.Iterable<java.lang.String> values)

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Parameters:: values - The subsolvers to add.
Returns:: This builder for chaining.

clearSubsolvers

public SatParameters.Builder clearSubsolvers()

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Returns:: This builder for chaining.

addSubsolversBytes

public SatParameters.Builder addSubsolversBytes(com.google.protobuf.ByteString value)

 In multi-thread, the solver can be mainly seen as a portfolio of solvers
 with different parameters. This field indicates the names of the parameters
 that are used in multithread.

 See cp_model_search.cc to see a list of the names and the default value (if
 left empty) that looks like:
 - default_lp           (linearization_level:1)
 - fixed                (only if fixed search specified or scheduling)
 - no_lp                (linearization_level:0)
 - max_lp               (linearization_level:2)
 - pseudo_costs         (only if objective, change search heuristic)
 - reduced_costs        (only if objective, change search heuristic)
 - quick_restart        (kind of probing)
 - quick_restart_no_lp  (kind of probing with linearization_level:0)
 - lb_tree_search       (to improve lower bound, MIP like tree search)
 - probing              (continuous probing and shaving)

 Also, note that some set of parameters will be ignored if they do not make
 sense. For instance if there is no objective, pseudo_cost or reduced_cost
 search will be ignored. Core based search will only work if the objective
 has many terms. If there is no fixed strategy fixed will be ignored. And so
 on.

 The order is important, as only the first usable "num_workers -
 min_num_lns_workers" subsolvers will be scheduled. You can see in the log
 which one are selected for a given run. All the others will be LNS if there
 is an objective, or randomized SAT search for pure satisfiability problems.

repeated string subsolvers = 207;

Parameters:: value - The bytes of the subsolvers to add.
Returns:: This builder for chaining.

getExtraSubsolversList
```
public com.google.protobuf.ProtocolStringList getExtraSubsolversList()
```
```
 A convenient way to add more workers types.
 These will be added at the beginning of the list.
 
```
repeated string extra_subsolvers = 219;
Specified by:

getExtraSubsolversList in interface SatParametersOrBuilder

Returns:

A list containing the extraSubsolvers.

getExtraSubsolversCount
```
public int getExtraSubsolversCount()
```
```
 A convenient way to add more workers types.
 These will be added at the beginning of the list.
 
```
repeated string extra_subsolvers = 219;
Specified by:

getExtraSubsolversCount in interface SatParametersOrBuilder

Returns:

The count of extraSubsolvers.

getExtraSubsolvers
```
public java.lang.String getExtraSubsolvers(int index)
```
```
 A convenient way to add more workers types.
 These will be added at the beginning of the list.
 
```
repeated string extra_subsolvers = 219;
Specified by:

getExtraSubsolvers in interface SatParametersOrBuilder

Parameters:

index - The index of the element to return.

Returns:

The extraSubsolvers at the given index.

getExtraSubsolversBytes
```
public com.google.protobuf.ByteString getExtraSubsolversBytes(int index)
```
```
 A convenient way to add more workers types.
 These will be added at the beginning of the list.
 
```
repeated string extra_subsolvers = 219;
Specified by:

getExtraSubsolversBytes in interface SatParametersOrBuilder

Parameters:

index - The index of the value to return.

Returns:

The bytes of the extraSubsolvers at the given index.

setExtraSubsolvers

public SatParameters.Builder setExtraSubsolvers(int index,
                                                java.lang.String value)

 A convenient way to add more workers types.
 These will be added at the beginning of the list.

repeated string extra_subsolvers = 219;

Parameters:: index - The index to set the value at.; value - The extraSubsolvers to set.
Returns:: This builder for chaining.

addExtraSubsolvers

public SatParameters.Builder addExtraSubsolvers(java.lang.String value)

 A convenient way to add more workers types.
 These will be added at the beginning of the list.

repeated string extra_subsolvers = 219;

Parameters:: value - The extraSubsolvers to add.
Returns:: This builder for chaining.

addAllExtraSubsolvers

public SatParameters.Builder addAllExtraSubsolvers(java.lang.Iterable<java.lang.String> values)

 A convenient way to add more workers types.
 These will be added at the beginning of the list.

repeated string extra_subsolvers = 219;

Parameters:: values - The extraSubsolvers to add.
Returns:: This builder for chaining.

clearExtraSubsolvers

public SatParameters.Builder clearExtraSubsolvers()

 A convenient way to add more workers types.
 These will be added at the beginning of the list.

repeated string extra_subsolvers = 219;

Returns:: This builder for chaining.

addExtraSubsolversBytes

public SatParameters.Builder addExtraSubsolversBytes(com.google.protobuf.ByteString value)

 A convenient way to add more workers types.
 These will be added at the beginning of the list.

repeated string extra_subsolvers = 219;

Parameters:: value - The bytes of the extraSubsolvers to add.
Returns:: This builder for chaining.

getIgnoreSubsolversList

public com.google.protobuf.ProtocolStringList getIgnoreSubsolversList()

 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.

repeated string ignore_subsolvers = 209;

Specified by:: getIgnoreSubsolversList in interface SatParametersOrBuilder
Returns:: A list containing the ignoreSubsolvers.

getIgnoreSubsolversCount

public int getIgnoreSubsolversCount()

 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.

repeated string ignore_subsolvers = 209;

Specified by:: getIgnoreSubsolversCount in interface SatParametersOrBuilder
Returns:: The count of ignoreSubsolvers.

getIgnoreSubsolvers
```
public java.lang.String getIgnoreSubsolvers(int index)
```
```
 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.
 
```
repeated string ignore_subsolvers = 209;
Specified by:

getIgnoreSubsolvers in interface SatParametersOrBuilder

Parameters:

index - The index of the element to return.

Returns:

The ignoreSubsolvers at the given index.

getIgnoreSubsolversBytes
```
public com.google.protobuf.ByteString getIgnoreSubsolversBytes(int index)
```
```
 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.
 
```
repeated string ignore_subsolvers = 209;
Specified by:

getIgnoreSubsolversBytes in interface SatParametersOrBuilder

Parameters:

index - The index of the value to return.

Returns:

The bytes of the ignoreSubsolvers at the given index.

setIgnoreSubsolvers

public SatParameters.Builder setIgnoreSubsolvers(int index,
                                                 java.lang.String value)

 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.

repeated string ignore_subsolvers = 209;

Parameters:: index - The index to set the value at.; value - The ignoreSubsolvers to set.
Returns:: This builder for chaining.

addIgnoreSubsolvers

public SatParameters.Builder addIgnoreSubsolvers(java.lang.String value)

 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.

repeated string ignore_subsolvers = 209;

Parameters:: value - The ignoreSubsolvers to add.
Returns:: This builder for chaining.

addAllIgnoreSubsolvers

public SatParameters.Builder addAllIgnoreSubsolvers(java.lang.Iterable<java.lang.String> values)

 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.

repeated string ignore_subsolvers = 209;

Parameters:: values - The ignoreSubsolvers to add.
Returns:: This builder for chaining.

clearIgnoreSubsolvers

public SatParameters.Builder clearIgnoreSubsolvers()

 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.

repeated string ignore_subsolvers = 209;

Returns:: This builder for chaining.

addIgnoreSubsolversBytes

public SatParameters.Builder addIgnoreSubsolversBytes(com.google.protobuf.ByteString value)

 Rather than fully specifying subsolvers, it is often convenient to just
 remove the ones that are not useful on a given problem.

repeated string ignore_subsolvers = 209;

Parameters:: value - The bytes of the ignoreSubsolvers to add.
Returns:: This builder for chaining.