From 4f381f6d078ccf21a629f0f6a05528578bd95ab9 Mon Sep 17 00:00:00 2001
From: Mizux Seiha <mizux.dev@gmail.com>
Date: Tue, 16 Sep 2025 16:25:04 +0200
Subject: [PATCH] backport from main:

* bump abseil to 20250814
* bump protobuf to v32.0
* cmake: add ccache auto support
* backport flatzinc, math_opt and sat update
---
 .dockerignore                                 |    1 -
 CMakeLists.txt                                |    5 +-
 Dependencies.txt                              |    4 +-
 MODULE.bazel                                  |    8 +-
 bazel/notebook_requirements.in                |    2 +-
 bazel/notebook_requirements.txt               |    2 +-
 bazel/ortools_requirements.in                 |    2 +-
 bazel/ortools_requirements.txt                |    2 +-
 bazel/swig_java.bzl                           |   28 +-
 cmake/README.md                               |   11 -
 cmake/ccache.cmake                            |   67 +
 cmake/cpp.cmake                               |    1 +
 cmake/dependencies/CMakeLists.txt             |   50 +-
 cmake/glop.cmake                              |    2 -
 cmake/host.CMakeLists.txt                     |    8 +-
 cmake/java.cmake                              |    2 +-
 cmake/python.cmake                            |    2 +-
 ortools/algorithms/BUILD.bazel                |   39 +-
 ortools/algorithms/java/BUILD.bazel           |    8 +-
 ortools/algorithms/python/BUILD.bazel         |    1 -
 ortools/algorithms/samples/code_samples.bzl   |    4 -
 ortools/base/BUILD.bazel                      |   74 +-
 ortools/base/CMakeLists.txt                   |   24 +-
 ortools/base/case.cc                          |  129 -
 ortools/base/case.h                           |  128 -
 ortools/base/parse_test_proto.h               |    3 +-
 ortools/base/protocol-buffer-matchers.cc      |  396 +
 ortools/base/protocol-buffer-matchers.h       |  368 +-
 ortools/base/small_map.h                      |   22 -
 ortools/base/stl_logging.h                    |  149 -
 ortools/bop/bop_solver.cc                     |    1 +
 ortools/dotnet/Google.OrTools-full.csproj.in  |    2 +-
 ortools/dotnet/Google.OrTools-local.csproj.in |    2 +-
 .../dotnet/Google.OrTools.runtime.csproj.in   |    2 +-
 ortools/flatzinc/BUILD.bazel                  |   26 +-
 ortools/flatzinc/checker.cc                   |  374 +-
 ortools/flatzinc/cp_model_fz_solver.cc        | 1748 +++-
 ortools/flatzinc/fz.cc                        |   26 +
 ortools/flatzinc/model.cc                     |   71 +-
 ortools/flatzinc/model.h                      |   14 +-
 .../flatzinc/mznlib/fzn_all_different_set.mzn |    1 +
 ortools/flatzinc/mznlib/fzn_all_disjoint.mzn  |    1 +
 ortools/flatzinc/mznlib/fzn_all_equal_int.mzn |    4 +
 ortools/flatzinc/mznlib/fzn_all_equal_set.mzn |    4 +
 ortools/flatzinc/mznlib/fzn_arg_max_bool.mzn  |    4 +
 ortools/flatzinc/mznlib/fzn_arg_max_int.mzn   |    4 +
 ortools/flatzinc/mznlib/fzn_arg_min_bool.mzn  |    4 +
 ortools/flatzinc/mznlib/fzn_arg_min_int.mzn   |    4 +
 ortools/flatzinc/mznlib/fzn_disjoint.mzn      |    1 +
 .../mznlib/fzn_global_cardinality.mzn         |   12 +
 .../mznlib/fzn_global_cardinality_closed.mzn  |   12 +
 .../mznlib/fzn_global_cardinality_low_up.mzn  |   14 +
 .../fzn_global_cardinality_low_up_closed.mzn  |   14 +
 ortools/flatzinc/mznlib/fzn_lex_less_bool.mzn |   14 +
 ortools/flatzinc/mznlib/fzn_lex_less_int.mzn  |   14 +
 .../flatzinc/mznlib/fzn_lex_lesseq_bool.mzn   |   14 +
 .../flatzinc/mznlib/fzn_lex_lesseq_int.mzn    |   14 +
 ortools/flatzinc/mznlib/fzn_partition_set.mzn |    1 +
 .../mznlib/fzn_seq_precede_chain_int.mzn      |    5 +
 .../mznlib/fzn_value_precede_chain_int.mzn    |   12 +
 .../flatzinc/mznlib/fzn_value_precede_int.mzn |    1 +
 .../flatzinc/mznlib/redefinitions-2.0.2.mzn   |    8 +-
 ortools/flatzinc/parser.tab.cc                |  745 +-
 ortools/flatzinc/parser.yy                    |   25 +-
 ortools/flatzinc/parser_main.cc               |   11 +-
 ortools/glop/BUILD.bazel                      |   27 +-
 ortools/glpk/BUILD.bazel                      |   15 +
 ortools/graph/BUILD.bazel                     |   38 +-
 ortools/graph/bidirectional_dijkstra.h        |    8 +-
 ortools/graph/generic_max_flow_test.cc        |    7 +-
 ortools/graph/java/BUILD.bazel                |    6 +-
 ortools/graph/line_graph.h                    |   62 -
 ortools/graph/line_graph_test.cc              |  104 -
 ortools/graph/samples/code_samples.bzl        |    4 -
 ortools/init/java/BUILD.bazel                 |    8 +-
 ortools/init/python/BUILD.bazel               |    1 -
 ortools/java/com/google/ortools/BUILD.bazel   |    1 +
 .../google/ortools/modelbuilder/BUILD.bazel   |    5 +-
 .../java/com/google/ortools/sat/BUILD.bazel   |    5 +-
 ortools/java/pom-full.xml.in                  |    2 +-
 ortools/java/pom-local.xml.in                 |    2 +-
 ortools/linear_solver/cbc_interface.cc        |    2 +-
 ortools/linear_solver/csharp/linear_solver.i  |    3 -
 ortools/linear_solver/gurobi_interface.cc     |    4 +-
 ortools/linear_solver/highs_interface.cc      |   15 +-
 ortools/linear_solver/java/BUILD.bazel        |    8 +-
 ortools/linear_solver/linear_solver.cc        |    6 +-
 ortools/linear_solver/linear_solver.proto     |    1 -
 .../proto_solver/highs_proto_solver.cc        |    6 +-
 .../proto_solver/highs_proto_solver.h         |   14 +-
 .../linear_solver/samples/code_samples.bzl    |    4 -
 ortools/linear_solver/scip_callback.cc        |    2 +-
 ortools/linear_solver/scip_interface.cc       |    4 +-
 ortools/lp_data/BUILD.bazel                   |   28 +-
 ortools/lp_data/lp_decomposer.cc              |   12 +-
 ortools/math_opt/core/python/BUILD.bazel      |   23 -
 ortools/math_opt/cpp/BUILD.bazel              |  260 +
 ortools/math_opt/cpp/CMakeLists.txt           |    2 +-
 ortools/math_opt/cpp/callback_test.cc         |  358 +
 ...ompute_infeasible_subsystem_result_test.cc |  590 ++
 ortools/math_opt/cpp/enums_test.cc            |  132 +
 .../cpp/enums_test.proto}                     |   17 +-
 ortools/math_opt/cpp/formatters_test.cc       |  137 +
 ortools/math_opt/cpp/key_types.h              |    6 +-
 ortools/math_opt/cpp/key_types_test.cc        |  165 +
 .../math_opt/cpp/linear_constraint_test.cc    |  205 +
 ortools/math_opt/cpp/map_filter_test.cc       |  331 +
 ortools/math_opt/cpp/matchers_test.cc         | 2032 +++++
 ortools/math_opt/cpp/message_callback.cc      |    9 +-
 ortools/math_opt/cpp/message_callback_test.cc |  415 +
 .../cpp/model_solve_parameters_test.cc        |  742 ++
 ortools/math_opt/cpp/objective_test.cc        |  233 +
 ortools/math_opt/cpp/parameters_test.cc       |  249 +
 ortools/math_opt/cpp/solution_test.cc         |  504 ++
 ortools/math_opt/cpp/solve_arguments_test.cc  |   97 +
 ortools/math_opt/cpp/solve_impl.cc            |    4 +-
 ortools/math_opt/cpp/solve_impl_test.cc       | 1865 ++++
 ortools/math_opt/cpp/solve_result_test.cc     |  932 ++
 ortools/math_opt/cpp/solve_test.cc            | 1539 ++++
 ortools/math_opt/cpp/solver_resources_test.cc |  103 +
 ortools/math_opt/cpp/statistics_test.cc       |  162 +
 .../streamable_solver_init_arguments_test.cc  |   50 +
 .../cpp/variable_and_expressions_nc_test.cc   |  101 +
 .../cpp/variable_and_expressions_test.cc      | 7643 +++++++++++++++++
 ortools/math_opt/elemental/BUILD.bazel        |   14 -
 ortools/math_opt/elemental/CMakeLists.txt     |    2 +-
 ortools/math_opt/elemental/element_storage.h  |    3 +-
 ortools/math_opt/elemental/elemental_test.cc  |    3 +-
 ortools/math_opt/python/BUILD.bazel           |    6 +-
 .../math_opt/python/bounded_expressions.py    |    1 +
 .../math_opt/python/ipc/proto_converter.py    |    2 +-
 .../math_opt/python/linear_expression_test.py |   28 +-
 .../python/normalized_inequality_test.py      |   18 +-
 ortools/math_opt/python/result_test.py        |   14 +-
 ortools/math_opt/samples/cpp/BUILD.bazel      |    5 -
 ortools/math_opt/samples/cpp/CMakeLists.txt   |    1 +
 .../math_opt/samples/cpp/coil_in_the_box.cc   |  383 +
 ortools/math_opt/samples/python/BUILD.bazel   |    1 -
 .../samples/python/linear_regression.py       |    3 -
 ortools/math_opt/solver_tests/CMakeLists.txt  |   44 +-
 .../solver_tests/invalid_input_tests.cc       |    1 -
 ortools/math_opt/solvers/BUILD.bazel          |   50 +-
 ortools/math_opt/solvers/CMakeLists.txt       |   76 +-
 ortools/math_opt/solvers/glpk/BUILD.bazel     |   25 +
 ortools/math_opt/solvers/gscip/BUILD.bazel    |   44 +-
 .../solvers/gscip/gscip_event_handler_test.cc |    1 -
 ortools/math_opt/solvers/highs_solver.cc      |    2 +-
 .../math_opt/solvers/message_callback_data.cc |    4 +-
 ortools/math_opt/solvers/osqp.proto           |    4 +-
 ortools/math_opt/storage/update_trackers.h    |   10 +-
 ortools/math_opt/testing/BUILD.bazel          |    2 +-
 ortools/math_opt/validators/BUILD.bazel       |    2 +-
 ortools/pdlp/BUILD.bazel                      |   31 +-
 ortools/pdlp/gtest_main.cc                    |   24 -
 ortools/pdlp/python/BUILD.bazel               |    2 -
 ortools/port/BUILD.bazel                      |    5 +
 ortools/port/os.h                             |   42 +
 ortools/python/setup.py.in                    |    2 +-
 ortools/sat/2d_distances_propagator.cc        |   26 +-
 .../sat/2d_mandatory_overlap_propagator.cc    |    1 +
 ortools/sat/2d_try_edge_propagator.cc         |    3 +-
 ortools/sat/2d_try_edge_propagator_test.cc    |    2 +-
 ortools/sat/BUILD.bazel                       |  222 +-
 ortools/sat/all_different.cc                  |   55 +-
 ortools/sat/all_different.h                   |   26 +-
 ortools/sat/all_different_test.cc             |   34 +
 ortools/sat/boolean_problem.cc                |    5 +-
 ortools/sat/circuit.cc                        |  200 +-
 ortools/sat/circuit.h                         |   17 +-
 ortools/sat/circuit_test.cc                   |   14 +-
 ortools/sat/clause.cc                         |  470 +-
 ortools/sat/clause.h                          |   56 +-
 ortools/sat/colab/cp_sat.ipynb                |   14 +
 ortools/sat/combine_solutions.cc              |    5 +-
 ortools/sat/combine_solutions.h               |    3 +-
 ortools/sat/constraint_violation.cc           |   52 +-
 ortools/sat/constraint_violation.h            |   33 +-
 ortools/sat/container.h                       |  238 +
 ortools/sat/container_test.cc                 |  139 +
 ortools/sat/cp_constraints.cc                 |  407 +-
 ortools/sat/cp_constraints.h                  |  131 +-
 ortools/sat/cp_constraints_test.cc            |  112 -
 ortools/sat/cp_model.proto                    |   30 +-
 ortools/sat/cp_model_checker.cc               |   97 +-
 ortools/sat/cp_model_checker_test.cc          |   27 -
 ortools/sat/cp_model_copy.cc                  |  287 +-
 ortools/sat/cp_model_copy.h                   |   26 +-
 ortools/sat/cp_model_copy_test.cc             |  131 +
 ortools/sat/cp_model_expand.cc                |  626 +-
 ortools/sat/cp_model_expand_test.cc           |  588 +-
 ortools/sat/cp_model_loader.cc                |   52 +-
 ortools/sat/cp_model_presolve.cc              |   68 +-
 ortools/sat/cp_model_search.cc                |   21 +-
 ortools/sat/cp_model_solver.cc                |   41 +-
 ortools/sat/cp_model_solver_helpers.cc        |   42 +-
 ortools/sat/cp_model_solver_test.cc           |  501 +-
 ortools/sat/cp_model_symmetries.cc            |   16 +-
 ortools/sat/cp_model_utils.cc                 |   18 +
 ortools/sat/cp_model_utils.h                  |   20 +
 ortools/sat/cumulative.cc                     |   43 +-
 ortools/sat/cumulative.h                      |    5 +
 ortools/sat/cumulative_energy.cc              |   21 +-
 ortools/sat/cumulative_energy_test.cc         |   17 +-
 ortools/sat/cumulative_test.cc                |   17 +-
 ortools/sat/diffn.cc                          |  121 +-
 ortools/sat/diffn.h                           |    8 +-
 ortools/sat/diffn_test.cc                     |    4 +-
 ortools/sat/diffn_util.cc                     |    8 +-
 ortools/sat/disjunctive.cc                    |  261 +-
 ortools/sat/disjunctive.h                     |   23 +-
 ortools/sat/disjunctive_test.cc               |   27 +-
 ortools/sat/docs/README.md                    |   65 +-
 ortools/sat/docs/boolean_logic.md             |   40 +-
 ortools/sat/docs/channeling.md                |  325 +-
 ortools/sat/docs/integer_arithmetic.md        |   22 +-
 ortools/sat/docs/model.md                     |    1 +
 ortools/sat/docs/scheduling.md                | 2164 ++---
 ortools/sat/docs/solver.md                    |    3 +
 ortools/sat/drat_proof_handler.h              |    4 +-
 ortools/sat/enforcement.cc                    |  313 +
 ortools/sat/enforcement.h                     |  134 +
 ortools/sat/enforcement_helper.cc             |  132 +
 ortools/sat/enforcement_helper.h              |  103 +
 ortools/sat/enforcement_test.cc               |  146 +
 ortools/sat/implied_bounds_test.cc            |    6 +-
 ortools/sat/integer.cc                        |   60 +-
 ortools/sat/integer.h                         |   11 +-
 ortools/sat/integer_expr.cc                   |  358 +-
 ortools/sat/integer_expr.h                    |   63 +-
 ortools/sat/integer_expr_test.cc              |  140 +-
 ortools/sat/integer_search.cc                 |   45 +-
 ortools/sat/integer_test.cc                   |   17 +-
 ortools/sat/intervals.cc                      |   22 +-
 ortools/sat/intervals.h                       |   13 +-
 ortools/sat/java/BUILD.bazel                  |   12 +-
 ortools/sat/linear_constraint_manager.cc      |    5 +-
 ortools/sat/linear_propagation.cc             |   19 +-
 ortools/sat/linear_propagation.h              |    4 +-
 ortools/sat/linear_relaxation.cc              |  166 +-
 ortools/sat/linear_relaxation.h               |   13 +-
 ortools/sat/linear_relaxation_test.cc         |   94 +-
 ortools/sat/no_overlap_2d_helper.cc           |   67 +-
 ortools/sat/no_overlap_2d_helper.h            |   21 +-
 ortools/sat/parameters_validation.cc          |    5 -
 ortools/sat/precedences.cc                    |  238 +
 ortools/sat/precedences.h                     |   41 +-
 ortools/sat/precedences_test.cc               |   12 +-
 ortools/sat/presolve_context.cc               |    1 -
 ortools/sat/probing.cc                        |    4 +-
 ortools/sat/python/cp_model_helper.cc         |    9 +
 ortools/sat/python/cp_model_test.py           |    5 +
 ortools/sat/python/wrappers.cc                |    6 +-
 ortools/sat/routing_cuts.cc                   |    8 +-
 ortools/sat/routing_cuts.h                    |    4 +-
 ortools/sat/routing_cuts_test.cc              |   18 +-
 ortools/sat/samples/BinPackingProblemSat.cs   |    2 +
 ortools/sat/samples/BinPackingProblemSat.java |    2 +
 ortools/sat/samples/BoolOrSampleSat.cs        |    2 +
 ortools/sat/samples/BoolOrSampleSat.java      |    2 +
 ortools/sat/samples/ChannelingSampleSat.cs    |    2 +
 ortools/sat/samples/ChannelingSampleSat.java  |    2 +
 .../EarlinessTardinessCostSampleSat.cs        |    2 +
 .../EarlinessTardinessCostSampleSat.java      |    2 +
 ortools/sat/samples/IntervalSampleSat.cs      |    2 +
 ortools/sat/samples/IntervalSampleSat.java    |    2 +
 ortools/sat/samples/LiteralSampleSat.cs       |    2 +
 ortools/sat/samples/LiteralSampleSat.java     |    2 +
 ortools/sat/samples/NoOverlapSampleSat.cs     |    2 +
 ortools/sat/samples/NoOverlapSampleSat.java   |    2 +
 .../sat/samples/OptionalIntervalSampleSat.cs  |    2 +
 .../samples/OptionalIntervalSampleSat.java    |    2 +
 ortools/sat/samples/RabbitsAndPheasantsSat.cs |    3 +
 .../sat/samples/RabbitsAndPheasantsSat.java   |    2 +
 ortools/sat/samples/RankingSampleSat.cs       |    2 +
 ortools/sat/samples/RankingSampleSat.java     |    2 +
 ortools/sat/samples/ReifiedSampleSat.cs       |    2 +
 ortools/sat/samples/ReifiedSampleSat.java     |    2 +
 ortools/sat/samples/StepFunctionSampleSat.cs  |    2 +
 .../sat/samples/StepFunctionSampleSat.java    |    2 +
 .../all_different_except_zero_sample_sat.py   |    2 +
 ortools/sat/samples/binpacking_problem_sat.cc |    2 +
 ortools/sat/samples/binpacking_problem_sat.go |    3 +
 ortools/sat/samples/binpacking_problem_sat.py |    2 +
 .../bool_and_int_var_product_sample_sat.py    |    2 +
 ortools/sat/samples/bool_or_sample_sat.cc     |    2 +
 ortools/sat/samples/bool_or_sample_sat.go     |    3 +
 ortools/sat/samples/bool_or_sample_sat.py     |    2 +
 .../sat/samples/boolean_product_sample_sat.go |    3 +
 .../sat/samples/boolean_product_sample_sat.py |    2 +
 ortools/sat/samples/channeling_sample_sat.cc  |    2 +
 ortools/sat/samples/channeling_sample_sat.go  |    3 +
 ortools/sat/samples/channeling_sample_sat.py  |    2 +
 ortools/sat/samples/code_samples.bzl          |    4 -
 .../cumulative_variable_profile_sample_sat.py |    2 +
 .../earliness_tardiness_cost_sample_sat.cc    |    2 +
 .../earliness_tardiness_cost_sample_sat.go    |    3 +
 .../earliness_tardiness_cost_sample_sat.py    |    2 +
 .../index_first_boolvar_true_sample_sat.py    |    2 +
 .../samples/interval_relations_sample_sat.py  |    2 +
 ortools/sat/samples/interval_sample_sat.cc    |    2 +
 ortools/sat/samples/interval_sample_sat.go    |    3 +
 ortools/sat/samples/interval_sample_sat.py    |    2 +
 ortools/sat/samples/literal_sample_sat.cc     |    2 +
 ortools/sat/samples/literal_sample_sat.go     |    3 +
 ortools/sat/samples/literal_sample_sat.py     |    2 +
 ortools/sat/samples/no_overlap_sample_sat.cc  |    2 +
 ortools/sat/samples/no_overlap_sample_sat.go  |    3 +
 ortools/sat/samples/no_overlap_sample_sat.py  |    2 +
 .../samples/optional_interval_sample_sat.cc   |    2 +
 .../samples/optional_interval_sample_sat.go   |    3 +
 .../samples/optional_interval_sample_sat.py   |    2 +
 .../overlapping_intervals_sample_sat.py       |    2 +
 .../sat/samples/rabbits_and_pheasants_sat.cc  |    2 +
 .../sat/samples/rabbits_and_pheasants_sat.go  |    3 +
 .../sat/samples/rabbits_and_pheasants_sat.py  |    2 +
 .../sat/samples/ranking_circuit_sample_sat.py |    2 +
 ortools/sat/samples/ranking_sample_sat.cc     |    2 +
 ortools/sat/samples/ranking_sample_sat.go     |    3 +
 ortools/sat/samples/ranking_sample_sat.py     |    2 +
 ortools/sat/samples/reified_sample_sat.cc     |    2 +
 ortools/sat/samples/reified_sample_sat.go     |    3 +
 ortools/sat/samples/reified_sample_sat.py     |    2 +
 .../scheduling_with_calendar_sample_sat.py    |    2 +
 .../search_for_all_solutions_sample_sat.go    |    3 +
 .../sequences_in_no_overlap_sample_sat.py     |    2 +
 ortools/sat/samples/simple_sat_program.go     |    3 +
 .../samples/solution_hinting_sample_sat.go    |    3 +
 ...print_intermediate_solutions_sample_sat.go |    3 +
 .../solve_with_time_limit_sample_sat.go       |    3 +
 .../sat/samples/step_function_sample_sat.cc   |    2 +
 .../sat/samples/step_function_sample_sat.go   |    3 +
 .../sat/samples/step_function_sample_sat.py   |    2 +
 .../transitions_in_no_overlap_sample_sat.py   |    2 +
 ortools/sat/sat_parameters.proto              |   24 +-
 ortools/sat/sat_solver.cc                     |    5 +-
 ortools/sat/sat_solver.h                      |    2 +
 ortools/sat/scheduling_cuts_test.cc           |   51 +-
 ortools/sat/scheduling_helpers.cc             |  189 +-
 ortools/sat/scheduling_helpers.h              |  144 +-
 ortools/sat/scheduling_helpers_test.cc        |   20 +-
 ortools/sat/solution_crush.cc                 |    7 +
 ortools/sat/stat_tables.cc                    |    8 +-
 ortools/sat/synchronization.h                 |   19 +-
 ortools/sat/table_test.cc                     |   17 -
 ortools/sat/timetable.cc                      |  123 +-
 ortools/sat/timetable.h                       |   24 +-
 ortools/sat/timetable_edgefinding.cc          |    5 +-
 ortools/sat/timetable_test.cc                 |   44 +-
 ortools/sat/util.cc                           |   40 +-
 ortools/sat/util.h                            |    7 +-
 ortools/sat/util_test.cc                      |   73 +-
 ortools/scheduling/python/BUILD.bazel         |    1 -
 ortools/service/v1/BUILD.bazel                |    1 +
 ortools/set_cover/BUILD.bazel                 |    1 +
 ortools/set_cover/python/BUILD.bazel          |    1 -
 ortools/third_party_solvers/BUILD.bazel       |   19 +-
 .../third_party_solvers/xpress_environment.cc |    2 +-
 ortools/util/BUILD.bazel                      |   32 +-
 ortools/util/java/BUILD.bazel                 |   65 +-
 ortools/util/proto_tools.cc                   |    3 +
 ortools/util/proto_tools.h                    |   54 +-
 ortools/util/python/BUILD.bazel               |    4 +-
 ortools/util/python/py_solve_interrupter.cc   |    6 +-
 ortools/util/sigint.cc                        |    5 +
 ortools/util/sigint.h                         |    6 +
 ortools/util/solve_interrupter.cc             |    8 +-
 ortools/util/time_limit.h                     |   14 +-
 patches/BUILD.bazel                           |    5 -
 patches/abseil-cpp-20250512.0.patch           |   20 -
 patches/abseil-cpp-20250814.0.patch           |  125 +
 ...-02-14.patch => fuzztest-2025-08-05.patch} |  141 +-
 ...tobuf-v31.1.patch => protobuf-v32.0.patch} |    0
 tools/doc/doxygen_filter.py                   |    2 +-
 373 files changed, 30302 insertions(+), 6458 deletions(-)
 create mode 100644 cmake/ccache.cmake
 delete mode 100644 ortools/base/case.cc
 delete mode 100644 ortools/base/case.h
 create mode 100644 ortools/base/protocol-buffer-matchers.cc
 delete mode 100644 ortools/base/small_map.h
 delete mode 100644 ortools/base/stl_logging.h
 create mode 100644 ortools/flatzinc/mznlib/fzn_all_different_set.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_all_disjoint.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_all_equal_int.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_all_equal_set.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_arg_max_bool.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_arg_max_int.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_arg_min_bool.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_arg_min_int.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_disjoint.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_global_cardinality.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_global_cardinality_closed.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_global_cardinality_low_up.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_global_cardinality_low_up_closed.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_lex_less_bool.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_lex_less_int.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_lex_lesseq_bool.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_lex_lesseq_int.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_partition_set.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_seq_precede_chain_int.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_value_precede_chain_int.mzn
 create mode 100644 ortools/flatzinc/mznlib/fzn_value_precede_int.mzn
 delete mode 100644 ortools/graph/line_graph.h
 delete mode 100644 ortools/graph/line_graph_test.cc
 create mode 100644 ortools/math_opt/cpp/callback_test.cc
 create mode 100644 ortools/math_opt/cpp/compute_infeasible_subsystem_result_test.cc
 create mode 100644 ortools/math_opt/cpp/enums_test.cc
 rename ortools/{base/ptr_util.h => math_opt/cpp/enums_test.proto} (66%)
 create mode 100644 ortools/math_opt/cpp/formatters_test.cc
 create mode 100644 ortools/math_opt/cpp/key_types_test.cc
 create mode 100644 ortools/math_opt/cpp/linear_constraint_test.cc
 create mode 100644 ortools/math_opt/cpp/map_filter_test.cc
 create mode 100644 ortools/math_opt/cpp/matchers_test.cc
 create mode 100644 ortools/math_opt/cpp/message_callback_test.cc
 create mode 100644 ortools/math_opt/cpp/model_solve_parameters_test.cc
 create mode 100644 ortools/math_opt/cpp/objective_test.cc
 create mode 100644 ortools/math_opt/cpp/parameters_test.cc
 create mode 100644 ortools/math_opt/cpp/solution_test.cc
 create mode 100644 ortools/math_opt/cpp/solve_arguments_test.cc
 create mode 100644 ortools/math_opt/cpp/solve_impl_test.cc
 create mode 100644 ortools/math_opt/cpp/solve_result_test.cc
 create mode 100644 ortools/math_opt/cpp/solve_test.cc
 create mode 100644 ortools/math_opt/cpp/solver_resources_test.cc
 create mode 100644 ortools/math_opt/cpp/statistics_test.cc
 create mode 100644 ortools/math_opt/cpp/streamable_solver_init_arguments_test.cc
 create mode 100644 ortools/math_opt/cpp/variable_and_expressions_nc_test.cc
 create mode 100644 ortools/math_opt/cpp/variable_and_expressions_test.cc
 create mode 100644 ortools/math_opt/samples/cpp/coil_in_the_box.cc
 delete mode 100644 ortools/pdlp/gtest_main.cc
 create mode 100644 ortools/port/os.h
 create mode 100644 ortools/sat/container.h
 create mode 100644 ortools/sat/container_test.cc
 create mode 100644 ortools/sat/enforcement.cc
 create mode 100644 ortools/sat/enforcement.h
 create mode 100644 ortools/sat/enforcement_helper.cc
 create mode 100644 ortools/sat/enforcement_helper.h
 create mode 100644 ortools/sat/enforcement_test.cc
 delete mode 100644 patches/abseil-cpp-20250512.0.patch
 create mode 100644 patches/abseil-cpp-20250814.0.patch
 rename patches/{fuzztest-2025-02-14.patch => fuzztest-2025-08-05.patch} (57%)
 rename patches/{protobuf-v31.1.patch => protobuf-v32.0.patch} (100%)

diff --git a/.dockerignore b/.dockerignore
index 87ec80e5e9..db7c918e2e 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -32,7 +32,6 @@ makefiles/docker
 makefiles/Makefile
 Makefile.local
 
-binder
 docs
 tools/docker
 tools/release
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7d3b443efd..0f30547c7d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -90,6 +90,9 @@ if(MSVC AND BUILD_SHARED_LIBS)
   set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 endif()
 
+# Enable CCache if any
+include(ccache)
+
 # Disable CTest targets
 set_property(GLOBAL PROPERTY CTEST_TARGETS_ADDED 1)
 include(CTest)
@@ -198,7 +201,7 @@ if(BUILD_TESTING)
   CMAKE_DEPENDENT_OPTION(BUILD_benchmark "Build benchmark" OFF
     "NOT BUILD_DEPS" ON)
   # Fuzztest do not support MSVC or toolchain
-  if(MSVC OR CMAKE_CROSSCOMPILING)
+  if(APPLE OR MSVC OR CMAKE_CROSSCOMPILING)
     set(USE_fuzztest OFF)
   else()
     # since no distro provide a fuzztest package disable support by default.
diff --git a/Dependencies.txt b/Dependencies.txt
index 5d072a8acb..c4fa4626ed 100644
--- a/Dependencies.txt
+++ b/Dependencies.txt
@@ -1,6 +1,6 @@
 ZLIB=1.3.1
-abseil-cpp=20250512.0
-Protobuf=v31.1
+abseil-cpp=20250814.0
+Protobuf=v32.0
 Eigen=3.4.0
 Re2=2024-07-02
 CoinUtils=2.11.12
diff --git a/MODULE.bazel b/MODULE.bazel
index 28d7579aa7..f3112f60c1 100644
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -41,17 +41,17 @@ bazel_dep(name = "rules_python", version = "1.5.1")
 
 # OR-Tools C++ dependencies
 # keep sorted go/buildifier#keep-sorted
-bazel_dep(name = "abseil-cpp", version = "20250512.0")
+bazel_dep(name = "abseil-cpp", version = "20250814.0")
 bazel_dep(name = "bzip2", version = "1.0.8.bcr.2")
 bazel_dep(name = "eigen", version = "3.4.0.bcr.3")
-bazel_dep(name = "fuzztest", version = "20250214.0")
+bazel_dep(name = "fuzztest", version = "20250805.0")
 bazel_dep(name = "riegeli", version = "0.0.0-20241218-3385e3c")  # otherwise fuzztest use a borken version
 bazel_dep(name = "glpk", version = "5.0.bcr.4")
 bazel_dep(name = "google_benchmark", version = "1.9.2")
 bazel_dep(name = "googletest", version = "1.17.0")
 bazel_dep(name = "highs", version = "1.11.0")
-bazel_dep(name = "protobuf", version = "31.1")
-bazel_dep(name = "re2", version = "2024-07-02.bcr.1")
+bazel_dep(name = "protobuf", version = "32.0")
+bazel_dep(name = "re2", version = "2025-08-12")
 bazel_dep(name = "scip", version = "9.2.2")
 bazel_dep(name = "zlib", version = "1.3.1.bcr.5")
 
diff --git a/bazel/notebook_requirements.in b/bazel/notebook_requirements.in
index c2d02e6fcb..d1c56d4459 100644
--- a/bazel/notebook_requirements.in
+++ b/bazel/notebook_requirements.in
@@ -2,7 +2,7 @@
 absl-py==2.2.2
 immutabledict==4.2.1
 numpy==2.2.0
-protobuf==6.31.1
+protobuf==6.32.0
 requests==2.32.4
 scipy==1.14.1
 typing-extensions==4.13.1
diff --git a/bazel/notebook_requirements.txt b/bazel/notebook_requirements.txt
index 51e2da3358..4f44c1c124 100644
--- a/bazel/notebook_requirements.txt
+++ b/bazel/notebook_requirements.txt
@@ -215,7 +215,7 @@ prometheus-client==0.22.1
     # via jupyter-server
 prompt-toolkit==3.0.51
     # via ipython
-protobuf==6.31.1
+protobuf==6.32.0
     # via
     #   -r bazel/notebook_requirements.in
     #   mypy-protobuf
diff --git a/bazel/ortools_requirements.in b/bazel/ortools_requirements.in
index e893a8b629..115af98e15 100644
--- a/bazel/ortools_requirements.in
+++ b/bazel/ortools_requirements.in
@@ -2,7 +2,7 @@
 absl-py==2.2.2
 immutabledict==4.2.1
 numpy==2.2.0
-protobuf==6.31.1
+protobuf==6.32.0
 requests==2.32.4
 scipy==1.14.1
 typing-extensions==4.13.1
diff --git a/bazel/ortools_requirements.txt b/bazel/ortools_requirements.txt
index 3232c1e420..e11a30013e 100644
--- a/bazel/ortools_requirements.txt
+++ b/bazel/ortools_requirements.txt
@@ -45,7 +45,7 @@ platformdirs==4.3.8
     # via
     #   black
     #   virtualenv
-protobuf==6.31.1
+protobuf==6.32.0
     # via
     #   -r bazel/ortools_requirements.in
     #   mypy-protobuf
diff --git a/bazel/swig_java.bzl b/bazel/swig_java.bzl
index 17439585e3..e320982c81 100644
--- a/bazel/swig_java.bzl
+++ b/bazel/swig_java.bzl
@@ -15,6 +15,7 @@
 
 load("@bazel_skylib//lib:paths.bzl", "paths")
 load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
 load("@rules_java//java:java_library.bzl", "java_library")
 load("@rules_java//java/common:java_common.bzl", "java_common")
 
@@ -33,7 +34,9 @@ def _create_src_jar(ctx, java_runtime_info, input_dir, output_jar):
     )
 
 def _java_wrap_cc_impl(ctx):
-    src = ctx.file.src
+    if len(ctx.files.srcs) != 1:
+        fail("There must be exactly one *.swig file", attr = "srcs")
+    swig_src = ctx.files.srcs[0]
     outfile = ctx.outputs.outfile
     outhdr = ctx.outputs.outhdr
 
@@ -65,7 +68,7 @@ def _java_wrap_cc_impl(ctx):
         swig_args.add("-module", ctx.attr.module)
     for include_path in depset(transitive = include_path_sets).to_list():
         swig_args.add("-I" + include_path)
-    swig_args.add(src.path)
+    swig_args.add(swig_src.path)
     generated_c_files = [outfile]
     if ctx.attr.use_directors:
         generated_c_files.append(outhdr)
@@ -74,7 +77,7 @@ def _java_wrap_cc_impl(ctx):
     swig_lib = {"SWIG_LIB": paths.dirname(ctx.files._swig_lib[0].path)}
     ctx.actions.run(
         outputs = generated_c_files + [java_files_dir],
-        inputs = depset([src] + ctx.files.swig_includes + ctx.files._swig_lib, transitive = header_sets),
+        inputs = depset([swig_src] + ctx.files.swig_includes + ctx.files._swig_lib, transitive = header_sets),
         env = swig_lib,
         executable = ctx.executable._swig,
         arguments = [swig_args],
@@ -92,10 +95,13 @@ It's expected that the `swig` binary exists in the host's path.
 """,
     implementation = _java_wrap_cc_impl,
     attrs = {
-        "src": attr.label(
-            doc = "Single swig source file.",
-            allow_single_file = True,
-            mandatory = True,
+        "srcs": attr.label_list(
+            allow_empty = False,
+            allow_files = [".swig", ".i"],
+            flags = ["DIRECT_COMPILE_TIME_INPUT", "ORDER_INDEPENDENT"],
+            doc = """
+A list of one <code>swig</code> source.
+            """,
         ),
         "deps": attr.label_list(
             doc = "C++ dependencies.",
@@ -141,9 +147,9 @@ It's expected that the `swig` binary exists in the host's path.
     },
 )
 
-def ortools_java_wrap_cc(
+def java_wrap_cc(
         name,
-        src,
+        srcs,
         package,
         deps = [],
         java_deps = [],
@@ -159,7 +165,7 @@ def ortools_java_wrap_cc(
 
     Args:
         name: target name.
-        src: single .i source file.
+        srcs: A list of one <code>swig</code> source.
         package: package of generated Java files.
         deps: C++ deps.
         java_deps: Java deps.
@@ -183,7 +189,7 @@ def ortools_java_wrap_cc(
 
     _java_wrap_cc(
         name = wrapper_name,
-        src = src,
+        srcs = srcs,
         package = package,
         outfile = outfile,
         outhdr = outhdr if use_directors else None,
diff --git a/cmake/README.md b/cmake/README.md
index ff84170a29..ea95808966 100644
--- a/cmake/README.md
+++ b/cmake/README.md
@@ -51,17 +51,6 @@ Dockers:
 [docker_svg]: ./../../../actions/workflows/amd64_docker_cmake.yml/badge.svg?branch=main
 [docker_link]: ./../../../actions/workflows/amd64_docker_cmake.yml
 
-[![Build Status][aarch64_toolchain_status]][aarch64_toolchain_link]
-[![Build Status][mips_toolchain_status]][mips_toolchain_link]
-[![Build Status][powerpc_toolchain_status]][powerpc_toolchain_link]
-
-[aarch64_toolchain_status]: ./../../../actions/workflows/aarch64_toolchain.yml/badge.svg?branch=main
-[aarch64_toolchain_link]: ./../../../actions/workflows/aarch64_toolchain.yml
-[mips_toolchain_status]: ./../../../actions/workflows/mips_toolchain.yml/badge.svg?branch=main
-[mips_toolchain_link]: ./../../../actions/workflows/mips_toolchain.yml
-[powerpc_toolchain_status]: ./../../../actions/workflows/powerpc_toolchain.yml/badge.svg?branch=main
-[powerpc_toolchain_link]: ./../../../actions/workflows/powerpc_toolchain.yml
-
 ## Introduction
 <nav for="cmake"> |
 <a href="#requirement">Requirement</a> |
diff --git a/cmake/ccache.cmake b/cmake/ccache.cmake
new file mode 100644
index 0000000000..b55849f713
--- /dev/null
+++ b/cmake/ccache.cmake
@@ -0,0 +1,67 @@
+# Copyright 2010-2025 Google LLC
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(NOT UNIX)
+ return()
+endif()
+
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+    # Set up wrapper scripts
+    set(C_LAUNCHER   "${CCACHE_PROGRAM}")
+    set(CXX_LAUNCHER "${CCACHE_PROGRAM}")
+
+    file(WRITE "${CMAKE_BINARY_DIR}/launch-c"
+      "#!/usr/bin/env sh\n"
+      "# Xcode generator doesn't include the compiler as the\n"
+      "# first argument, Ninja and Makefiles do. Handle both cases.\n"
+      "if [ \"$1\" = \"${CMAKE_C_COMPILER}\" ]; then\n"
+      "  shift\n"
+      "fi\n"
+      "export CCACHE_CPP2=true\n"
+      "exec \"${C_LAUNCHER}\" \"${CMAKE_C_COMPILER}\" \"$@\"\n"
+    )
+    file(WRITE "${CMAKE_BINARY_DIR}/launch-cxx"
+      "#!/usr/bin/env sh\n"
+      "# Xcode generator doesn't include the compiler as the\n"
+      "# first argument, Ninja and Makefiles do. Handle both cases.\n"
+      "if [ \"$1\" = \"${CMAKE_CXX_COMPILER}\" ]; then\n"
+      "  shift\n"
+      "fi\n"
+      "export CCACHE_CPP2=true\n"
+      "exec \"${CXX_LAUNCHER}\" \"${CMAKE_CXX_COMPILER}\" \"$@\"\n"
+    )
+    file(CHMOD
+      "${CMAKE_BINARY_DIR}/launch-c"
+      "${CMAKE_BINARY_DIR}/launch-cxx"
+      FILE_PERMISSIONS
+        OWNER_READ OWNER_EXECUTE
+        GROUP_READ GROUP_EXECUTE
+        WORLD_READ WORLD_EXECUTE)
+
+    if(CMAKE_GENERATOR STREQUAL "Xcode")
+        # Set Xcode project attributes to route compilation and linking
+        # through our scripts
+        set(CMAKE_XCODE_ATTRIBUTE_CC         "${CMAKE_BINARY_DIR}/launch-c")
+        set(CMAKE_XCODE_ATTRIBUTE_CXX        "${CMAKE_BINARY_DIR}/launch-cxx")
+        set(CMAKE_XCODE_ATTRIBUTE_LD         "${CMAKE_BINARY_DIR}/launch-c")
+        set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_BINARY_DIR}/launch-cxx")
+    else()
+        # Support Unix Makefiles and Ninja
+        set(CMAKE_C_COMPILER_LAUNCHER   "${CMAKE_BINARY_DIR}/launch-c")
+        set(CMAKE_CXX_COMPILER_LAUNCHER "${CMAKE_BINARY_DIR}/launch-cxx")
+    endif()
+    message(STATUS "CCache enabled")
+else()
+  message(WARNING "CCache disabled")
+endif()
diff --git a/cmake/cpp.cmake b/cmake/cpp.cmake
index f1cd328287..00055926f8 100644
--- a/cmake/cpp.cmake
+++ b/cmake/cpp.cmake
@@ -196,6 +196,7 @@ function(ortools_cxx_test)
   target_compile_options(${TEST_NAME} PRIVATE ${TEST_COMPILE_OPTIONS})
   target_link_libraries(${TEST_NAME} PRIVATE
     ${PROJECT_NAMESPACE}::ortools
+    ${PROJECT_NAMESPACE}::base_gmock
     ${TEST_LINK_LIBRARIES}
   )
   target_link_options(${TEST_NAME} PRIVATE ${TEST_LINK_OPTIONS})
diff --git a/cmake/dependencies/CMakeLists.txt b/cmake/dependencies/CMakeLists.txt
index 2efbe88c33..43739ba387 100644
--- a/cmake/dependencies/CMakeLists.txt
+++ b/cmake/dependencies/CMakeLists.txt
@@ -69,8 +69,10 @@ if(BUILD_ZLIB)
     GIT_REPOSITORY "https://github.com/madler/ZLIB.git"
     GIT_TAG "v1.3.1"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
-    "${CMAKE_CURRENT_LIST_DIR}/../../patches/ZLIB-v1.3.1.patch")
+    "${CMAKE_CURRENT_LIST_DIR}/../../patches/ZLIB-v1.3.1.patch"
+  )
   FetchContent_MakeAvailable(ZLIB)
   list(POP_BACK CMAKE_MESSAGE_INDENT)
   message(CHECK_PASS "fetched")
@@ -90,6 +92,7 @@ if(BUILD_BZip2)
     GIT_TAG "master"
     # GIT_TAG "bzip2-1.0.8" # CMake support not available
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/bzip2.patch"
   )
@@ -114,10 +117,11 @@ if(BUILD_absl)
   FetchContent_Declare(
     absl
     GIT_REPOSITORY "https://github.com/abseil/abseil-cpp.git"
-    GIT_TAG "20250512.0"
+    GIT_TAG "20250814.0"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
-    "${CMAKE_CURRENT_LIST_DIR}/../../patches/abseil-cpp-20250512.0.patch"
+    "${CMAKE_CURRENT_LIST_DIR}/../../patches/abseil-cpp-20250814.0.patch"
     OVERRIDE_FIND_PACKAGE
   )
   FetchContent_MakeAvailable(absl)
@@ -139,11 +143,12 @@ if(BUILD_Protobuf)
   FetchContent_Declare(
     Protobuf
     GIT_REPOSITORY "https://github.com/protocolbuffers/protobuf.git"
-    GIT_TAG "v31.1"
+    GIT_TAG "v32.0"
     GIT_SHALLOW TRUE
     GIT_SUBMODULES ""
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
-    "${CMAKE_CURRENT_LIST_DIR}/../../patches/protobuf-v31.1.patch"
+    "${CMAKE_CURRENT_LIST_DIR}/../../patches/protobuf-v32.0.patch"
   )
   FetchContent_MakeAvailable(Protobuf)
   list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -162,7 +167,9 @@ if(BUILD_re2)
     GIT_REPOSITORY "https://github.com/google/re2.git"
     GIT_TAG "2024-07-02"
     GIT_SHALLOW TRUE
-    PATCH_COMMAND git apply --ignore-whitespace "${CMAKE_CURRENT_LIST_DIR}/../../patches/re2-2024-07-02.patch"
+    UPDATE_COMMAND git reset --hard
+    PATCH_COMMAND git apply --ignore-whitespace
+    "${CMAKE_CURRENT_LIST_DIR}/../../patches/re2-2024-07-02.patch"
   )
   FetchContent_MakeAvailable(re2)
   list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -184,7 +191,9 @@ if(BUILD_Eigen3)
     GIT_REPOSITORY "https://gitlab.com/libeigen/eigen.git"
     GIT_TAG "3.4.0"
     GIT_SHALLOW TRUE
-    PATCH_COMMAND git apply --ignore-whitespace "${CMAKE_CURRENT_LIST_DIR}/../../patches/eigen3-3.4.0.patch"
+    UPDATE_COMMAND git reset --hard
+    PATCH_COMMAND git apply --ignore-whitespace
+    "${CMAKE_CURRENT_LIST_DIR}/../../patches/eigen3-3.4.0.patch"
   )
   FetchContent_MakeAvailable(eigen3)
   list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -216,6 +225,7 @@ if(BUILD_PYTHON)
       #GIT_TAG "bd5951b6" # 2024/08/14 TEST FAIL
       GIT_TAG "v2.13.6" # TEST PASS with a1d00916 patch apply
       #GIT_SHALLOW TRUE
+      UPDATE_COMMAND git reset --hard
       PATCH_COMMAND git apply --ignore-whitespace
       "${CMAKE_CURRENT_LIST_DIR}/../../patches/pybind11-v2.13.6.patch"
     )
@@ -232,7 +242,9 @@ if(BUILD_PYTHON)
       GIT_REPOSITORY "https://github.com/pybind/pybind11_abseil.git" # 2024/01/11
       GIT_TAG "v202402.0"
       GIT_SHALLOW TRUE
-      PATCH_COMMAND git apply --ignore-whitespace "${CMAKE_CURRENT_LIST_DIR}/../../patches/pybind11_abseil.patch"
+      UPDATE_COMMAND git reset --hard
+      PATCH_COMMAND git apply --ignore-whitespace
+      "${CMAKE_CURRENT_LIST_DIR}/../../patches/pybind11_abseil.patch"
     )
     FetchContent_MakeAvailable(pybind11_abseil)
     list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -246,8 +258,10 @@ if(BUILD_PYTHON)
       pybind11_protobuf
       GIT_REPOSITORY "https://github.com/pybind/pybind11_protobuf.git"
       GIT_TAG "f02a2b7653bc50eb5119d125842a3870db95d251" # 2025/02/10
-      #PATCH_COMMAND git apply --ignore-whitespace "${CMAKE_CURRENT_LIST_DIR}/../../patches/pybind11_protobuf.patch"
       #GIT_SHALLOW TRUE
+      #UPDATE_COMMAND git reset --hard
+      #PATCH_COMMAND git apply --ignore-whitespace
+      #"${CMAKE_CURRENT_LIST_DIR}/../../patches/pybind11_protobuf.patch"
     )
     FetchContent_MakeAvailable(pybind11_protobuf)
     list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -290,6 +304,7 @@ if(BUILD_HIGHS)
     GIT_REPOSITORY "https://github.com/ERGO-Code/HiGHS.git"
     GIT_TAG        "v1.11.0"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/highs-v1.11.0.patch"
   )
@@ -310,7 +325,9 @@ if(BUILD_Boost)
     GIT_TAG "boost-1.87.0"
     GIT_SHALLOW TRUE
     GIT_SUBMODULES_RECURSE TRUE
-    PATCH_COMMAND git apply --ignore-whitespace "${CMAKE_CURRENT_LIST_DIR}/../../patches/boost-1.87.0.patch"
+    UPDATE_COMMAND git reset --hard --recurse-submodules
+    PATCH_COMMAND git apply --ignore-whitespace
+    "${CMAKE_CURRENT_LIST_DIR}/../../patches/boost-1.87.0.patch"
   )
   set(BOOST_INCLUDE_LIBRARIES multiprecision serialization)
   option(BOOST_SKIP_INSTALL_RULES NO)
@@ -333,6 +350,7 @@ if(BUILD_soplex)
     GIT_REPOSITORY "https://github.com/scipopt/soplex.git"
     GIT_TAG        "release-713"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/soplex-v7.1.3.patch"
   )
@@ -362,6 +380,7 @@ if(BUILD_SCIP)
     GIT_REPOSITORY "https://github.com/scipopt/scip.git"
     GIT_TAG        "v922"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/scip-v922.patch"
   )
@@ -399,6 +418,7 @@ if(BUILD_CoinUtils)
     GIT_REPOSITORY "https://github.com/Mizux/CoinUtils.git"
     GIT_TAG "cmake/2.11.12"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/coinutils-2.11.patch")
   FetchContent_MakeAvailable(CoinUtils)
@@ -417,6 +437,7 @@ if(BUILD_Osi)
     GIT_REPOSITORY "https://github.com/Mizux/Osi.git"
     GIT_TAG "cmake/0.108.11"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/osi-0.108.patch")
   FetchContent_MakeAvailable(Osi)
@@ -435,6 +456,7 @@ if(BUILD_Clp)
     GIT_REPOSITORY "https://github.com/Mizux/Clp.git"
     GIT_TAG "cmake/1.17.10"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/clp-1.17.patch")
   FetchContent_MakeAvailable(Clp)
@@ -453,6 +475,7 @@ if(BUILD_Cgl)
     GIT_REPOSITORY "https://github.com/Mizux/Cgl.git"
     GIT_TAG "cmake/0.60.9"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/cgl-0.60.patch")
   FetchContent_MakeAvailable(Cgl)
@@ -471,6 +494,7 @@ if(BUILD_Cbc)
     GIT_REPOSITORY "https://github.com/Mizux/Cbc.git"
     GIT_TAG "cmake/2.10.12"
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/cbc-2.10.patch")
   FetchContent_MakeAvailable(Cbc)
@@ -498,6 +522,7 @@ if(BUILD_googletest)
     GIT_REPOSITORY https://github.com/google/googletest.git
     GIT_TAG v1.17.0
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
     "${CMAKE_CURRENT_LIST_DIR}/../../patches/googletest-v1.17.0.patch"
   )
@@ -533,10 +558,11 @@ if(BUILD_fuzztest)
   FetchContent_Declare(
     fuzztest
     GIT_REPOSITORY https://github.com/google/fuzztest.git
-    GIT_TAG 2025-02-14
+    GIT_TAG 2025-08-05
     GIT_SHALLOW TRUE
+    UPDATE_COMMAND git reset --hard
     PATCH_COMMAND git apply --ignore-whitespace
-    "${CMAKE_CURRENT_LIST_DIR}/../../patches/fuzztest-2025-02-14.patch"
+    "${CMAKE_CURRENT_LIST_DIR}/../../patches/fuzztest-2025-08-05.patch"
   )
   FetchContent_MakeAvailable(fuzztest)
   list(POP_BACK CMAKE_MESSAGE_INDENT)
diff --git a/cmake/glop.cmake b/cmake/glop.cmake
index f420a3375d..03bb2a088d 100644
--- a/cmake/glop.cmake
+++ b/cmake/glop.cmake
@@ -82,8 +82,6 @@ target_sources(glop PRIVATE
   ortools/base/accurate_sum.h
   ortools/base/base_export.h
   ortools/base/basictypes.h
-  ortools/base/case.cc
-  ortools/base/case.h
   ortools/base/commandlineflags.h
   ortools/base/file.cc
   ortools/base/file.h
diff --git a/cmake/host.CMakeLists.txt b/cmake/host.CMakeLists.txt
index 6b63f17257..21b114bcfb 100644
--- a/cmake/host.CMakeLists.txt
+++ b/cmake/host.CMakeLists.txt
@@ -106,10 +106,10 @@ set(ABSL_BUILD_TESTING OFF)
 FetchContent_Declare(
   absl
   GIT_REPOSITORY "https://github.com/abseil/abseil-cpp.git"
-  GIT_TAG "20250512.0"
+  GIT_TAG "20250814.0"
   GIT_SHALLOW TRUE
   PATCH_COMMAND git apply --ignore-whitespace
-  "${CMAKE_CURRENT_LIST_DIR}/@PATCHES_PATH@/abseil-cpp-20250512.0.patch"
+  "${CMAKE_CURRENT_LIST_DIR}/@PATCHES_PATH@/abseil-cpp-20250814.0.patch"
 )
 FetchContent_MakeAvailable(absl)
 list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -125,11 +125,11 @@ set(protobuf_WITH_ZLIB OFF)
 FetchContent_Declare(
   protobuf
   GIT_REPOSITORY "https://github.com/protocolbuffers/protobuf.git"
-  GIT_TAG "v31.1"
+  GIT_TAG "v32.0"
   GIT_SHALLOW TRUE
   GIT_SUBMODULES ""
   PATCH_COMMAND git apply --ignore-whitespace
-  "${CMAKE_CURRENT_LIST_DIR}/@PATCHES_PATH@/protobuf-v31.1.patch"
+  "${CMAKE_CURRENT_LIST_DIR}/@PATCHES_PATH@/protobuf-v32.0.patch"
 )
 FetchContent_MakeAvailable(protobuf)
 list(POP_BACK CMAKE_MESSAGE_INDENT)
diff --git a/cmake/java.cmake b/cmake/java.cmake
index 32aa4ee551..a8152ac70c 100644
--- a/cmake/java.cmake
+++ b/cmake/java.cmake
@@ -363,6 +363,7 @@ add_custom_command(
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::int128>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::kernel_timeout_internal>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::leak_check>>
+    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_entry>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_flags>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_globals>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_initialize>>
@@ -378,7 +379,6 @@ add_custom_command(
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_proto>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_severity>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_sink>>
-    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::low_level_hash>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::malloc_internal>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_distributions>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_entropy_pool>>
diff --git a/cmake/python.cmake b/cmake/python.cmake
index 00248b6ef7..1d16501990 100644
--- a/cmake/python.cmake
+++ b/cmake/python.cmake
@@ -535,6 +535,7 @@ add_custom_command(
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::int128>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::kernel_timeout_internal>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::leak_check>>
+    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_entry>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_flags>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_globals>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_initialize>>
@@ -550,7 +551,6 @@ add_custom_command(
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_internal_proto>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_severity>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::log_sink>>
-    $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::low_level_hash>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::malloc_internal>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_distributions>>
     $<${need_unix_absl_lib}:$<TARGET_SONAME_FILE:absl::random_internal_entropy_pool>>
diff --git a/ortools/algorithms/BUILD.bazel b/ortools/algorithms/BUILD.bazel
index 6c1affd1f3..89721444fa 100644
--- a/ortools/algorithms/BUILD.bazel
+++ b/ortools/algorithms/BUILD.bazel
@@ -20,21 +20,6 @@ package(default_visibility = ["//visibility:public"])
 # Description:
 # Home of algorithms used in OR solvers
 
-config_setting(
-    name = "on_linux",
-    constraint_values = ["@platforms//os:linux"],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = ["@platforms//os:macos"],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = ["@platforms//os:windows"],
-)
-
 # OSS solvers
 bool_flag(
     name = "with_cbc",
@@ -110,9 +95,7 @@ cc_test(
     name = "radix_sort_test",
     srcs = ["radix_sort_test.cc"],
     copts = select({
-        "on_linux": [],
-        "on_macos": [],
-        "on_windows": ["/Zc:preprocessor"],
+        "@platforms//os:windows": ["/Zc:preprocessor"],
         "//conditions:default": [],
     }),
     deps = [
@@ -197,6 +180,7 @@ cc_test(
     size = "large",
     timeout = "eternal",
     srcs = ["adjustable_k_ary_heap_stress_test.cc"],
+    tags = ["manual"],
     deps = [
         ":adjustable_k_ary_heap",
         "//ortools/base:gmock_main",
@@ -427,22 +411,3 @@ cc_library(
         "@abseil-cpp//absl/time",
     ],
 )
-
-cc_test(
-    name = "n_choose_k_test",
-    srcs = ["n_choose_k_test.cc"],
-    deps = [
-        ":n_choose_k",
-        "//ortools/base:dump_vars",
-        "//ortools/base:fuzztest",
-        "//ortools/base:gmock_main",
-        "//ortools/base:mathutil",
-        "//ortools/util:flat_matrix",
-        "@abseil-cpp//absl/numeric:int128",
-        "@abseil-cpp//absl/random",
-        "@abseil-cpp//absl/random:distributions",
-        "@abseil-cpp//absl/status",
-        "@abseil-cpp//absl/status:statusor",
-        "@google_benchmark//:benchmark",
-    ],
-)
diff --git a/ortools/algorithms/java/BUILD.bazel b/ortools/algorithms/java/BUILD.bazel
index 5b84c09b2f..273c2e6302 100644
--- a/ortools/algorithms/java/BUILD.bazel
+++ b/ortools/algorithms/java/BUILD.bazel
@@ -13,16 +13,16 @@
 
 # Description: java wrapping of the C++ code at ../
 
-load("//bazel:swig_java.bzl", "ortools_java_wrap_cc")
+load("//bazel:swig_java.bzl", "java_wrap_cc")
 
-ortools_java_wrap_cc(
+java_wrap_cc(
     name = "knapsacksolver",
-    src = "knapsack_solver.swig",
+    srcs = ["knapsack_solver.swig"],
     module = "operations_research_algorithms",
     package = "com.google.ortools.algorithms",
     swig_includes = [
         "//ortools/base:base_swig",
-        "//ortools/util/java:vector_swig",
+        "//ortools/util/java:vector.swig",
     ],
     visibility = ["//visibility:public"],
     deps = [
diff --git a/ortools/algorithms/python/BUILD.bazel b/ortools/algorithms/python/BUILD.bazel
index 1d3ff6c81f..de7c3e4f72 100644
--- a/ortools/algorithms/python/BUILD.bazel
+++ b/ortools/algorithms/python/BUILD.bazel
@@ -72,7 +72,6 @@ pybind_extension(
 py_test(
     name = "knapsack_solver_test",
     srcs = ["knapsack_solver_test.py"],
-    python_version = "PY3",
     deps = [
         ":knapsack_solver",
         requirement("absl-py"),
diff --git a/ortools/algorithms/samples/code_samples.bzl b/ortools/algorithms/samples/code_samples.bzl
index 0fdece1ace..5d85abce64 100644
--- a/ortools/algorithms/samples/code_samples.bzl
+++ b/ortools/algorithms/samples/code_samples.bzl
@@ -49,8 +49,6 @@ def code_sample_py(name):
             requirement("absl-py"),
             requirement("numpy"),
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
     py_test(
@@ -63,8 +61,6 @@ def code_sample_py(name):
             requirement("absl-py"),
             requirement("numpy"),
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
 def code_sample_cc_py(name):
diff --git a/ortools/base/BUILD.bazel b/ortools/base/BUILD.bazel
index a9aca1680b..cbe9b33f84 100644
--- a/ortools/base/BUILD.bazel
+++ b/ortools/base/BUILD.bazel
@@ -16,21 +16,6 @@ load("@rules_cc//cc:cc_test.bzl", "cc_test")
 
 package(default_visibility = ["//visibility:public"])
 
-config_setting(
-    name = "on_linux",
-    constraint_values = ["@platforms//os:linux"],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = ["@platforms//os:macos"],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = ["@platforms//os:windows"],
-)
-
 filegroup(
     name = "base_swig",
     srcs = [
@@ -72,19 +57,16 @@ cc_library(
     hdrs = [
         "commandlineflags.h",
         "init_google.h",
-        "stl_logging.h",
         "types.h",
         "version.h",
     ],
     copts = [
         "-DOR_TOOLS_MAJOR=9",
-        "-DOR_TOOLS_MINOR=14",
+        "-DOR_TOOLS_MINOR=15",
         "-DOR_TOOLS_PATCH=9999",
     ],
     linkopts = select({
-        "on_linux": [],
-        "on_macos": ["-framework CoreFoundation"],
-        "on_windows": [],
+        "@platforms//os:macos": ["-framework CoreFoundation"],
         "//conditions:default": [],
     }),
     deps = [
@@ -125,13 +107,6 @@ cc_library(
     hdrs = ["bitmap.h"],
 )
 
-cc_library(
-    name = "case",
-    srcs = ["case.cc"],
-    hdrs = ["case.h"],
-    deps = [":base"],
-)
-
 cc_library(
     name = "commandlineflags",
     srcs = [
@@ -180,9 +155,7 @@ cc_library(
     name = "dump_vars",
     hdrs = ["dump_vars.h"],
     copts = select({
-        "on_linux": [],
-        "on_macos": [],
-        "on_windows": ["/Zc:preprocessor"],
+        "@platforms//os:windows": ["/Zc:preprocessor"],
         "//conditions:default": [],
     }),
     deps = [
@@ -197,9 +170,7 @@ cc_test(
     size = "small",
     srcs = ["dump_vars_test.cc"],
     copts = select({
-        "on_linux": [],
-        "on_macos": [],
-        "on_windows": ["/Zc:preprocessor"],
+        "@platforms//os:windows": ["/Zc:preprocessor"],
         "//conditions:default": [],
     }),
     deps = [
@@ -249,19 +220,6 @@ cc_library(
     ],
 )
 
-cc_library(
-    name = "fuzztest",
-    testonly = 1,
-    hdrs = ["fuzztest.h"],
-    deps = [
-        "@abseil-cpp//absl/log:check",
-        "@fuzztest//fuzztest",
-        "@fuzztest//fuzztest:googletest_fixture_adapter",
-        "@fuzztest//fuzztest:init_fuzztest",
-        "@protobuf",
-    ],
-)
-
 cc_library(
     name = "gmock",
     hdrs = ["gmock.h"],
@@ -305,15 +263,9 @@ cc_library(
 
 cc_library(
     name = "hash",
-    srcs = [
-        "hash.cc",
-    ],
-    hdrs = [
-        "hash.h",
-    ],
-    deps = [
-        "@abseil-cpp//absl/strings",
-    ],
+    srcs = ["hash.cc"],
+    hdrs = ["hash.h"],
+    deps = ["@abseil-cpp//absl/strings"],
 )
 
 cc_library(
@@ -470,6 +422,7 @@ cc_library(
 
 cc_library(
     name = "protocol-buffer-matchers",
+    srcs = ["protocol-buffer-matchers.cc"],
     hdrs = ["protocol-buffer-matchers.h"],
     deps = [
         "@abseil-cpp//absl/log:check",
@@ -499,11 +452,6 @@ cc_library(
     ],
 )
 
-cc_library(
-    name = "ptr_util",
-    hdrs = ["ptr_util.h"],
-)
-
 cc_library(
     name = "recordio",
     srcs = ["recordio.cc"],
@@ -519,12 +467,6 @@ cc_library(
     ],
 )
 
-cc_library(
-    name = "small_map",
-    hdrs = ["small_map.h"],
-    deps = [":base"],
-)
-
 cc_library(
     name = "source_location",
     hdrs = ["source_location.h"],
diff --git a/ortools/base/CMakeLists.txt b/ortools/base/CMakeLists.txt
index 61c3524d4f..3fb969f8b3 100644
--- a/ortools/base/CMakeLists.txt
+++ b/ortools/base/CMakeLists.txt
@@ -13,8 +13,9 @@
 
 file(GLOB _SRCS "*.h" "*.cc")
 list(FILTER _SRCS EXCLUDE REGEX "/.*_test.cc")
+list(FILTER _SRCS EXCLUDE REGEX "/gmock\.h")
 list(FILTER _SRCS EXCLUDE REGEX "/status-matchers\.h")
-list(FILTER _SRCS EXCLUDE REGEX "/protocol-buffer-matchers\.h")
+list(FILTER _SRCS EXCLUDE REGEX "/protocol-buffer-matchers\..*")
 
 set(NAME ${PROJECT_NAME}_base)
 
@@ -46,6 +47,25 @@ target_link_libraries(${NAME} PRIVATE
 #add_library(${PROJECT_NAMESPACE}::base ALIAS ${NAME})
 
 if(BUILD_TESTING)
+ortools_cxx_library(
+  NAME
+    base_gmock
+  SOURCES
+    "gmock.h"
+    "protocol-buffer-matchers.cc"
+    "protocol-buffer-matchers.h"
+    "status-matchers.h"
+  TYPE
+    STATIC
+  LINK_LIBRARIES
+    absl::log
+    absl::strings
+    GTest::gtest
+    GTest::gmock
+    protobuf::libprotobuf
+  TESTING
+)
+
   file(GLOB _TEST_SRCS "*_test.cc")
   foreach(_FULL_FILE_NAME IN LISTS _TEST_SRCS)
     get_filename_component(_NAME ${_FULL_FILE_NAME} NAME_WE)
@@ -57,9 +77,9 @@ if(BUILD_TESTING)
         ${_FILE_NAME}
       LINK_LIBRARIES
         benchmark::benchmark
+        base_gmock
         GTest::gtest
         GTest::gtest_main
-        GTest::gmock
     )
   endforeach()
 endif()
diff --git a/ortools/base/case.cc b/ortools/base/case.cc
deleted file mode 100644
index 82ac240d97..0000000000
--- a/ortools/base/case.cc
+++ /dev/null
@@ -1,129 +0,0 @@
-// Copyright 2010-2025 Google LLC
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This file contains string processing functions related to
-// uppercase, lowercase, etc.
-#include "ortools/base/case.h"
-
-#include <functional>
-#include <ostream>
-#include <string>
-
-#include "absl/hash/hash.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/match.h"
-#include "absl/strings/string_view.h"
-
-#ifdef _MSC_VER
-#define strncasecmp _strnicmp
-#define strcasecmp _stricmp
-#endif
-
-namespace strings {
-
-std::ostream& operator<<(std::ostream& os,
-                         const AsciiCapitalizationType& type) {
-  switch (type) {
-    case AsciiCapitalizationType::kLower:
-      return os << "kLower";
-    case AsciiCapitalizationType::kUpper:
-      return os << "kUpper";
-    case AsciiCapitalizationType::kFirst:
-      return os << "kFirst";
-    case AsciiCapitalizationType::kMixed:
-      return os << "kMixed";
-    case AsciiCapitalizationType::kNoAlpha:
-      return os << "kNoAlpha";
-    default:
-      return os << "INVALID";
-  }
-}
-
-AsciiCapitalizationType GetAsciiCapitalization(const absl::string_view input) {
-  const char* s = input.data();
-  const char* const end = s + input.size();
-  // find the caps type of the first alpha char
-  for (; s != end && !(absl::ascii_isupper(*s) || absl::ascii_islower(*s));
-       ++s) {
-  }
-  if (s == end) return AsciiCapitalizationType::kNoAlpha;
-  const AsciiCapitalizationType firstcapstype =
-      (absl::ascii_islower(*s)) ? AsciiCapitalizationType::kLower
-                                : AsciiCapitalizationType::kUpper;
-
-  // skip ahead to the next alpha char
-  for (++s; s != end && !(absl::ascii_isupper(*s) || absl::ascii_islower(*s));
-       ++s) {
-  }
-  if (s == end) return firstcapstype;
-  const AsciiCapitalizationType capstype =
-      (absl::ascii_islower(*s)) ? AsciiCapitalizationType::kLower
-                                : AsciiCapitalizationType::kUpper;
-
-  if (firstcapstype == AsciiCapitalizationType::kLower &&
-      capstype == AsciiCapitalizationType::kUpper)
-    return AsciiCapitalizationType::kMixed;
-
-  for (; s != end; ++s)
-    if ((absl::ascii_isupper(*s) &&
-         capstype != AsciiCapitalizationType::kUpper) ||
-        (absl::ascii_islower(*s) &&
-         capstype != AsciiCapitalizationType::kLower))
-      return AsciiCapitalizationType::kMixed;
-
-  if (firstcapstype == AsciiCapitalizationType::kUpper &&
-      capstype == AsciiCapitalizationType::kLower)
-    return AsciiCapitalizationType::kFirst;
-  return capstype;
-}
-
-int AsciiCaseInsensitiveCompare(absl::string_view s1, absl::string_view s2) {
-  if (s1.size() == s2.size()) {
-    return strncasecmp(s1.data(), s2.data(), s1.size());
-  } else if (s1.size() < s2.size()) {
-    int res = strncasecmp(s1.data(), s2.data(), s1.size());
-    return (res == 0) ? -1 : res;
-  } else {
-    int res = strncasecmp(s1.data(), s2.data(), s2.size());
-    return (res == 0) ? 1 : res;
-  }
-}
-
-size_t AsciiCaseInsensitiveHash::operator()(absl::string_view s) const {
-  // return absl::HashOf(absl::AsciiStrToLower(s));
-  return std::hash<std::string>{}(absl::AsciiStrToLower(s));
-}
-
-bool AsciiCaseInsensitiveEq::operator()(absl::string_view s1,
-                                        absl::string_view s2) const {
-  return s1.size() == s2.size() &&
-         strncasecmp(s1.data(), s2.data(), s1.size()) == 0;
-}
-
-void MakeAsciiTitlecase(std::string* s, absl::string_view delimiters) {
-  bool upper = true;
-  for (auto& ch : *s) {
-    if (upper) {
-      ch = absl::ascii_toupper(ch);
-    }
-    upper = (absl::StrContains(delimiters, ch));
-  }
-}
-
-std::string MakeAsciiTitlecase(absl::string_view s,
-                               absl::string_view delimiters) {
-  std::string result(s);
-  MakeAsciiTitlecase(&result, delimiters);
-  return result;
-}
-}  // namespace strings
diff --git a/ortools/base/case.h b/ortools/base/case.h
deleted file mode 100644
index 004a227a6d..0000000000
--- a/ortools/base/case.h
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright 2010-2025 Google LLC
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This package contains character classification functions for evaluating
-// the case state of strings, and converting strings to uppercase, lowercase,
-// etc.
-//
-// Unlike <ctype.h> (or absl/strings/ascii.h), the functions in this file
-// are designed to operate on strings, not single characters.
-//
-// Except for those marked as "using the C/POSIX locale", these functions are
-// for ASCII strings only.
-
-#ifndef OR_TOOLS_BASE_CASE_H_
-#define OR_TOOLS_BASE_CASE_H_
-
-#ifndef _MSC_VER
-#include <strings.h>  // for strcasecmp, but msvc does not have this header
-#endif
-
-#include <cstddef>
-#include <cstring>
-#include <functional>
-#include <ostream>
-#include <string>
-
-#include "absl/base/attributes.h"
-#include "absl/base/macros.h"
-#include "absl/base/port.h"  // disable some warnings on Windows
-#include "absl/strings/ascii.h"
-#include "absl/strings/string_view.h"
-
-namespace strings {
-// Enum values returned by GetAsciiCapitalization().
-enum class AsciiCapitalizationType {
-  kLower,   // Entirely lowercase
-  kUpper,   // Entirely uppercase
-  kFirst,   // First letter uppercase
-  kMixed,   // Mixed case
-  kNoAlpha  // Not an alphabetic string
-};
-
-// Prints the name of an enum value.
-std::ostream& operator<<(std::ostream& os, const AsciiCapitalizationType& type);
-
-// GetAsciiCapitalization()
-//
-// Returns a value indicating whether an ASCII string is entirely lowercase,
-// entirely uppercase, first letter uppercase, or mixed case, as returned by
-// `absl::ascii_islower()` and `absl::ascii_isupper()`.
-AsciiCapitalizationType GetAsciiCapitalization(absl::string_view input);
-
-// AsciiCaseInsensitiveCompare()
-//
-// Performs a case-insensitive absl::string_view comparison.
-// Returns:
-//    less than 0:    if s1 < s2
-//    equal to 0:     if s1 == s2
-//    greater than 0: if s1 > s2
-int AsciiCaseInsensitiveCompare(absl::string_view s1, absl::string_view s2);
-
-// AsciiCaseInsensitiveLess()
-//
-// Performs a case-insensitive less-than absl::string_view comparison. This
-// function object is useful as a template parameter for set/map of
-// absl::string_view-compatible types, if uniqueness of keys is
-// case-insensitive.
-// Can be used for heterogeneous lookups in associative containers. Example:
-//
-// absl::btree_map<std::string, std::string, AsciiCaseInsensitiveLess> map;
-// absl::string_view key = ...;
-// auto it = map.find(key);
-struct AsciiCaseInsensitiveLess {
-  // Enable heterogeneous lookup.
-  using is_transparent = void;
-  bool operator()(absl::string_view s1, absl::string_view s2) const {
-    return AsciiCaseInsensitiveCompare(s1, s2) < 0;
-  }
-};
-
-// AsciiCaseInsensitiveHash and AsciiCaseInsensitiveEq
-//
-// Performs a case-insensitive hash/eq absl::string_view operations. This
-// function objects are useful as a template parameter for hash set/map of
-// absl::string_view-compatible types, if uniqueness of keys is
-// case-insensitive.
-// Can be used for heterogeneous lookups in absl associative containers.
-// Example:
-//
-// absl::flat_hash_map<std::string, std::string,
-//                     AsciiCaseInsensitiveHash,
-//                     AsciiCaseInsensitiveEq>
-//     map;
-// absl::string_view key = ...;
-// auto it = map.find(key);
-struct AsciiCaseInsensitiveHash {
-  using is_transparent = void;
-  size_t operator()(absl::string_view s) const;
-};
-struct AsciiCaseInsensitiveEq {
-  using is_transparent = void;
-  bool operator()(absl::string_view s1, absl::string_view s2) const;
-};
-
-// MakeAsciiTitlecase()
-//
-// Capitalizes the first character of each word in a string, using the set of
-// characters in `delimiters` to use as word boundaries. This function can be
-// implemented using a regular expression, but this version should be more
-// efficient.
-void MakeAsciiTitlecase(std::string* s, absl::string_view delimiters);
-
-// As above but with string_view as input
-std::string MakeAsciiTitlecase(absl::string_view s,
-                               absl::string_view delimiters);
-
-}  // namespace strings
-#endif  // OR_TOOLS_BASE_CASE_H_
diff --git a/ortools/base/parse_test_proto.h b/ortools/base/parse_test_proto.h
index 0553e1a221..a654315cee 100644
--- a/ortools/base/parse_test_proto.h
+++ b/ortools/base/parse_test_proto.h
@@ -43,7 +43,8 @@ class ParseProtoHelper {
 
 }  // namespace parse_proto_internal
 
-parse_proto_internal::ParseProtoHelper ParseTestProto(std::string_view input) {
+inline parse_proto_internal::ParseProtoHelper ParseTestProto(
+    std::string_view input) {
   return parse_proto_internal::ParseProtoHelper(input);
 }
 
diff --git a/ortools/base/protocol-buffer-matchers.cc b/ortools/base/protocol-buffer-matchers.cc
new file mode 100644
index 0000000000..bba51ab653
--- /dev/null
+++ b/ortools/base/protocol-buffer-matchers.cc
@@ -0,0 +1,396 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// emulates g3/testing/base/public/gmock_utils/protocol-buffer-matchers.cc
+#include "ortools/base/protocol-buffer-matchers.h"
+
+#include <regex>
+
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+#include "absl/strings/string_view.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/io/tokenizer.h"
+#include "google/protobuf/message.h"
+#include "google/protobuf/text_format.h"
+#include "google/protobuf/util/message_differencer.h"
+
+namespace testing {
+namespace internal {
+// Utilities.
+class StringErrorCollector : public ::google::protobuf::io::ErrorCollector {
+ public:
+  explicit StringErrorCollector(std::string* error_text)
+      : error_text_(error_text) {}
+
+  void RecordError(int line, int column, absl::string_view message) override {
+    std::ostringstream stream;
+    stream << line << '(' << column << "): " << message << std::endl;
+    *error_text_ += stream.str();
+  }
+
+  void RecordWarning(int line, int column, absl::string_view message) override {
+    std::ostringstream stream;
+    stream << line << '(' << column << "): " << message << std::endl;
+    *error_text_ += stream.str();
+  }
+
+ private:
+  std::string* error_text_;
+  StringErrorCollector(const StringErrorCollector&) = delete;
+  StringErrorCollector& operator=(const StringErrorCollector&) = delete;
+};
+
+bool ParsePartialFromAscii(const std::string& pb_ascii,
+                           ::google::protobuf::Message* proto,
+                           std::string* error_text) {
+  ::google::protobuf::TextFormat::Parser parser;
+  StringErrorCollector collector(error_text);
+  parser.RecordErrorsTo(&collector);
+  parser.AllowPartialMessage(true);
+  return parser.ParseFromString(pb_ascii, proto);
+}
+
+// Returns true iff p and q can be compared (i.e. have the same descriptor).
+bool ProtoComparable(const ::google::protobuf::Message& p,
+                     const ::google::protobuf::Message& q) {
+  return p.GetDescriptor() == q.GetDescriptor();
+}
+
+template <typename Container>
+std::string JoinStringPieces(const Container& strings,
+                             absl::string_view separator) {
+  std::stringstream stream;
+  absl::string_view sep = "";
+  for (const absl::string_view str : strings) {
+    stream << sep << str;
+    sep = separator;
+  }
+  return stream.str();
+}
+
+// Find all the descriptors for the ingore_fields.
+std::vector<const ::google::protobuf::FieldDescriptor*> GetFieldDescriptors(
+    const ::google::protobuf::Descriptor* proto_descriptor,
+    const std::vector<std::string>& ignore_fields) {
+  std::vector<const ::google::protobuf::FieldDescriptor*> ignore_descriptors;
+  std::vector<absl::string_view> remaining_descriptors;
+
+  const ::google::protobuf::DescriptorPool* pool =
+      proto_descriptor->file()->pool();
+  for (const std::string& name : ignore_fields) {
+    if (const ::google::protobuf::FieldDescriptor* field =
+            pool->FindFieldByName(name)) {
+      ignore_descriptors.push_back(field);
+    } else {
+      remaining_descriptors.push_back(name);
+    }
+  }
+
+  CHECK(remaining_descriptors.empty())
+      << "Could not find fields for proto " << proto_descriptor->full_name()
+      << " with fully qualified names: "
+      << JoinStringPieces(remaining_descriptors, ",");
+  return ignore_descriptors;
+}
+
+// Sets the ignored fields corresponding to ignore_fields in differencer. Dies
+// if any is invalid.
+void SetIgnoredFieldsOrDie(
+    const ::google::protobuf::Descriptor& root_descriptor,
+    const std::vector<std::string>& ignore_fields,
+    ::google::protobuf::util::MessageDifferencer* differencer) {
+  if (!ignore_fields.empty()) {
+    std::vector<const ::google::protobuf::FieldDescriptor*> ignore_descriptors =
+        GetFieldDescriptors(&root_descriptor, ignore_fields);
+    for (std::vector<const ::google::protobuf::FieldDescriptor*>::iterator it =
+             ignore_descriptors.begin();
+         it != ignore_descriptors.end(); ++it) {
+      differencer->IgnoreField(*it);
+    }
+  }
+}
+
+// A criterion that ignores a field path.
+class IgnoreFieldPathCriteria
+    : public ::google::protobuf::util::MessageDifferencer::IgnoreCriteria {
+ public:
+  explicit IgnoreFieldPathCriteria(
+      const std::vector<
+          ::google::protobuf::util::MessageDifferencer::SpecificField>&
+          field_path)
+      : ignored_field_path_(field_path) {}
+
+  bool IsIgnored(
+      const ::google::protobuf::Message& message1,
+      const ::google::protobuf::Message& message2,
+      const ::google::protobuf::FieldDescriptor* field,
+      const std::vector<
+          ::google::protobuf::util::MessageDifferencer::SpecificField>&
+          parent_fields) override {
+    // The off by one is for the current field.
+    if (parent_fields.size() + 1 != ignored_field_path_.size()) {
+      return false;
+    }
+    for (size_t i = 0; i < parent_fields.size(); ++i) {
+      const auto& cur_field = parent_fields[i];
+      const auto& ignored_field = ignored_field_path_[i];
+      // We could compare pointers but it's not guaranteed that descriptors come
+      // from the same pool.
+      if (cur_field.field->full_name() != ignored_field.field->full_name()) {
+        return false;
+      }
+
+      // repeated_field[i] is ignored if repeated_field is ignored. To put it
+      // differently: if ignored_field specifies an index, we ignore only a
+      // field with the same index.
+      if (ignored_field.index != -1 && ignored_field.index != cur_field.index) {
+        return false;
+      }
+    }
+    return field->full_name() == ignored_field_path_.back().field->full_name();
+  }
+
+ private:
+  const std::vector<google::protobuf::util::MessageDifferencer::SpecificField>
+      ignored_field_path_;
+};
+
+// Parses a field path and returns individual components.
+std::vector<google::protobuf::util::MessageDifferencer::SpecificField>
+ParseFieldPathOrDie(const std::string& relative_field_path,
+                    const ::google::protobuf::Descriptor& root_descriptor) {
+  std::vector<google::protobuf::util::MessageDifferencer::SpecificField>
+      field_path;
+
+  // We're parsing a dot-separated list of elements that can be either:
+  //   - field names
+  //   - extension names
+  //   - indexed field names
+  // The parser is very permissive as to what is a field name, then we check
+  // the field name against the descriptor.
+
+  // Regular parsers. Consume() does not handle optional captures so we split it
+  // in two regexps.
+  const std::regex field_regex(R"(([^.()[\]]+))");
+  const std::regex field_subscript_regex(R"(([^.()[\]]+)\[(\d+)\])");
+  const std::regex extension_regex(R"(\(([^)]+)\))");
+
+  const auto begin = std::begin(relative_field_path);
+  auto it = begin;
+  const auto end = std::end(relative_field_path);
+  while (it != end) {
+    // Consume a dot, except on the first iteration.
+    if (it != std::begin(relative_field_path) && *(it++) != '.') {
+      LOG(FATAL) << "Cannot parse field path '" << relative_field_path
+                 << "' at offset " << std::distance(begin, it)
+                 << ": expected '.'";
+    }
+    // Try to consume a field name. If that fails, consume an extension name.
+    ::google::protobuf::util::MessageDifferencer::SpecificField field;
+    std::smatch match_results;
+    if (std::regex_search(it, end, match_results, field_subscript_regex) ||
+        std::regex_search(it, end, match_results, field_regex)) {
+      std::string name = match_results[1].str();
+      if (field_path.empty()) {
+        field.field = root_descriptor.FindFieldByName(name);
+        CHECK(field.field) << "No such field '" << name << "' in message '"
+                           << root_descriptor.full_name() << "'";
+      } else {
+        const ::google::protobuf::util::MessageDifferencer::SpecificField&
+            parent = field_path.back();
+        field.field = parent.field->message_type()->FindFieldByName(name);
+        CHECK(field.field) << "No such field '" << name << "' in '"
+                           << parent.field->full_name() << "'";
+      }
+      if (match_results.size() > 2 && match_results[2].matched) {
+        std::string number = match_results[2].str();
+        field.index = std::stoi(number);
+      }
+
+    } else if (std::regex_search(it, end, match_results, extension_regex)) {
+      std::string name = match_results[1].str();
+      field.field = ::google::protobuf::DescriptorPool::generated_pool()
+                        ->FindExtensionByName(name);
+      CHECK(field.field) << "No such extension '" << name << "'";
+      if (field_path.empty()) {
+        CHECK(root_descriptor.IsExtensionNumber(field.field->number()))
+            << "Extension '" << name << "' does not extend message '"
+            << root_descriptor.full_name() << "'";
+      } else {
+        const ::google::protobuf::util::MessageDifferencer::SpecificField&
+            parent = field_path.back();
+        CHECK(parent.field->message_type()->IsExtensionNumber(
+            field.field->number()))
+            << "Extension '" << name << "' does not extend '"
+            << parent.field->full_name() << "'";
+      }
+    } else {
+      LOG(FATAL) << "Cannot parse field path '" << relative_field_path
+                 << "' at offset " << std::distance(begin, it)
+                 << ": expected field or extension";
+    }
+    auto consume = match_results[0].length();
+    it += consume;
+    field_path.push_back(field);
+  }
+
+  CHECK(!field_path.empty());
+  CHECK(field_path.back().index == -1)
+      << "Terminally ignoring fields by index is currently not supported ('"
+      << relative_field_path << "')";
+
+  return field_path;
+}
+
+// Sets the ignored field paths corresponding to field_paths in differencer.
+// Dies if any path is invalid.
+void SetIgnoredFieldPathsOrDie(
+    const ::google::protobuf::Descriptor& root_descriptor,
+    const std::vector<std::string>& field_paths,
+    ::google::protobuf::util::MessageDifferencer* differencer) {
+  for (const std::string& field_path : field_paths) {
+    differencer->AddIgnoreCriteria(new IgnoreFieldPathCriteria(
+        ParseFieldPathOrDie(field_path, root_descriptor)));
+  }
+}
+
+// Configures a MessageDifferencer and DefaultFieldComparator to use the logic
+// described in comp. The configured differencer is the output of this function,
+// but a FieldComparator must be provided to keep ownership clear.
+void ConfigureDifferencer(
+    const ProtoComparison& comp,
+    ::google::protobuf::util::DefaultFieldComparator* comparator,
+    ::google::protobuf::util::MessageDifferencer* differencer,
+    const ::google::protobuf::Descriptor* descriptor) {
+  differencer->set_message_field_comparison(comp.field_comp);
+  differencer->set_scope(comp.scope);
+  comparator->set_float_comparison(comp.float_comp);
+  comparator->set_treat_nan_as_equal(comp.treating_nan_as_equal);
+  differencer->set_repeated_field_comparison(comp.repeated_field_comp);
+  SetIgnoredFieldsOrDie(*descriptor, comp.ignore_fields, differencer);
+  SetIgnoredFieldPathsOrDie(*descriptor, comp.ignore_field_paths, differencer);
+  if (comp.float_comp == kProtoApproximate &&
+      (comp.has_custom_margin || comp.has_custom_fraction)) {
+    // Two fields will be considered equal if they're within the fraction _or_
+    // within the margin. So setting the fraction to 0.0 makes this effectively
+    // a "SetMargin". Similarly, setting the margin to 0.0 makes this
+    // effectively a "SetFraction".
+    comparator->SetDefaultFractionAndMargin(comp.float_fraction,
+                                            comp.float_margin);
+  }
+  differencer->set_field_comparator(comparator);
+  if (comp.differencer_config_function) {
+    comp.differencer_config_function(comparator, differencer);
+  }
+}
+
+// Returns true iff actual and expected are comparable and match.  The
+// comp argument specifies how the two are compared.
+bool ProtoCompare(const ProtoComparison& comp,
+                  const ::google::protobuf::Message& actual,
+                  const ::google::protobuf::Message& expected) {
+  if (!ProtoComparable(actual, expected)) return false;
+
+  ::google::protobuf::util::MessageDifferencer differencer;
+  ::google::protobuf::util::DefaultFieldComparator field_comparator;
+  ConfigureDifferencer(comp, &field_comparator, &differencer,
+                       actual.GetDescriptor());
+
+  // It's important for 'expected' to be the first argument here, as
+  // Compare() is not symmetric.  When we do a partial comparison,
+  // only fields present in the first argument of Compare() are
+  // considered.
+  return differencer.Compare(expected, actual);
+}
+
+// Describes the types of the expected and the actual protocol buffer.
+std::string DescribeTypes(const ::google::protobuf::Message& expected,
+                          const ::google::protobuf::Message& actual) {
+  std::ostringstream s;
+  s << "whose type should be " << expected.GetDescriptor()->full_name()
+    << " but actually is " << actual.GetDescriptor()->full_name();
+  return s.str();
+}
+
+// Prints the protocol buffer pointed to by proto.
+std::string PrintProtoPointee(const ::google::protobuf::Message* proto) {
+  if (proto == nullptr) return "";
+  return "which points to " + ::testing::PrintToString(*proto);
+}
+
+// Describes the differences between the two protocol buffers.
+std::string DescribeDiff(const ProtoComparison& comp,
+                         const ::google::protobuf::Message& actual,
+                         const ::google::protobuf::Message& expected) {
+  ::google::protobuf::util::MessageDifferencer differencer;
+  ::google::protobuf::util::DefaultFieldComparator field_comparator;
+  ConfigureDifferencer(comp, &field_comparator, &differencer,
+                       actual.GetDescriptor());
+
+  std::string diff;
+  differencer.ReportDifferencesToString(&diff);
+
+  // We must put 'expected' as the first argument here, as Compare()
+  // reports the diff in terms of how the protobuf changes from the
+  // first argument to the second argument.
+  differencer.Compare(expected, actual);
+
+  // Removes the trailing '\n' in the diff to make the output look nicer.
+  if (diff.length() > 0 && *(diff.end() - 1) == '\n') {
+    diff.erase(diff.end() - 1);
+  }
+
+  return "with the difference:\n" + diff;
+}
+
+bool ProtoMatcherBase::MatchAndExplain(
+    const ::google::protobuf::Message& arg,
+    bool is_matcher_for_pointer,  // true iff this matcher is used to match
+                                  // a protobuf pointer.
+    ::testing::MatchResultListener* listener) const {
+  if (must_be_initialized_ && !arg.IsInitialized()) {
+    *listener << "which isn't fully initialized";
+    return false;
+  }
+
+  const google::protobuf::Message* const expected =
+      CreateExpectedProto(arg, listener);
+  if (expected == nullptr) return false;
+
+  // Protobufs of different types cannot be compared.
+  const bool comparable = ProtoComparable(arg, *expected);
+  const bool match = comparable && ProtoCompare(comp(), arg, *expected);
+
+  // Explaining the match result is expensive.  We don't want to waste
+  // time calculating an explanation if the listener isn't interested.
+  if (listener->IsInterested()) {
+    const char* sep = "";
+    if (is_matcher_for_pointer) {
+      *listener << PrintProtoPointee(&arg);
+      sep = ",\n";
+    }
+
+    if (!comparable) {
+      *listener << sep << DescribeTypes(*expected, arg);
+    } else if (!match) {
+      *listener << sep << DescribeDiff(comp(), arg, *expected);
+    }
+  }
+
+  DeleteExpectedProto(expected);
+  return match;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/ortools/base/protocol-buffer-matchers.h b/ortools/base/protocol-buffer-matchers.h
index 943c9f5c3c..535027ab6c 100644
--- a/ortools/base/protocol-buffer-matchers.h
+++ b/ortools/base/protocol-buffer-matchers.h
@@ -58,9 +58,11 @@
 //                                   "bar: 'x'"));
 
 #include <cstddef>
-#include <iterator>
+#include <functional>
+#include <iomanip>
+#include <limits>
+#include <memory>
 #include <ostream>
-#include <regex>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -69,11 +71,10 @@
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
 #include "gmock/gmock-matchers.h"
-#include "gmock/gmock.h"
 #include "google/protobuf/descriptor.h"
-#include "google/protobuf/io/tokenizer.h"
 #include "google/protobuf/message.h"
 #include "google/protobuf/util/message_differencer.h"
+#include "gtest/gtest.h"
 
 namespace testing {
 using DifferencerConfigFunction =
@@ -146,334 +147,32 @@ struct ProtoComparison {
 const bool kMustBeInitialized = true;
 const bool kMayBeUninitialized = false;
 
-class StringErrorCollector : public ::google::protobuf::io::ErrorCollector {
- public:
-  explicit StringErrorCollector(std::string* error_text)
-      : error_text_(error_text) {}
-
-  void RecordError(int line, int column, absl::string_view message) override {
-    std::ostringstream stream;
-    stream << line << '(' << column << "): " << message << std::endl;
-    *error_text_ += stream.str();
-  }
-
-  void RecordWarning(int line, int column, absl::string_view message) override {
-    std::ostringstream stream;
-    stream << line << '(' << column << "): " << message << std::endl;
-    *error_text_ += stream.str();
-  }
-
- private:
-  std::string* error_text_;
-  StringErrorCollector(const StringErrorCollector&) = delete;
-  StringErrorCollector& operator=(const StringErrorCollector&) = delete;
-};
-
 // Parses the TextFormat representation of a protobuf, allowing required fields
 // to be missing.  Returns true if successful.
 bool ParsePartialFromAscii(const std::string& pb_ascii,
                            ::google::protobuf::Message* proto,
-                           std::string* error_text) {
-  ::google::protobuf::TextFormat::Parser parser;
-  StringErrorCollector collector(error_text);
-  parser.RecordErrorsTo(&collector);
-  parser.AllowPartialMessage(true);
-  return parser.ParseFromString(pb_ascii, proto);
-}
+                           std::string* error_text);
 
 // Returns true iff p and q can be compared (i.e. have the same descriptor).
 bool ProtoComparable(const ::google::protobuf::Message& p,
-                     const ::google::protobuf::Message& q) {
-  return p.GetDescriptor() == q.GetDescriptor();
-}
-
-template <typename Container>
-std::string JoinStringPieces(const Container& strings,
-                             absl::string_view separator) {
-  std::stringstream stream;
-  absl::string_view sep = "";
-  for (const absl::string_view str : strings) {
-    stream << sep << str;
-    sep = separator;
-  }
-  return stream.str();
-}
-
-// Find all the descriptors for the ingore_fields.
-std::vector<const ::google::protobuf::FieldDescriptor*> GetFieldDescriptors(
-    const ::google::protobuf::Descriptor* proto_descriptor,
-    const std::vector<std::string>& ignore_fields) {
-  std::vector<const ::google::protobuf::FieldDescriptor*> ignore_descriptors;
-  std::vector<absl::string_view> remaining_descriptors;
-
-  const ::google::protobuf::DescriptorPool* pool =
-      proto_descriptor->file()->pool();
-  for (const std::string& name : ignore_fields) {
-    if (const ::google::protobuf::FieldDescriptor* field =
-            pool->FindFieldByName(name)) {
-      ignore_descriptors.push_back(field);
-    } else {
-      remaining_descriptors.push_back(name);
-    }
-  }
-
-  CHECK(remaining_descriptors.empty())
-      << "Could not find fields for proto " << proto_descriptor->full_name()
-      << " with fully qualified names: "
-      << JoinStringPieces(remaining_descriptors, ",");
-  return ignore_descriptors;
-}
-
-// Sets the ignored fields corresponding to ignore_fields in differencer. Dies
-// if any is invalid.
-void SetIgnoredFieldsOrDie(
-    const ::google::protobuf::Descriptor& root_descriptor,
-    const std::vector<std::string>& ignore_fields,
-    ::google::protobuf::util::MessageDifferencer* differencer) {
-  if (!ignore_fields.empty()) {
-    std::vector<const ::google::protobuf::FieldDescriptor*> ignore_descriptors =
-        GetFieldDescriptors(&root_descriptor, ignore_fields);
-    for (std::vector<const ::google::protobuf::FieldDescriptor*>::iterator it =
-             ignore_descriptors.begin();
-         it != ignore_descriptors.end(); ++it) {
-      differencer->IgnoreField(*it);
-    }
-  }
-}
-
-// A criterion that ignores a field path.
-class IgnoreFieldPathCriteria
-    : public ::google::protobuf::util::MessageDifferencer::IgnoreCriteria {
- public:
-  explicit IgnoreFieldPathCriteria(
-      const std::vector<
-          ::google::protobuf::util::MessageDifferencer::SpecificField>&
-          field_path)
-      : ignored_field_path_(field_path) {}
-
-  bool IsIgnored(
-      const ::google::protobuf::Message& message1,
-      const ::google::protobuf::Message& message2,
-      const ::google::protobuf::FieldDescriptor* field,
-      const std::vector<
-          ::google::protobuf::util::MessageDifferencer::SpecificField>&
-          parent_fields) override {
-    // The off by one is for the current field.
-    if (parent_fields.size() + 1 != ignored_field_path_.size()) {
-      return false;
-    }
-    for (size_t i = 0; i < parent_fields.size(); ++i) {
-      const auto& cur_field = parent_fields[i];
-      const auto& ignored_field = ignored_field_path_[i];
-      // We could compare pointers but it's not guaranteed that descriptors come
-      // from the same pool.
-      if (cur_field.field->full_name() != ignored_field.field->full_name()) {
-        return false;
-      }
-
-      // repeated_field[i] is ignored if repeated_field is ignored. To put it
-      // differently: if ignored_field specifies an index, we ignore only a
-      // field with the same index.
-      if (ignored_field.index != -1 && ignored_field.index != cur_field.index) {
-        return false;
-      }
-    }
-    return field->full_name() == ignored_field_path_.back().field->full_name();
-  }
-
- private:
-  const std::vector<google::protobuf::util::MessageDifferencer::SpecificField>
-      ignored_field_path_;
-};
-
-// Parses a field path and returns individual components.
-std::vector<google::protobuf::util::MessageDifferencer::SpecificField>
-ParseFieldPathOrDie(const std::string& relative_field_path,
-                    const ::google::protobuf::Descriptor& root_descriptor) {
-  std::vector<google::protobuf::util::MessageDifferencer::SpecificField>
-      field_path;
-
-  // We're parsing a dot-separated list of elements that can be either:
-  //   - field names
-  //   - extension names
-  //   - indexed field names
-  // The parser is very permissive as to what is a field name, then we check
-  // the field name against the descriptor.
-
-  // Regular parsers. Consume() does not handle optional captures so we split it
-  // in two regexps.
-  const std::regex field_regex(R"(([^.()[\]]+))");
-  const std::regex field_subscript_regex(R"(([^.()[\]]+)\[(\d+)\])");
-  const std::regex extension_regex(R"(\(([^)]+)\))");
-
-  const auto begin = std::begin(relative_field_path);
-  auto it = begin;
-  const auto end = std::end(relative_field_path);
-  while (it != end) {
-    // Consume a dot, except on the first iteration.
-    if (it != std::begin(relative_field_path) && *(it++) != '.') {
-      LOG(FATAL) << "Cannot parse field path '" << relative_field_path
-                 << "' at offset " << std::distance(begin, it)
-                 << ": expected '.'";
-    }
-    // Try to consume a field name. If that fails, consume an extension name.
-    ::google::protobuf::util::MessageDifferencer::SpecificField field;
-    std::smatch match_results;
-    if (std::regex_search(it, end, match_results, field_subscript_regex) ||
-        std::regex_search(it, end, match_results, field_regex)) {
-      std::string name = match_results[1].str();
-      if (field_path.empty()) {
-        field.field = root_descriptor.FindFieldByName(name);
-        CHECK(field.field) << "No such field '" << name << "' in message '"
-                           << root_descriptor.full_name() << "'";
-      } else {
-        const ::google::protobuf::util::MessageDifferencer::SpecificField&
-            parent = field_path.back();
-        field.field = parent.field->message_type()->FindFieldByName(name);
-        CHECK(field.field) << "No such field '" << name << "' in '"
-                           << parent.field->full_name() << "'";
-      }
-      if (match_results.size() > 2 && match_results[2].matched) {
-        std::string number = match_results[2].str();
-        field.index = std::stoi(number);
-      }
-
-    } else if (std::regex_search(it, end, match_results, extension_regex)) {
-      std::string name = match_results[1].str();
-      field.field = ::google::protobuf::DescriptorPool::generated_pool()
-                        ->FindExtensionByName(name);
-      CHECK(field.field) << "No such extension '" << name << "'";
-      if (field_path.empty()) {
-        CHECK(root_descriptor.IsExtensionNumber(field.field->number()))
-            << "Extension '" << name << "' does not extend message '"
-            << root_descriptor.full_name() << "'";
-      } else {
-        const ::google::protobuf::util::MessageDifferencer::SpecificField&
-            parent = field_path.back();
-        CHECK(parent.field->message_type()->IsExtensionNumber(
-            field.field->number()))
-            << "Extension '" << name << "' does not extend '"
-            << parent.field->full_name() << "'";
-      }
-    } else {
-      LOG(FATAL) << "Cannot parse field path '" << relative_field_path
-                 << "' at offset " << std::distance(begin, it)
-                 << ": expected field or extension";
-    }
-    auto consume = match_results[0].length();
-    it += consume;
-    field_path.push_back(field);
-  }
-
-  CHECK(!field_path.empty());
-  CHECK(field_path.back().index == -1)
-      << "Terminally ignoring fields by index is currently not supported ('"
-      << relative_field_path << "')";
-
-  return field_path;
-}
-
-// Sets the ignored field paths corresponding to field_paths in differencer.
-// Dies if any path is invalid.
-void SetIgnoredFieldPathsOrDie(
-    const ::google::protobuf::Descriptor& root_descriptor,
-    const std::vector<std::string>& field_paths,
-    ::google::protobuf::util::MessageDifferencer* differencer) {
-  for (const std::string& field_path : field_paths) {
-    differencer->AddIgnoreCriteria(new IgnoreFieldPathCriteria(
-        ParseFieldPathOrDie(field_path, root_descriptor)));
-  }
-}
-
-// Configures a MessageDifferencer and DefaultFieldComparator to use the logic
-// described in comp. The configured differencer is the output of this function,
-// but a FieldComparator must be provided to keep ownership clear.
-void ConfigureDifferencer(
-    const ProtoComparison& comp,
-    ::google::protobuf::util::DefaultFieldComparator* comparator,
-    ::google::protobuf::util::MessageDifferencer* differencer,
-    const ::google::protobuf::Descriptor* descriptor) {
-  differencer->set_message_field_comparison(comp.field_comp);
-  differencer->set_scope(comp.scope);
-  comparator->set_float_comparison(comp.float_comp);
-  comparator->set_treat_nan_as_equal(comp.treating_nan_as_equal);
-  differencer->set_repeated_field_comparison(comp.repeated_field_comp);
-  SetIgnoredFieldsOrDie(*descriptor, comp.ignore_fields, differencer);
-  SetIgnoredFieldPathsOrDie(*descriptor, comp.ignore_field_paths, differencer);
-  if (comp.float_comp == kProtoApproximate &&
-      (comp.has_custom_margin || comp.has_custom_fraction)) {
-    // Two fields will be considered equal if they're within the fraction _or_
-    // within the margin. So setting the fraction to 0.0 makes this effectively
-    // a "SetMargin". Similarly, setting the margin to 0.0 makes this
-    // effectively a "SetFraction".
-    comparator->SetDefaultFractionAndMargin(comp.float_fraction,
-                                            comp.float_margin);
-  }
-  differencer->set_field_comparator(comparator);
-  if (comp.differencer_config_function) {
-    comp.differencer_config_function(comparator, differencer);
-  }
-}
+                     const ::google::protobuf::Message& q);
 
 // Returns true iff actual and expected are comparable and match.  The
 // comp argument specifies how the two are compared.
 bool ProtoCompare(const ProtoComparison& comp,
                   const ::google::protobuf::Message& actual,
-                  const ::google::protobuf::Message& expected) {
-  if (!ProtoComparable(actual, expected)) return false;
-
-  ::google::protobuf::util::MessageDifferencer differencer;
-  ::google::protobuf::util::DefaultFieldComparator field_comparator;
-  ConfigureDifferencer(comp, &field_comparator, &differencer,
-                       actual.GetDescriptor());
-
-  // It's important for 'expected' to be the first argument here, as
-  // Compare() is not symmetric.  When we do a partial comparison,
-  // only fields present in the first argument of Compare() are
-  // considered.
-  return differencer.Compare(expected, actual);
-}
+                  const ::google::protobuf::Message& expected);
 
 // Describes the types of the expected and the actual protocol buffer.
 std::string DescribeTypes(const ::google::protobuf::Message& expected,
-                          const ::google::protobuf::Message& actual) {
-  std::ostringstream s;
-  s << "whose type should be " << expected.GetDescriptor()->full_name()
-    << " but actually is " << actual.GetDescriptor()->full_name();
-  return s.str();
-}
-
+                          const ::google::protobuf::Message& actual);
 // Prints the protocol buffer pointed to by proto.
-std::string PrintProtoPointee(const ::google::protobuf::Message* proto) {
-  if (proto == NULL) return "";
-  return "which points to " + ::testing::PrintToString(*proto);
-}
+std::string PrintProtoPointee(const ::google::protobuf::Message* proto);
 
 // Describes the differences between the two protocol buffers.
 std::string DescribeDiff(const ProtoComparison& comp,
                          const ::google::protobuf::Message& actual,
-                         const ::google::protobuf::Message& expected) {
-  ::google::protobuf::util::MessageDifferencer differencer;
-  ::google::protobuf::util::DefaultFieldComparator field_comparator;
-  ConfigureDifferencer(comp, &field_comparator, &differencer,
-                       actual.GetDescriptor());
-
-  std::string diff;
-  differencer.ReportDifferencesToString(&diff);
-
-  // We must put 'expected' as the first argument here, as Compare()
-  // reports the diff in terms of how the protobuf changes from the
-  // first argument to the second argument.
-  differencer.Compare(expected, actual);
-
-  // Removes the trailing '\n' in the diff to make the output look nicer.
-  if (diff.length() > 0 && *(diff.end() - 1) == '\n') {
-    diff.erase(diff.end() - 1);
-  }
-
-  return "with the difference:\n" + diff;
-}
-
+                         const ::google::protobuf::Message& expected);
 // Common code for implementing EqualsProto and EquivToProto.
 class ProtoMatcherBase {
  public:
@@ -582,41 +281,10 @@ class ProtoMatcherBase {
 
  private:
   bool MatchAndExplain(
-    const ::google::protobuf::Message& arg,
-    bool is_matcher_for_pointer,  // true iff this matcher is used to match a protobuf pointer.
-    ::testing::MatchResultListener* listener) const {
-    if (must_be_initialized_ && !arg.IsInitialized()) {
-      *listener << "which isn't fully initialized";
-      return false;
-    }
-
-    const ::google::protobuf::Message* const expected =
-      CreateExpectedProto(arg, listener);
-    if (expected == NULL) return false;
-
-    // Protobufs of different types cannot be compared.
-    const bool comparable = ProtoComparable(arg, *expected);
-    const bool match = comparable && ProtoCompare(comp(), arg, *expected);
-
-    // Explaining the match result is expensive.  We don't want to waste
-    // time calculating an explanation if the listener isn't interested.
-    if (listener->IsInterested()) {
-      const char* sep = "";
-      if (is_matcher_for_pointer) {
-        *listener << PrintProtoPointee(&arg);
-        sep = ",\n";
-      }
-
-      if (!comparable) {
-        *listener << sep << DescribeTypes(*expected, arg);
-      } else if (!match) {
-        *listener << sep << DescribeDiff(comp(), arg, *expected);
-      }
-    }
-
-    DeleteExpectedProto(expected);
-    return match;
-  }
+      const ::google::protobuf::Message& arg,
+      bool is_matcher_for_pointer,  // true iff this matcher is used to match a
+                                    // protobuf pointer.
+      ::testing::MatchResultListener* listener) const;
 
   const bool must_be_initialized_;
   std::unique_ptr<ProtoComparison> comp_;
@@ -681,15 +349,15 @@ class ProtoStringMatcher : public ProtoMatcherBase {
           expected,              // The text representing the expected protobuf.
       bool must_be_initialized,  // Must the argument be fully initialized?
       const ProtoComparison comp)  // How to compare the two protobufs.
-      : ProtoMatcherBase(must_be_initialized, comp), expected_(std::string(expected)) {}
+      : ProtoMatcherBase(must_be_initialized, comp),
+        expected_(std::string(expected)) {}
 
   // Parses the expected string as a protobuf of the same type as arg,
   // and returns the parsed protobuf (or NULL when the parse fails).
   // The caller must call DeleteExpectedProto() on the return value
   // later.
   virtual const MessageType* CreateExpectedProto(
-      const MessageType& arg,
-      ::testing::MatchResultListener* listener) const {
+      const MessageType& arg, ::testing::MatchResultListener* listener) const {
     ::google::protobuf::Message* expected_proto = arg.New();
     // We don't insist that the expected string parses as an
     // *initialized* protobuf.  Otherwise EqualsProto("...") may
diff --git a/ortools/base/small_map.h b/ortools/base/small_map.h
deleted file mode 100644
index aeca406d44..0000000000
--- a/ortools/base/small_map.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2010-2025 Google LLC
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef OR_TOOLS_BASE_SMALL_MAP_H_
-#define OR_TOOLS_BASE_SMALL_MAP_H_
-
-namespace gtl {
-template <class T>
-class small_map : public T {};
-}  // namespace gtl
-
-#endif  // OR_TOOLS_BASE_SMALL_MAP_H_
diff --git a/ortools/base/stl_logging.h b/ortools/base/stl_logging.h
deleted file mode 100644
index bd7bb50fd1..0000000000
--- a/ortools/base/stl_logging.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright 2010-2025 Google LLC
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef OR_TOOLS_BASE_STL_LOGGING_H_
-#define OR_TOOLS_BASE_STL_LOGGING_H_
-
-#include <deque>
-#include <list>
-#include <map>
-#include <ostream>
-#include <set>
-#include <utility>
-#include <vector>
-
-#include "absl/container/flat_hash_map.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/container/node_hash_map.h"
-#include "absl/container/node_hash_set.h"
-
-// Forward declare these two, and define them after all the container streams
-// operators so that we can recurse from pair -> container -> container -> pair
-// properly.
-template <class First, class Second>
-std::ostream& operator<<(std::ostream& out, const std::pair<First, Second>& p);
-
-namespace google {
-
-template <class Iter>
-void PrintSequence(std::ostream& out, Iter begin, Iter end);
-
-}  // namespace google
-
-#define OUTPUT_TWO_ARG_CONTAINER(Sequence)                       \
-  template <class T1, class T2>                                  \
-  inline std::ostream& operator<<(std::ostream& out,             \
-                                  const Sequence<T1, T2>& seq) { \
-    google::PrintSequence(out, seq.begin(), seq.end());          \
-    return out;                                                  \
-  }
-
-OUTPUT_TWO_ARG_CONTAINER(std::vector)
-OUTPUT_TWO_ARG_CONTAINER(std::deque)
-OUTPUT_TWO_ARG_CONTAINER(std::list)
-
-#undef OUTPUT_TWO_ARG_CONTAINER
-
-#define OUTPUT_THREE_ARG_CONTAINER(Sequence)                         \
-  template <class T1, class T2, class T3>                            \
-  inline std::ostream& operator<<(std::ostream& out,                 \
-                                  const Sequence<T1, T2, T3>& seq) { \
-    google::PrintSequence(out, seq.begin(), seq.end());              \
-    return out;                                                      \
-  }
-
-OUTPUT_THREE_ARG_CONTAINER(std::set)
-OUTPUT_THREE_ARG_CONTAINER(std::multiset)
-
-#undef OUTPUT_THREE_ARG_CONTAINER
-
-#define OUTPUT_FOUR_ARG_CONTAINER(Sequence)                              \
-  template <class T1, class T2, class T3, class T4>                      \
-  inline std::ostream& operator<<(std::ostream& out,                     \
-                                  const Sequence<T1, T2, T3, T4>& seq) { \
-    google::PrintSequence(out, seq.begin(), seq.end());                  \
-    return out;                                                          \
-  }
-
-OUTPUT_FOUR_ARG_CONTAINER(std::map)
-OUTPUT_FOUR_ARG_CONTAINER(std::multimap)
-OUTPUT_FOUR_ARG_CONTAINER(absl::flat_hash_set)
-OUTPUT_FOUR_ARG_CONTAINER(absl::node_hash_set)
-
-#undef OUTPUT_FOUR_ARG_CONTAINER
-
-#define OUTPUT_FIVE_ARG_CONTAINER(Sequence)                                  \
-  template <class T1, class T2, class T3, class T4, class T5>                \
-  inline std::ostream& operator<<(std::ostream& out,                         \
-                                  const Sequence<T1, T2, T3, T4, T5>& seq) { \
-    google::PrintSequence(out, seq.begin(), seq.end());                      \
-    return out;                                                              \
-  }
-
-OUTPUT_FIVE_ARG_CONTAINER(absl::flat_hash_map)
-OUTPUT_FIVE_ARG_CONTAINER(absl::node_hash_map)
-
-#undef OUTPUT_FIVE_ARG_CONTAINER
-
-template <class First, class Second>
-inline std::ostream& operator<<(std::ostream& out,
-                                const std::pair<First, Second>& p) {
-  out << '(' << p.first << ", " << p.second << ')';
-  return out;
-}
-
-namespace google {
-
-template <class Iter>
-inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
-  // Output at most 100 elements -- appropriate if used for logging.
-  for (int i = 0; begin != end && i < 100; ++i, ++begin) {
-    if (i > 0) out << ' ';
-    out << *begin;
-  }
-  if (begin != end) {
-    out << " ...";
-  }
-}
-
-}  // namespace google
-
-// Note that this is technically undefined behavior! We are adding things into
-// the std namespace for a reason though -- we are providing new operations on
-// types which are themselves defined with this namespace. Without this, these
-// operator overloads cannot be found via ADL. If these definitions are not
-// found via ADL, they must be #included before they're used, which requires
-// this header to be included before apparently independent other headers.
-//
-// For example, base/logging.h defines various template functions to implement
-// CHECK_EQ(x, y) and stream x and y into the log in the event the check fails.
-// It does so via the function template MakeCheckOpValueString:
-//   template<class T>
-//   void MakeCheckOpValueString(strstream* ss, const T& v) {
-//     (*ss) << v;
-//   }
-// Because 'logging.h' is included before 'stl_logging.h',
-// subsequent CHECK_EQ(v1, v2) for vector<...> typed variable v1 and v2 can only
-// find these operator definitions via ADL.
-//
-// Even this solution has problems -- it may pull unintended operators into the
-// namespace as well, allowing them to also be found via ADL, and creating code
-// that only works with a particular order of includes. Long term, we need to
-// move all of the *definitions* into namespace std, bet we need to ensure no
-// one references them first. This lets us take that step. We cannot define them
-// in both because that would create ambiguous overloads when both are found.
-namespace std {
-using ::operator<<;
-}
-
-#endif  // OR_TOOLS_BASE_STL_LOGGING_H_
diff --git a/ortools/bop/bop_solver.cc b/ortools/bop/bop_solver.cc
index 1c3ebe4930..71bc5be1bc 100644
--- a/ortools/bop/bop_solver.cc
+++ b/ortools/bop/bop_solver.cc
@@ -167,6 +167,7 @@ BopSolveStatus BopSolver::SolveWithTimeLimit(const BopSolution& first_solution,
     VLOG(1)
         << "First solution is infeasible. Using it as assignment preference.";
     std::vector<bool> assignment_preference;
+    assignment_preference.reserve(first_solution.Size());
     for (int i = 0; i < first_solution.Size(); ++i) {
       assignment_preference.push_back(first_solution.Value(VariableIndex(i)));
     }
diff --git a/ortools/dotnet/Google.OrTools-full.csproj.in b/ortools/dotnet/Google.OrTools-full.csproj.in
index 9945e956c0..5ac80e65e3 100644
--- a/ortools/dotnet/Google.OrTools-full.csproj.in
+++ b/ortools/dotnet/Google.OrTools-full.csproj.in
@@ -184,7 +184,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.31.1"/>
+    <PackageReference Include="Google.Protobuf" Version="3.32.0"/>
   </ItemGroup>
 
   <!-- Need to add required runtime dependencies so Meta-Project will pull runtime Nuget(s) -->
diff --git a/ortools/dotnet/Google.OrTools-local.csproj.in b/ortools/dotnet/Google.OrTools-local.csproj.in
index e07af1825a..edff73523c 100644
--- a/ortools/dotnet/Google.OrTools-local.csproj.in
+++ b/ortools/dotnet/Google.OrTools-local.csproj.in
@@ -172,7 +172,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.31.1"/>
+    <PackageReference Include="Google.Protobuf" Version="3.32.0"/>
   </ItemGroup>
 
   <!-- Need to add required runtime dependencies so Meta-Project will pull runtime Nuget(s) -->
diff --git a/ortools/dotnet/Google.OrTools.runtime.csproj.in b/ortools/dotnet/Google.OrTools.runtime.csproj.in
index cb57d49ab2..c565b1b1bb 100644
--- a/ortools/dotnet/Google.OrTools.runtime.csproj.in
+++ b/ortools/dotnet/Google.OrTools.runtime.csproj.in
@@ -68,6 +68,7 @@
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::int128>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::kernel_timeout_internal>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::leak_check>>
+      $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::log_entry>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::log_flags>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::log_globals>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::log_initialize>>
@@ -83,7 +84,6 @@
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::log_internal_proto>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::log_severity>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::log_sink>>
-      $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::low_level_hash>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::malloc_internal>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::random_distributions>>
       $<@need_unix_absl_lib@:;$<TARGET_SONAME_FILE:absl::random_internal_entropy_pool>>
diff --git a/ortools/flatzinc/BUILD.bazel b/ortools/flatzinc/BUILD.bazel
index ec57d91ccc..8d84487fbd 100644
--- a/ortools/flatzinc/BUILD.bazel
+++ b/ortools/flatzinc/BUILD.bazel
@@ -20,27 +20,6 @@ load("@rules_cc//cc:cc_library.bzl", "cc_library")
 
 package(default_visibility = ["//visibility:public"])
 
-config_setting(
-    name = "on_linux",
-    constraint_values = [
-        "@platforms//os:linux",
-    ],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = [
-        "@platforms//os:macos",
-    ],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = [
-        "@platforms//os:windows",
-    ],
-)
-
 # ---------------------------------------------------------------------------
 # Baseline flatzinc model.
 # ---------------------------------------------------------------------------
@@ -88,9 +67,8 @@ cc_library(
     name = "parser_lex_lib",
     srcs = ["parser.yy.cc"],
     copts = select({
-        "on_linux": ["-Wno-unused-function"],  # parser.yy.cc
-        "on_macos": ["-Wno-unused-function"],  # parser.yy.cc
-        "on_windows": [],
+        "@platforms//os:linux": ["-Wno-unused-function"],  # parser.yy.cc
+        "@platforms//os:macos": ["-Wno-unused-function"],  # parser.yy.cc
         "//conditions:default": [],
     }),
     deps = [
diff --git a/ortools/flatzinc/checker.cc b/ortools/flatzinc/checker.cc
index 7e8d529f43..5daee430b3 100644
--- a/ortools/flatzinc/checker.cc
+++ b/ortools/flatzinc/checker.cc
@@ -169,6 +169,24 @@ bool CheckAllDifferentInt(
   return true;
 }
 
+bool CheckAllDifferentSet(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  std::vector<std::vector<int64_t>> values;
+  values.reserve(Length(ct.arguments[0]));
+  for (int i = 0; i < Length(ct.arguments[0]); ++i) {
+    values.push_back(SetEvalAt(ct.arguments[0], i, set_evaluator));
+  }
+  for (int i = 0; i + 1 < values.size(); ++i) {
+    for (int j = i + 1; j < values.size(); ++j) {
+      if (values[i] == values[j]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 bool CheckAlldifferentExcept0(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
@@ -184,6 +202,21 @@ bool CheckAlldifferentExcept0(
   return true;
 }
 
+bool CheckAllDisjoint(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  absl::flat_hash_set<int64_t> visited;
+  for (int i = 0; i < Length(ct.arguments[0]); ++i) {
+    for (const int64_t value : SetEvalAt(ct.arguments[0], i, set_evaluator)) {
+      if (visited.contains(value)) {
+        return false;
+      }
+      visited.insert(value);
+    }
+  }
+  return true;
+}
+
 bool CheckAmong(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
@@ -265,7 +298,25 @@ bool CheckArrayVarIntElement(
   return element == target;
 }
 
-bool CheckOrtoolsArrayIntElement(
+bool CheckOrToolsArgMaxInt(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  const int rank = evaluator(ct.arguments[1].Var());
+  const int min_index = ct.arguments[2].Value();
+  const int multiplier = ct.arguments[3].Value();
+  int index = -1;
+  int64_t max_value = std::numeric_limits<int64_t>::min();
+  for (int i = 0; i < Length(ct.arguments[0]); ++i) {
+    const int64_t value = EvalAt(ct.arguments[0], i, evaluator) * multiplier;
+    if (value > max_value) {
+      max_value = value;
+      index = i;
+    }
+  }
+  return index + min_index == rank;
+}
+
+bool CheckOrToolsArrayIntElement(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const int64_t min_index = ct.arguments[1].values[0];
@@ -342,7 +393,19 @@ bool CheckBoolXor(
   return target == (left + right == 1);
 }
 
-bool CheckOrtoolsCircuit(
+bool CheckDisjoint(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
+  const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
+  std::vector<int64_t> computed_intersection;
+  std::set_intersection(values_x.begin(), values_x.end(), values_y.begin(),
+                        values_y.end(),
+                        std::back_inserter(computed_intersection));
+  return computed_intersection.empty();
+}
+
+bool CheckOrToolsCircuit(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const int size = Length(ct.arguments[0]);
@@ -358,7 +421,7 @@ bool CheckOrtoolsCircuit(
   return visited.size() == size;
 }
 
-bool CheckOrtoolsBinPacking(
+bool CheckOrToolsBinPacking(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const int64_t capacity = ct.arguments[0].Value();
@@ -377,7 +440,7 @@ bool CheckOrtoolsBinPacking(
   return true;
 }
 
-bool CheckOrtoolsBinPackingCapa(
+bool CheckOrToolsBinPackingCapa(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const std::vector<int64_t>& capacities = ct.arguments[0].values;
@@ -398,7 +461,7 @@ bool CheckOrtoolsBinPackingCapa(
   return true;
 }
 
-bool CheckOrtoolsBinPackingLoad(
+bool CheckOrToolsBinPackingLoad(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const int num_positions = Length(ct.arguments[1]);
@@ -420,7 +483,7 @@ bool CheckOrtoolsBinPackingLoad(
   return true;
 }
 
-bool CheckOrtoolsNValue(
+bool CheckOrToolsNValue(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const int64_t card = Eval(ct.arguments[0], evaluator);
@@ -441,7 +504,7 @@ int64_t ComputeCount(const Constraint& ct,
   return result;
 }
 
-bool CheckOrtoolsCountEq(
+bool CheckOrToolsCountEq(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const int64_t count = ComputeCount(ct, evaluator);
@@ -521,7 +584,7 @@ bool CheckCumulative(
   return true;
 }
 
-bool CheckOrtoolsCumulativeOpt(
+bool CheckOrToolsCumulativeOpt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   // TODO: Improve complexity for large durations.
@@ -617,7 +680,7 @@ bool CheckDisjunctiveStrict(
   return true;
 }
 
-bool CheckOrtoolsDisjunctiveStrictOpt(
+bool CheckOrToolsDisjunctiveStrictOpt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const int size = Length(ct.arguments[0]);
@@ -640,6 +703,29 @@ bool CheckOrtoolsDisjunctiveStrictOpt(
   return true;
 }
 
+bool CheckPartitionSet(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  absl::flat_hash_set<int64_t> visited;
+  for (int i = 0; i < Length(ct.arguments[0]); ++i) {
+    for (const int64_t value : SetEvalAt(ct.arguments[0], i, set_evaluator)) {
+      if (visited.contains(value)) {
+        return false;
+      }
+      visited.insert(value);
+    }
+  }
+  const std::vector<int64_t> universe = SetEval(ct.arguments[1], set_evaluator);
+  if (universe.size() != visited.size()) return false;
+  for (const int64_t value : universe) {
+    if (!visited.contains(value)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool CheckFalseConstraint(
     const Constraint& /*ct*/,
     const std::function<int64_t(Variable*)>& /*evaluator*/,
@@ -665,92 +751,51 @@ std::vector<int64_t> ComputeGlobalCardinalityCards(
   return cards;
 }
 
-bool CheckGlobalCardinality(
+bool CheckOrToolsGlobalCardinality(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const std::vector<int64_t> cards =
       ComputeGlobalCardinalityCards(ct, evaluator);
   CHECK_EQ(cards.size(), Length(ct.arguments[2]));
+  const bool is_closed = Eval(ct.arguments[3], evaluator) != 0;
   for (int i = 0; i < Length(ct.arguments[2]); ++i) {
     const int64_t card = EvalAt(ct.arguments[2], i, evaluator);
     if (card != cards[i]) {
       return false;
     }
   }
+
+  if (is_closed) {
+    int64_t sum_of_cards = 0;
+    for (int64_t card : cards) {
+      sum_of_cards += card;
+    }
+    return sum_of_cards == Length(ct.arguments[0]);
+  }
   return true;
 }
 
-bool CheckGlobalCardinalityClosed(
-    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
-    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
-  const std::vector<int64_t> cards =
-      ComputeGlobalCardinalityCards(ct, evaluator);
-  CHECK_EQ(cards.size(), Length(ct.arguments[2]));
-  for (int i = 0; i < Length(ct.arguments[2]); ++i) {
-    const int64_t card = EvalAt(ct.arguments[2], i, evaluator);
-    if (card != cards[i]) {
-      return false;
-    }
-  }
-  int64_t sum_of_cards = 0;
-  for (int64_t card : cards) {
-    sum_of_cards += card;
-  }
-  return sum_of_cards == Length(ct.arguments[0]);
-}
-
-bool CheckGlobalCardinalityLowUp(
+bool CheckOrToolsGlobalCardinalityLowUp(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   const std::vector<int64_t> cards =
       ComputeGlobalCardinalityCards(ct, evaluator);
   CHECK_EQ(cards.size(), ct.arguments[2].values.size());
   CHECK_EQ(cards.size(), ct.arguments[3].values.size());
+  const bool is_closed = Eval(ct.arguments[4], evaluator) != 0;
   for (int i = 0; i < cards.size(); ++i) {
     const int64_t card = cards[i];
     if (card < ct.arguments[2].values[i] || card > ct.arguments[3].values[i]) {
       return false;
     }
   }
-  return true;
-}
 
-bool CheckGlobalCardinalityLowUpClosed(
-    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
-    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
-  const std::vector<int64_t> cards =
-      ComputeGlobalCardinalityCards(ct, evaluator);
-  CHECK_EQ(cards.size(), ct.arguments[2].values.size());
-  CHECK_EQ(cards.size(), ct.arguments[3].values.size());
-  for (int i = 0; i < cards.size(); ++i) {
-    const int64_t card = cards[i];
-    if (card < ct.arguments[2].values[i] || card > ct.arguments[3].values[i]) {
-      return false;
-    }
-  }
-  int64_t sum_of_cards = 0;
-  for (int64_t card : cards) {
-    sum_of_cards += card;
-  }
-  return sum_of_cards == Length(ct.arguments[0]);
-}
-
-bool CheckGlobalCardinalityOld(
-    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
-    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
-  const int size = Length(ct.arguments[1]);
-  std::vector<int64_t> cards(size, 0);
-  for (int i = 0; i < Length(ct.arguments[0]); ++i) {
-    const int64_t value = EvalAt(ct.arguments[0], i, evaluator);
-    if (value >= 0 && value < size) {
-      cards[value]++;
-    }
-  }
-  for (int i = 0; i < size; ++i) {
-    const int64_t card = EvalAt(ct.arguments[1], i, evaluator);
-    if (card != cards[i]) {
-      return false;
+  if (is_closed) {
+    int64_t sum_of_cards = 0;
+    for (int64_t card : cards) {
+      sum_of_cards += card;
     }
+    return sum_of_cards == Length(ct.arguments[0]);
   }
   return true;
 }
@@ -1104,7 +1149,7 @@ bool CheckIntTimes(
   return target == left * right;
 }
 
-bool CheckOrtoolsInverse(
+bool CheckOrToolsInverse(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   CHECK_EQ(Length(ct.arguments[0]), Length(ct.arguments[1]));
@@ -1132,11 +1177,12 @@ bool CheckOrtoolsInverse(
   return true;
 }
 
-bool CheckLexLessInt(
+bool CheckOrToolsLexLessInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
-  CHECK_EQ(Length(ct.arguments[0]), Length(ct.arguments[1]));
-  for (int i = 0; i < Length(ct.arguments[0]); ++i) {
+  const int min_size =
+      std::min(Length(ct.arguments[0]), Length(ct.arguments[1]));
+  for (int i = 0; i < min_size; ++i) {
     const int64_t x = EvalAt(ct.arguments[0], i, evaluator);
     const int64_t y = EvalAt(ct.arguments[1], i, evaluator);
     if (x < y) {
@@ -1146,15 +1192,16 @@ bool CheckLexLessInt(
       return false;
     }
   }
-  // We are at the end of the list. The two chains are equals.
-  return false;
+  // We are at the end of the common list. We compare the lengths of the lists.
+  return Length(ct.arguments[1]) > Length(ct.arguments[0]);
 }
 
-bool CheckLexLesseqInt(
+bool CheckOrToolsLexLesseqInt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
-  CHECK_EQ(Length(ct.arguments[0]), Length(ct.arguments[1]));
-  for (int i = 0; i < Length(ct.arguments[0]); ++i) {
+  const int min_size =
+      std::min(Length(ct.arguments[0]), Length(ct.arguments[1]));
+  for (int i = 0; i < min_size; ++i) {
     const int64_t x = EvalAt(ct.arguments[0], i, evaluator);
     const int64_t y = EvalAt(ct.arguments[1], i, evaluator);
     if (x < y) {
@@ -1164,8 +1211,8 @@ bool CheckLexLesseqInt(
       return false;
     }
   }
-  // We are at the end of the list. The two chains are equals.
-  return true;
+  // We are at the end of the common list. We compare the lengths of the lists.
+  return Length(ct.arguments[1]) >= Length(ct.arguments[0]);
 }
 
 bool CheckMaximumArgInt(
@@ -1251,7 +1298,7 @@ bool CheckNetworkFlowConservation(
   return true;
 }
 
-bool CheckOrtoolsNetworkFlow(
+bool CheckOrToolsNetworkFlow(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   return CheckNetworkFlowConservation(ct.arguments[0], ct.arguments[1],
@@ -1259,7 +1306,7 @@ bool CheckOrtoolsNetworkFlow(
                                       evaluator);
 }
 
-bool CheckOrtoolsNetworkFlowCost(
+bool CheckOrToolsNetworkFlowCost(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   if (!CheckNetworkFlowConservation(ct.arguments[0], ct.arguments[1],
@@ -1279,7 +1326,7 @@ bool CheckOrtoolsNetworkFlowCost(
   return total_cost == Eval(ct.arguments[5], evaluator);
 }
 
-bool CheckOrtoolsRegular(
+bool CheckOrToolsRegular(
     const Constraint& /*ct*/,
     const std::function<int64_t(Variable*)>& /*evaluator*/,
     const std::function<std::vector<int64_t>(Variable*)>& /*set_evaluator*/) {
@@ -1344,8 +1391,6 @@ bool CheckSetIntersect(
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
-  absl::flat_hash_set<int64_t> set_x(values_x.begin(), values_x.end());
-  absl::flat_hash_set<int64_t> set_y(values_y.begin(), values_y.end());
   absl::flat_hash_set<int64_t> set_r(values_r.begin(), values_r.end());
   absl::flat_hash_set<int64_t> computed_intersection;
   std::set_intersection(
@@ -1360,8 +1405,6 @@ bool CheckSetUnion(
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
-  absl::flat_hash_set<int64_t> set_x(values_x.begin(), values_x.end());
-  absl::flat_hash_set<int64_t> set_y(values_y.begin(), values_y.end());
   absl::flat_hash_set<int64_t> set_r(values_r.begin(), values_r.end());
   absl::flat_hash_set<int64_t> computed_intersection;
   std::set_union(
@@ -1414,8 +1457,6 @@ bool CheckSetDiff(
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
-  absl::flat_hash_set<int64_t> set_x(values_x.begin(), values_x.end());
-  absl::flat_hash_set<int64_t> set_y(values_y.begin(), values_y.end());
   absl::flat_hash_set<int64_t> set_r(values_r.begin(), values_r.end());
   absl::flat_hash_set<int64_t> computed_diff;
   std::set_difference(values_x.begin(), values_x.end(), values_y.begin(),
@@ -1430,8 +1471,6 @@ bool CheckSetSymDiff(
   const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
   const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
   const std::vector<int64_t> values_r = SetEval(ct.arguments[2], set_evaluator);
-  absl::flat_hash_set<int64_t> set_x(values_x.begin(), values_x.end());
-  absl::flat_hash_set<int64_t> set_y(values_y.begin(), values_y.end());
   absl::flat_hash_set<int64_t> set_r(values_r.begin(), values_r.end());
   absl::flat_hash_set<int64_t> computed_sym_diff;
   std::set_symmetric_difference(
@@ -1478,6 +1517,25 @@ bool CheckSetLe(
   return values_y.size() >= values_x.size();
 }
 
+bool CheckSetLeReif(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
+  const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
+  const int min_size = std::min(values_x.size(), values_y.size());
+  const bool status = Eval(ct.arguments[2], evaluator) != 0;
+
+  const bool expected_status = [&]() {
+    for (int i = 0; i < min_size; ++i) {
+      if (values_x[i] < values_y[i]) return true;
+      if (values_x[i] > values_y[i]) return false;
+    }
+    return values_y.size() >= values_x.size();
+  }();
+
+  return expected_status == status;
+}
+
 bool CheckSetLt(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
@@ -1491,6 +1549,25 @@ bool CheckSetLt(
   return values_y.size() > values_x.size();
 }
 
+bool CheckSetLtReif(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  const std::vector<int64_t> values_x = SetEval(ct.arguments[0], set_evaluator);
+  const std::vector<int64_t> values_y = SetEval(ct.arguments[1], set_evaluator);
+  const int min_size = std::min(values_x.size(), values_y.size());
+  const bool status = Eval(ct.arguments[2], evaluator) != 0;
+
+  const bool expected_status = [&]() {
+    for (int i = 0; i < min_size; ++i) {
+      if (values_x[i] < values_y[i]) return true;
+      if (values_x[i] > values_y[i]) return false;
+    }
+    return values_y.size() > values_x.size();
+  }();
+
+  return expected_status == status;
+}
+
 bool CheckSetNeReif(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
@@ -1546,7 +1623,7 @@ bool CheckSort(
   return true;
 }
 
-bool CheckOrtoolsSubCircuit(
+bool CheckOrToolsSubCircuit(
     const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
     const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
   absl::flat_hash_set<int64_t> visited;
@@ -1577,7 +1654,7 @@ bool CheckOrtoolsSubCircuit(
   return visited.size() == Length(ct.arguments[0]);
 }
 
-bool CheckOrtoolsTableInt(
+bool CheckOrToolsTableInt(
     const Constraint& /*ct*/,
     const std::function<int64_t(Variable*)>& /*evaluator*/,
     const std::function<std::vector<int64_t>(Variable*)>& /*set_evaluator*/) {
@@ -1601,6 +1678,51 @@ bool CheckSymmetricAllDifferent(
   return true;
 }
 
+bool CheckValuePrecedeInt(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  const int64_t before = ct.arguments[0].Value();
+  const int64_t after = ct.arguments[1].Value();
+  const int64_t length = Length(ct.arguments[2]);
+  bool before_found = false;
+  for (int i = 0; i < length; ++i) {
+    const int64_t current = EvalAt(ct.arguments[2], i, evaluator);
+    if (current == before) before_found = true;
+    if (current == after && !before_found) return false;
+  }
+  return true;
+}
+
+bool CheckOrToolsPrecedeChainInt(
+    const Constraint& ct, const std::function<int64_t(Variable*)>& evaluator,
+    const std::function<std::vector<int64_t>(Variable*)>& set_evaluator) {
+  absl::flat_hash_map<int64_t, int> value_to_index;
+  if (ct.arguments[0].type == fz::Argument::INT_INTERVAL) {
+    for (int64_t v = ct.arguments[0].values[0]; v <= ct.arguments[0].values[1];
+         ++v) {
+      value_to_index[v] = value_to_index.size();
+      ;
+    }
+  } else if (ct.arguments[0].type == fz::Argument::INT_LIST) {
+    for (int64_t v : ct.arguments[0].values) {
+      value_to_index[v] = value_to_index.size();
+    }
+  } else {
+    LOG(FATAL) << "Unsupported argument type: " << ct.arguments[0].type;
+  }
+
+  int max_visited_index = -1;
+  const int64_t length = Length(ct.arguments[1]);
+  for (int i = 0; i < length; ++i) {
+    const int64_t current = EvalAt(ct.arguments[1], i, evaluator);
+    const auto it = value_to_index.find(current);
+    if (it == value_to_index.end()) continue;
+    if (it->second > max_visited_index + 1) return false;
+    if (it->second == max_visited_index + 1) ++max_visited_index;
+  }
+  return true;
+}
+
 using CallMap = absl::flat_hash_map<
     std::string,
     std::function<bool(const Constraint& ct, std::function<int64_t(Variable*)>,
@@ -1658,29 +1780,29 @@ CallMap CreateCallMap() {
   m["bool_right_imp"] = CheckIntGe;
   m["bool_xor"] = CheckBoolXor;
   m["bool2int"] = CheckIntEq;
-  m["count_eq"] = CheckOrtoolsCountEq;
+  m["count_eq"] = CheckOrToolsCountEq;
   m["count_geq"] = CheckCountGeq;
   m["count_gt"] = CheckCountGt;
   m["count_leq"] = CheckCountLeq;
   m["count_lt"] = CheckCountLt;
   m["count_neq"] = CheckCountNeq;
   m["count_reif"] = CheckCountReif;
-  m["count"] = CheckOrtoolsCountEq;
+  m["count"] = CheckOrToolsCountEq;
   m["diffn_k_with_sizes"] = CheckDiffnK;
   m["diffn_nonstrict_k_with_sizes"] = CheckDiffnNonStrictK;
   m["false_constraint"] = CheckFalseConstraint;
   m["fixed_cumulative"] = CheckCumulative;
   m["fzn_all_different_int"] = CheckAllDifferentInt;
+  m["fzn_all_different_set"] = CheckAllDifferentSet;
+  m["fzn_all_disjoint"] = CheckAllDisjoint;
   m["fzn_cumulative"] = CheckCumulative;
   m["fzn_diffn_nonstrict"] = CheckDiffnNonStrict;
   m["fzn_diffn"] = CheckDiffn;
+  m["fzn_disjoint"] = CheckDisjoint;
   m["fzn_disjunctive_strict"] = CheckDisjunctiveStrict;
   m["fzn_disjunctive"] = CheckDisjunctive;
-  m["global_cardinality_closed"] = CheckGlobalCardinalityClosed;
-  m["global_cardinality_low_up_closed"] = CheckGlobalCardinalityLowUpClosed;
-  m["global_cardinality_low_up"] = CheckGlobalCardinalityLowUp;
-  m["global_cardinality_old"] = CheckGlobalCardinalityOld;
-  m["global_cardinality"] = CheckGlobalCardinality;
+  m["fzn_partition_set"] = CheckPartitionSet;
+  m["fzn_value_precede_int"] = CheckValuePrecedeInt;
   m["int_abs"] = CheckIntAbs;
   m["int_div"] = CheckIntDiv;
   m["int_eq_imp"] = CheckIntEqImp;
@@ -1722,34 +1844,39 @@ CallMap CreateCallMap() {
   m["int_not_in"] = CheckSetNotIn;
   m["int_plus"] = CheckIntPlus;
   m["int_times"] = CheckIntTimes;
-  m["lex_less_bool"] = CheckLexLessInt;
-  m["lex_less_int"] = CheckLexLessInt;
-  m["lex_lesseq_bool"] = CheckLexLesseqInt;
-  m["lex_lesseq_int"] = CheckLexLesseqInt;
   m["maximum_arg_int"] = CheckMaximumArgInt;
   m["maximum_int"] = CheckMaximumInt;
   m["minimum_arg_int"] = CheckMinimumArgInt;
   m["minimum_int"] = CheckMinimumInt;
-  m["ortools_array_bool_element"] = CheckOrtoolsArrayIntElement;
-  m["ortools_array_int_element"] = CheckOrtoolsArrayIntElement;
-  m["ortools_array_var_bool_element"] = CheckOrtoolsArrayIntElement;
-  m["ortools_array_var_int_element"] = CheckOrtoolsArrayIntElement;
-  m["ortools_bin_packing_capa"] = CheckOrtoolsBinPackingCapa;
-  m["ortools_bin_packing_load"] = CheckOrtoolsBinPackingLoad;
-  m["ortools_bin_packing"] = CheckOrtoolsBinPacking;
-  m["ortools_circuit"] = CheckOrtoolsCircuit;
-  m["ortools_count_eq_cst"] = CheckOrtoolsCountEq;
-  m["ortools_count_eq"] = CheckOrtoolsCountEq;
-  m["ortools_cumulative_opt"] = CheckOrtoolsCumulativeOpt;
-  m["ortools_disjunctive_strict_opt"] = CheckOrtoolsDisjunctiveStrictOpt;
-  m["ortools_inverse"] = CheckOrtoolsInverse;
-  m["ortools_network_flow_cost"] = CheckOrtoolsNetworkFlowCost;
-  m["ortools_network_flow"] = CheckOrtoolsNetworkFlow;
-  m["ortools_nvalue"] = CheckOrtoolsNValue;
-  m["ortools_regular"] = CheckOrtoolsRegular;
-  m["ortools_subcircuit"] = CheckOrtoolsSubCircuit;
-  m["ortools_table_bool"] = CheckOrtoolsTableInt;
-  m["ortools_table_int"] = CheckOrtoolsTableInt;
+  m["ortools_arg_max_bool"] = CheckOrToolsArgMaxInt;
+  m["ortools_arg_max_int"] = CheckOrToolsArgMaxInt;
+  m["ortools_array_bool_element"] = CheckOrToolsArrayIntElement;
+  m["ortools_array_int_element"] = CheckOrToolsArrayIntElement;
+  m["ortools_array_var_bool_element"] = CheckOrToolsArrayIntElement;
+  m["ortools_array_var_int_element"] = CheckOrToolsArrayIntElement;
+  m["ortools_bin_packing_capa"] = CheckOrToolsBinPackingCapa;
+  m["ortools_bin_packing_load"] = CheckOrToolsBinPackingLoad;
+  m["ortools_bin_packing"] = CheckOrToolsBinPacking;
+  m["ortools_circuit"] = CheckOrToolsCircuit;
+  m["ortools_count_eq_cst"] = CheckOrToolsCountEq;
+  m["ortools_count_eq"] = CheckOrToolsCountEq;
+  m["ortools_cumulative_opt"] = CheckOrToolsCumulativeOpt;
+  m["ortools_disjunctive_strict_opt"] = CheckOrToolsDisjunctiveStrictOpt;
+  m["ortools_global_cardinality_low_up"] = CheckOrToolsGlobalCardinalityLowUp;
+  m["ortools_global_cardinality"] = CheckOrToolsGlobalCardinality;
+  m["ortools_inverse"] = CheckOrToolsInverse;
+  m["ortools_lex_less_bool"] = CheckOrToolsLexLessInt;
+  m["ortools_lex_less_int"] = CheckOrToolsLexLessInt;
+  m["ortools_lex_lesseq_bool"] = CheckOrToolsLexLesseqInt;
+  m["ortools_lex_lesseq_int"] = CheckOrToolsLexLesseqInt;
+  m["ortools_network_flow_cost"] = CheckOrToolsNetworkFlowCost;
+  m["ortools_network_flow"] = CheckOrToolsNetworkFlow;
+  m["ortools_nvalue"] = CheckOrToolsNValue;
+  m["ortools_precede_chain_int"] = CheckOrToolsPrecedeChainInt;
+  m["ortools_regular"] = CheckOrToolsRegular;
+  m["ortools_subcircuit"] = CheckOrToolsSubCircuit;
+  m["ortools_table_bool"] = CheckOrToolsTableInt;
+  m["ortools_table_int"] = CheckOrToolsTableInt;
   m["regular_nfa"] = CheckRegularNfa;
   m["set_card"] = CheckSetCard;
   m["set_diff"] = CheckSetDiff;
@@ -1760,6 +1887,8 @@ CallMap CreateCallMap() {
   m["set_intersect"] = CheckSetIntersect;
   m["set_le"] = CheckSetLe;
   m["set_lt"] = CheckSetLt;
+  m["set_le_reif"] = CheckSetLeReif;
+  m["set_lt_reif"] = CheckSetLtReif;
   m["set_ne_reif"] = CheckSetNeReif;
   m["set_ne"] = CheckSetNe;
   m["set_not_in"] = CheckSetNotIn;
@@ -1787,6 +1916,7 @@ bool CheckSolution(
   const CallMap call_map = CreateCallMap();
   for (Constraint* ct : model.constraints()) {
     if (!ct->active) continue;
+    DCHECK(call_map.contains(ct->type)) << ct->type;
     const auto& checker = call_map.at(ct->type);
     if (!checker(*ct, evaluator, set_evaluator)) {
       SOLVER_LOG(logger, "Failing constraint ", ct->DebugString());
diff --git a/ortools/flatzinc/cp_model_fz_solver.cc b/ortools/flatzinc/cp_model_fz_solver.cc
index cd4a25fb46..4064542707 100644
--- a/ortools/flatzinc/cp_model_fz_solver.cc
+++ b/ortools/flatzinc/cp_model_fz_solver.cc
@@ -18,11 +18,13 @@
 #include <functional>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
+#include "absl/algorithm/container.h"
 #include "absl/container/btree_map.h"
 #include "absl/container/btree_set.h"
 #include "absl/container/flat_hash_map.h"
@@ -53,9 +55,8 @@ ABSL_FLAG(int64_t, fz_int_max, int64_t{1} << 40,
           "Default max value for unbounded integer variables.");
 ABSL_FLAG(bool, force_interleave_search, false,
           "If true, enable interleaved workers when num_workers is 1.");
-ABSL_FLAG(bool, fz_light_full_encoding, false,
-          "EXPERIMENTAL: Use the at_most_one encoding when fully encoding a "
-          "variable.");
+ABSL_FLAG(bool, fz_use_light_encoding, false,
+          "Use lighter encodings for the model");
 
 // TODO(user): SetIn forces card to be > 0.
 
@@ -75,6 +76,7 @@ struct SetVariable {
   std::vector<int> var_indices;
   std::vector<int64_t> sorted_values;
   int card_var_index = kNoVar;
+  std::optional<int> fixed_card = std::nullopt;
 
   int find_value_index(int64_t value) const {
     const auto it =
@@ -86,9 +88,10 @@ struct SetVariable {
 
 // Helper class to convert a flatzinc model to a CpModelProto.
 struct CpModelProtoWithMapping {
-  CpModelProtoWithMapping()
+  CpModelProtoWithMapping(bool sat_enumeration)
       : arena(std::make_unique<google::protobuf::Arena>()),
-        proto(*google::protobuf::Arena::Create<CpModelProto>(arena.get())) {}
+        proto(*google::protobuf::Arena::Create<CpModelProto>(arena.get())),
+        sat_enumeration_(sat_enumeration) {}
 
   // Returns the index of a new boolean variable.
   int NewBoolVar();
@@ -116,9 +119,11 @@ struct CpModelProtoWithMapping {
                                      bool negate = false);
   std::vector<int> LookupVars(const fz::Argument& argument);
   VarOrValue LookupVarOrValue(const fz::Argument& argument);
-
   std::vector<VarOrValue> LookupVarsOrValues(const fz::Argument& argument);
 
+  // Checks is the domain of the variable is included in [0, 1].
+  bool VariableIsBoolean(int var) const;
+
   // Set variables.
   void ExtractSetConstraint(const fz::Constraint& fz_ct);
   bool ConstraintContainsSetVariables(const fz::Constraint& constraint) const;
@@ -126,14 +131,33 @@ struct CpModelProtoWithMapping {
   std::shared_ptr<SetVariable> LookupSetVarAt(const fz::Argument& argument,
                                               int pos);
 
-  // Get or create a literal that is equivalent to var == value.
-  int GetOrCreateLiteralForVarEqValue(int var, int64_t value);
+  // literal <=> (var op value).
+  int GetOrCreateEncodingLiteral(int var, int64_t value);
+  std::optional<int> GetEncodingLiteral(int var, int64_t value);
+  void AddVarEqValueLiteral(int var, int64_t value, int literal);
+  void AddVarGeValueLiteral(int var, int64_t value, int literal);
+  void AddVarGtValueLiteral(int var, int64_t value, int literal);
+  void AddVarLeValueLiteral(int var, int64_t value, int literal);
+  void AddVarLtValueLiteral(int var, int64_t value, int literal);
 
-  // Get or create a literal that is equivalent to var1 == var2.
+  // literal <=> (var1 op var2).
   int GetOrCreateLiteralForVarEqVar(int var1, int var2);
+  void AddVarEqVarLiteral(int var1, int var2, int literal);
+  std::optional<int> GetVarEqVarLiteral(int var1, int var2);
+  int GetOrCreateLiteralForVarNeVar(int var1, int var2);
+  std::optional<int> GetVarNeVarLiteral(int var1, int var2);
+  void AddVarNeVarLiteral(int var1, int var2, int literal);
+  int GetOrCreateLiteralForVarLeVar(int var1, int var2);
+  std::optional<int> GetVarLeVarLiteral(int var1, int var2);
+  void AddVarLeVarLiteral(int var1, int var2, int literal);
+  int GetOrCreateLiteralForVarLtVar(int var1, int var2);
+  std::optional<int> GetVarLtVarLiteral(int var1, int var2);
+  void AddVarLtVarLiteral(int var1, int var2, int literal);
+  void AddVarOrVarLiteral(int var1, int var2, int literal);
+  void AddVarAndVarLiteral(int var1, int var2, int literal);
 
   // Returns the list of literals corresponding to the domain of the variable.
-  absl::flat_hash_map<int64_t, int> FullyEncode(int var);
+  absl::btree_map<int64_t, int> GetFullEncoding(int var);
 
   // Create and return the indices of the IntervalConstraint corresponding
   // to the flatzinc "interval" specified by a start var and a size var.
@@ -172,7 +196,13 @@ struct CpModelProtoWithMapping {
       absl::Span<const int> enforcement_literals, const Domain& domain,
       absl::Span<const std::pair<int, int64_t>> terms = {});
 
-  // Helpers to fill a ConstraintProto.
+  // Adds a lex_less{eq} constraint to the model.
+  void AddLexOrdering(absl::Span<const int> x, absl::Span<const int> y,
+                      int enforcement_literal, bool accepts_equals);
+
+  // Enforces that x_array != y_array.
+  void AddLiteralVectorsNotEqual(absl::Span<const int> x_array,
+                                 absl::Span<const int> y_array);
 
   // This one must be called after the domain has been set.
   void AddTermToLinearConstraint(int var, int64_t coeff,
@@ -182,12 +212,14 @@ struct CpModelProtoWithMapping {
   void FillLinearConstraintWithGivenDomain(absl::Span<const int64_t> domain,
                                            const fz::Constraint& fz_ct,
                                            ConstraintProto* ct);
-  void FillConstraint(const fz::Constraint& fz_ct, ConstraintProto* ct);
-  void FillReifOrImpliedConstraint(const fz::Constraint& fz_ct,
-                                   ConstraintProto* ct);
   void BuildTableFromDomainIntLinEq(const fz::Constraint& fz_ct,
                                     ConstraintProto* ct);
 
+  void FirstPass(const fz::Constraint& fz_ct);
+  void FillConstraint(const fz::Constraint& fz_ct, ConstraintProto* ct);
+  void FillReifiedOrImpliedConstraint(const fz::Constraint& fz_ct);
+  void AddAllEncodingConstraints();
+
   // This function takes a list of set variables, normalize them to have all the
   // same domain then fill var_booleans[i][j] with the booleans encoding the
   // j-th possible value of the i-th set variable.
@@ -205,6 +237,7 @@ struct CpModelProtoWithMapping {
   std::unique_ptr<google::protobuf::Arena> arena;
   CpModelProto& proto;
   SatParameters parameters;
+  const bool sat_enumeration_;
 
   // Mapping from flatzinc variables to CpModelProto variables.
   absl::flat_hash_map<fz::Variable*, int> fz_var_to_index;
@@ -212,17 +245,31 @@ struct CpModelProtoWithMapping {
   absl::flat_hash_map<std::tuple<int, int64_t, int, int64_t, int>, int>
       interval_key_to_index;
   absl::flat_hash_map<int, int> var_to_lit_implies_greater_than_zero;
-  absl::flat_hash_map<std::pair<int, int64_t>, int> var_eq_value_to_literal;
+  // Var op value encoding literals.
+  absl::btree_map<int, absl::btree_map<int64_t, int>> encoding_literals;
+  absl::btree_map<int, absl::btree_map<int64_t, int>> var_le_value_to_literal;
+  // Var op var encoding literals.
   absl::flat_hash_map<std::pair<int, int>, int> var_eq_var_to_literal;
+  absl::flat_hash_map<std::pair<int, int>, int> var_lt_var_to_literal;
+  absl::flat_hash_map<std::pair<int, int>, int> var_or_var_to_literal;
+  absl::flat_hash_map<std::pair<int, int>, int> var_and_var_to_literal;
+  // Set variables.
   absl::flat_hash_map<fz::Variable*, std::shared_ptr<SetVariable>>
       set_variables;
+  // Statistics.
+  int num_var_op_value_reif_cached = 0;
+  int num_var_op_var_reif_cached = 0;
+  int num_var_op_var_imp_cached = 0;
+  int num_full_encodings = 0;
+  int num_light_encodings = 0;
+  int num_partial_encodings = 0;
 };
 
 int CpModelProtoWithMapping::NewBoolVar() { return NewIntVar(0, 1); }
 
 int CpModelProtoWithMapping::NewIntVar(int64_t min_value, int64_t max_value) {
   const int index = proto.variables_size();
-  FillDomainInProto({min_value, max_value}, proto.add_variables());
+  FillDomainInProto(min_value, max_value, proto.add_variables());
   return index;
 }
 
@@ -330,6 +377,13 @@ std::vector<VarOrValue> CpModelProtoWithMapping::LookupVarsOrValues(
   return result;
 }
 
+bool CpModelProtoWithMapping::VariableIsBoolean(int var) const {
+  if (var < 0) var = NegatedRef(var);
+  const IntegerVariableProto& var_proto = proto.variables(var);
+  return var_proto.domain_size() == 2 && var_proto.domain(0) >= 0 &&
+         var_proto.domain(1) <= 1;
+}
+
 bool CpModelProtoWithMapping::ConstraintContainsSetVariables(
     const fz::Constraint& constraint) const {
   for (const fz::Argument& argument : constraint.arguments) {
@@ -413,82 +467,315 @@ void CpModelProtoWithMapping::AddTermToLinearConstraint(
     // We need to update the domain of the constraint.
     for (int i = 0; i < ct->domain_size(); ++i) {
       const int64_t b = ct->domain(i);
-      // We account for infinity like bounds being INT_MAX, INT_MIN, and
-      // -INT_MAX.
-      if (b <= -std::numeric_limits<int64_t>::max() ||
+      if (b == std::numeric_limits<int64_t>::min() ||
           b == std::numeric_limits<int64_t>::max()) {
         continue;
       }
-      ct->set_domain(i, ct->domain(i) - coeff);
+      ct->set_domain(i, b - coeff);
     }
   }
 }
 
-int CpModelProtoWithMapping::GetOrCreateLiteralForVarEqValue(int var,
-                                                             int64_t value) {
-  const std::pair<int, int64_t> key = {var, value};
-  const auto it = var_eq_value_to_literal.find(key);
-  if (it != var_eq_value_to_literal.end()) return it->second;
-  const IntegerVariableProto& var_proto = proto.variables(var);
-  if (var_proto.domain_size() == 2 &&
-      var_proto.domain(0) == var_proto.domain(1)) {
-    const int fixed_literal = LookupConstant(value == var_proto.domain(0));
-    var_eq_value_to_literal[key] = fixed_literal;
-    return fixed_literal;
-  }
+void CpModelProtoWithMapping::AddLexOrdering(absl::Span<const int> x,
+                                             absl::Span<const int> y,
+                                             int enforcement_literal,
+                                             bool accepts_equals) {
+  const int min_size = std::min(x.size(), y.size());
+  std::vector<int> hold(min_size + 1);  // Variables indices.
+  hold[0] = enforcement_literal;
+  for (int i = 1; i < min_size; ++i) hold[i] = NewBoolVar();
+  const bool hold_sentinel_is_true =
+      x.size() < y.size() || (x.size() == y.size() && accepts_equals);
+  hold[min_size] = LookupConstant(hold_sentinel_is_true ? 1 : 0);
 
-  if (var_proto.domain_size() == 2 && var_proto.domain(0) == 0 &&
-      var_proto.domain(1) == 1) {
-    var_eq_value_to_literal[std::make_pair(var, 0)] = NegatedRef(var);
-    var_eq_value_to_literal[std::make_pair(var, 1)] = var;
+  if (!sat_enumeration_ && absl::GetFlag(FLAGS_fz_use_light_encoding)) {
+    // Faster version, but can produce duplicate solutions.
+    const Domain le_domain(std::numeric_limits<int64_t>::min(), 0);
+    const Domain lt_domain(std::numeric_limits<int64_t>::min(), -1);
+    for (int i = 0; i < min_size; ++i) {
+      // hold[i] => x[i] <= y[i].
+      AddLinearConstraint({hold[i]}, le_domain, {{x[i], 1}, {y[i], -1}});
+
+      // hold[i] => x[i] < y[i] || hold[i + 1]
+      const int is_lt = NewBoolVar();
+      AddLinearConstraint({is_lt}, lt_domain, {{x[i], 1}, {y[i], -1}});
+
+      ConstraintProto* chain = AddEnforcedConstraint(hold[i]);
+      chain->mutable_bool_or()->add_literals(is_lt);
+      chain->mutable_bool_or()->add_literals(hold[i + 1]);
+    }
+    ++num_light_encodings;
+  } else {
+    std::vector<int> is_lt(min_size);
+    std::vector<int> is_le(min_size);
+    for (int i = 0; i < min_size; ++i) {
+      is_le[i] = GetOrCreateLiteralForVarLeVar(x[i], y[i]);
+      is_lt[i] = GetOrCreateLiteralForVarLtVar(x[i], y[i]);
+    }
+
+    for (int i = 0; i < min_size; ++i) {
+      // hold[i] => x[i] <= y[i].
+      AddImplication({hold[i]}, is_le[i]);
+
+      // hold[i] => x[i] < y[i] || hold[i + 1]
+      ConstraintProto* chain = AddEnforcedConstraint(hold[i]);
+      chain->mutable_bool_or()->add_literals(is_lt[i]);
+      chain->mutable_bool_or()->add_literals(hold[i + 1]);
+
+      // Optimization.
+      if (i + 1 < min_size) {
+        // is_lt[i] => no need to look at further hold variables.
+        AddImplication({is_lt[i]}, NegatedRef(hold[i + 1]));
+
+        // Propagate the negation of hold[i] to hold[i + 1] to avoid unnecessary
+        // branching and disable the chain constraints.
+        AddImplication({NegatedRef(hold[i])}, NegatedRef(hold[i + 1]));
+      }
+    }
+  }
+}
+
+void CpModelProtoWithMapping::AddLiteralVectorsNotEqual(
+    absl::Span<const int> x_array, absl::Span<const int> y_array) {
+  const int size = x_array.size();
+  CHECK_EQ(size, y_array.size());
+  if (sat_enumeration_ || !absl::GetFlag(FLAGS_fz_use_light_encoding)) {
+    BoolArgumentProto* at_least_one_different =
+        proto.add_constraints()->mutable_bool_or();
+    for (int i = 0; i < x_array.size(); ++i) {
+      at_least_one_different->add_literals(
+          GetOrCreateLiteralForVarNeVar(x_array[i], y_array[i]));
+    }
+    ++num_light_encodings;
+  } else {
+    // This version is way faster, but can produce duplicates solution when
+    // enumerating solutions in a SAT model.
+    std::vector<int> is_ne(size);
+    for (int i = 0; i < size; ++i) {
+      // Using a simple implication is faster, but it forbids the optimization
+      // of the lex ordering.
+      is_ne[i] = NewBoolVar();
+      AddLinearConstraint({is_ne[i]}, Domain(1),
+                          {{x_array[i], 1}, {y_array[i], 1}});
+    }
+
+    std::vector<int> hold(size + 1);
+    hold[0] = LookupConstant(1);
+    for (int i = 1; i < size; ++i) hold[i] = NewBoolVar();
+    hold[size] = LookupConstant(0);
+
+    for (int i = 0; i < size; ++i) {
+      // hold[i] => x[i] != y[i] || hold[i + 1]
+      ConstraintProto* chain = AddEnforcedConstraint(hold[i]);
+      chain->mutable_bool_or()->add_literals(is_ne[i]);
+      chain->mutable_bool_or()->add_literals(hold[i + 1]);
+    }
+  }
+}
+
+// lit <=> var op value
+
+std::optional<int> CpModelProtoWithMapping::GetEncodingLiteral(int var,
+                                                               int64_t value) {
+  CHECK_GE(var, 0);
+  const IntegerVariableProto& var_proto = proto.variables(var);
+  const Domain domain = ReadDomainFromProto(var_proto);
+
+  // We have a few shortcuts where we do not create an encoding.
+
+  // Shortcut 1:Rule out values that are not in the domain.
+  if (!domain.Contains(value)) return LookupConstant(0);
+
+  // Shortcut 2: As we have ruled out values that are not in the domain, we can
+  // return a true literal if the domain has only one value.
+  if (domain.Size() == 1) return LookupConstant(1);
+
+  // Shortcut 3: The encoding of a Boolean variable is itself.
+  if (domain.Size() == 2 && domain.Min() == 0 && domain.Max() == 1) {
     return value == 1 ? var : NegatedRef(var);
   }
 
-  const int bool_var = NewBoolVar();
-  var_eq_value_to_literal[key] = bool_var;
-
-  AddLinearConstraint({bool_var}, Domain(value), {{var, 1}});
-  AddLinearConstraint({NegatedRef(bool_var)}, Domain(value).Complement(),
-                      {{var, 1}});
-
-  return bool_var;
+  const auto it = encoding_literals.find(var);
+  if (it != encoding_literals.end()) {
+    const auto it2 = it->second.find(value);
+    if (it2 != it->second.end()) return it2->second;
+  }
+  return std::nullopt;
 }
 
-absl::flat_hash_map<int64_t, int> CpModelProtoWithMapping::FullyEncode(
-    int var) {
-  absl::flat_hash_map<int64_t, int> result;
-  const Domain domain = ReadDomainFromProto(proto.variables(var));
+int CpModelProtoWithMapping::GetOrCreateEncodingLiteral(int var,
+                                                        int64_t value) {
+  CHECK_GE(var, 0);
+  const std::optional<int> existing_literal = GetEncodingLiteral(var, value);
+  if (existing_literal.has_value()) {
+    CHECK_NE(existing_literal.value(), kNoVar);
+    return existing_literal.value();
+  }
 
-  bool use_normal_encoding = true;
-  if (absl::GetFlag(FLAGS_fz_light_full_encoding)) {
-    use_normal_encoding = false;
-    for (int64_t value : domain.Values()) {
-      if (var_eq_value_to_literal.contains({var, value})) {
-        use_normal_encoding = true;
-        break;
+  const IntegerVariableProto& var_proto = proto.variables(var);
+  const Domain domain = ReadDomainFromProto(var_proto);
+  CHECK(domain.Contains(value));
+  CHECK(domain.Size() > 2 ||
+        (domain.Size() == 2 && (domain.Min() != 0 || domain.Max() != 1)));
+
+  const int lit = NewBoolVar();
+  if (domain.Size() == 2) {  // We fully encode the variable.
+    encoding_literals[var][domain.Min()] = NegatedRef(lit);
+    encoding_literals[var][domain.Max()] = lit;
+    return value == domain.Min() ? NegatedRef(lit) : lit;
+  } else {
+    encoding_literals[var][value] = lit;
+    return lit;
+  }
+}
+
+void CpModelProtoWithMapping::AddVarEqValueLiteral(int var, int64_t value,
+                                                   int lit) {
+  CHECK_GE(var, 0);
+  const std::optional<int> existing_literal = GetEncodingLiteral(var, value);
+  if (existing_literal.has_value()) {
+    AddLinearConstraint({}, Domain(0),
+                        {{lit, 1}, {existing_literal.value(), -1}});
+    ++num_var_op_value_reif_cached;
+  } else {
+    const IntegerVariableProto& var_proto = proto.variables(var);
+    const Domain domain = ReadDomainFromProto(var_proto);
+    CHECK(domain.Contains(value));
+    if (domain.Size() == 2) {
+      CHECK(domain.Min() != 0 || domain.Max() != 1);
+      if (value == domain.Min()) {
+        encoding_literals[var][domain.Min()] = lit;
+        encoding_literals[var][domain.Max()] = NegatedRef(lit);
+      } else {
+        encoding_literals[var][domain.Min()] = NegatedRef(lit);
+        encoding_literals[var][domain.Max()] = lit;
+      }
+    } else {
+      encoding_literals[var][value] = lit;
+    }
+  }
+}
+
+void CpModelProtoWithMapping::AddVarGeValueLiteral(int var, int64_t value,
+                                                   int lit) {
+  AddVarLeValueLiteral(var, value - 1, NegatedRef(lit));
+}
+
+void CpModelProtoWithMapping::AddVarGtValueLiteral(int var, int64_t value,
+                                                   int lit) {
+  AddVarLeValueLiteral(var, value, NegatedRef(lit));
+}
+
+void CpModelProtoWithMapping::AddVarLtValueLiteral(int var, int64_t value,
+                                                   int lit) {
+  AddVarLeValueLiteral(var, value - 1, lit);
+}
+
+void CpModelProtoWithMapping::AddVarLeValueLiteral(int var, int64_t value,
+                                                   int lit) {
+  const Domain domain = ReadDomainFromProto(proto.variables(var));
+  const auto it = var_le_value_to_literal.find(var);
+  if (it != var_le_value_to_literal.end()) {
+    const auto it2 = it->second.find(value);
+    if (it2 != it->second.end()) {
+      AddLinearConstraint({}, Domain(0), {{lit, 1}, {it2->second, -1}});
+      ++num_var_op_value_reif_cached;
+      return;
+    }
+  }
+  var_le_value_to_literal[var][value] = lit;
+}
+
+absl::btree_map<int64_t, int> CpModelProtoWithMapping::GetFullEncoding(
+    int var) {
+  absl::btree_map<int64_t, int> result;
+  const Domain domain = ReadDomainFromProto(proto.variables(var));
+  for (int64_t value : domain.Values()) {
+    result[value] = GetOrCreateEncodingLiteral(var, value);
+  }
+  return result;
+}
+
+void CpModelProtoWithMapping::AddAllEncodingConstraints() {
+  const bool light_encoding = absl::GetFlag(FLAGS_fz_use_light_encoding);
+  for (const auto& [var, encoding] : encoding_literals) {
+    const Domain domain = ReadDomainFromProto(proto.variables(var));
+    CHECK(domain.Size() > 2 ||
+          (domain.Size() == 2 && (domain.Min() != 0 || domain.Max() != 1)));
+
+    if (domain.Size() == encoding.size()) ++num_full_encodings;
+
+    if (domain.Size() == 2) {
+      CHECK_EQ(encoding.size(), 2);
+      const int lit = encoding.at(domain.Max());
+      CHECK_EQ(encoding.at(domain.Min()), NegatedRef(lit));
+      AddLinearConstraint({}, Domain(domain.Min()),
+                          {{var, 1}, {lit, domain.Min() - domain.Max()}});
+      continue;
+    }
+
+    if (domain.Size() == encoding.size() && light_encoding) {
+      BoolArgumentProto* exo = proto.add_constraints()->mutable_exactly_one();
+      for (const auto& [value, lit] : encoding) {
+        exo->add_literals(lit);
+        AddLinearConstraint({lit}, Domain(value), {{var, 1}});
+      }
+    } else if (encoding.size() > domain.Size() / 2 && light_encoding) {
+      BoolArgumentProto* exo = proto.add_constraints()->mutable_exactly_one();
+      // We iterate on the domain to make sure we visit all values.
+      for (const int64_t value : domain.Values()) {
+        const int lit = GetOrCreateEncodingLiteral(var, value);
+        exo->add_literals(lit);
+        AddLinearConstraint({lit}, Domain(value), {{var, 1}});
+      }
+      ++num_partial_encodings;
+    } else {
+      for (const auto& [value, lit] : encoding) {
+        AddLinearConstraint({lit}, Domain(value), {{var, 1}});
+        AddLinearConstraint({NegatedRef(lit)}, Domain(value).Complement(),
+                            {{var, 1}});
       }
     }
   }
 
-  if (use_normal_encoding) {
-    for (int64_t value : domain.Values()) {
-      result[value] = GetOrCreateLiteralForVarEqValue(var, value);
-    }
-  } else {
-    BoolArgumentProto* ex1 = proto.add_constraints()->mutable_exactly_one();
-    for (int64_t value : domain.Values()) {
-      const int literal = NewBoolVar();
-      var_eq_value_to_literal[{var, value}] = literal;
-      ex1->add_literals(literal);
-      result[value] = literal;
+  for (const auto& [var, encoding] : var_le_value_to_literal) {
+    const Domain domain = ReadDomainFromProto(proto.variables(var));
+    for (const auto& [value, lit] : encoding) {
+      // If the value is the min of the max of the domain, it is equivalent to
+      // the encoding literal of the variable bounds. In that case, we can
+      // link it to the corresponding encoding literal if it exists.
+      if (value == domain.Min()) {
+        const std::optional<int> encoding =
+            GetEncodingLiteral(var, domain.Min());
+        if (encoding.has_value()) {
+          AddLinearConstraint({}, Domain(0),
+                              {{lit, 1}, {encoding.value(), -1}});
+          ++num_var_op_value_reif_cached;
+        }
+      }
+      if (value == domain.Max() - 1 && !light_encoding) {
+        // In the case of light encoding, !encoding_lit does not propagate.
+        const std::optional<int> encoding_lit =
+            GetEncodingLiteral(var, domain.Max());
+        if (encoding_lit.has_value()) {
+          AddLinearConstraint(
+              {}, Domain(0),
+              {{lit, 1}, {NegatedRef(encoding_lit.value()), -1}});
+          ++num_var_op_value_reif_cached;
+          continue;
+        }
+      }
 
-      AddLinearConstraint({literal}, Domain(value), {{var, 1}});
+      const Domain le_domain(std::numeric_limits<int64_t>::min(), value);
+      AddLinearConstraint({lit}, le_domain, {{var, 1}});
+      AddLinearConstraint({NegatedRef(lit)}, le_domain.Complement(),
+                          {{var, 1}});
     }
   }
-
-  return result;
 }
 
+// literal <=> var1 op var2
+
 int CpModelProtoWithMapping::GetOrCreateLiteralForVarEqVar(int var1, int var2) {
   CHECK_NE(var1, kNoVar);
   CHECK_NE(var2, kNoVar);
@@ -499,14 +786,203 @@ int CpModelProtoWithMapping::GetOrCreateLiteralForVarEqVar(int var1, int var2) {
   const auto it = var_eq_var_to_literal.find(key);
   if (it != var_eq_var_to_literal.end()) return it->second;
 
-  const int bool_var = NewBoolVar();
+  const int lit = NewBoolVar();
+  AddVarEqVarLiteral(var1, var2, lit);
+  return lit;
+}
 
-  AddLinearConstraint({bool_var}, Domain(0), {{var1, 1}, {var2, -1}});
-  AddLinearConstraint({NegatedRef(bool_var)}, Domain(0).Complement(),
-                      {{var1, 1}, {var2, -1}});
+int CpModelProtoWithMapping::GetOrCreateLiteralForVarNeVar(int var1, int var2) {
+  return NegatedRef(GetOrCreateLiteralForVarEqVar(var1, var2));
+}
 
-  var_eq_var_to_literal[key] = bool_var;
-  return bool_var;
+void CpModelProtoWithMapping::AddVarEqVarLiteral(int var1, int var2, int lit) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) {
+    AddImplication({}, lit);
+    return;
+  }
+  if (var1 > var2) std::swap(var1, var2);
+
+  const std::pair<int, int> key = {var1, var2};
+  const auto it = var_eq_var_to_literal.find(key);
+  if (it != var_eq_var_to_literal.end()) {
+    AddLinearConstraint({}, Domain(0), {{lit, 1}, {it->second, -1}});
+    ++num_var_op_var_reif_cached;
+  } else {
+    if (VariableIsBoolean(var1) && VariableIsBoolean(var2)) {
+      AddLinearConstraint({lit}, Domain(0), {{var1, 1}, {var2, -1}});
+      AddLinearConstraint({NegatedRef(lit)}, Domain(1), {{var1, 1}, {var2, 1}});
+    } else {
+      AddLinearConstraint({lit}, Domain(0), {{var1, 1}, {var2, -1}});
+      AddLinearConstraint({NegatedRef(lit)}, Domain(0).Complement(),
+                          {{var1, 1}, {var2, -1}});
+    }
+    var_eq_var_to_literal[key] = lit;
+  }
+}
+
+void CpModelProtoWithMapping::AddVarNeVarLiteral(int var1, int var2, int lit) {
+  AddVarEqVarLiteral(var1, var2, NegatedRef(lit));
+}
+
+std::optional<int> CpModelProtoWithMapping::GetVarEqVarLiteral(int var1,
+                                                               int var2) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) return LookupConstant(1);
+  if (var1 > var2) std::swap(var1, var2);
+  const std::pair<int, int> key = {var1, var2};
+  const auto it = var_eq_var_to_literal.find(key);
+  if (it != var_eq_var_to_literal.end()) return it->second;
+  return std::nullopt;
+}
+
+std::optional<int> CpModelProtoWithMapping::GetVarNeVarLiteral(int var1,
+                                                               int var2) {
+  const std::optional<int> lit = GetVarEqVarLiteral(var1, var2);
+  if (lit.has_value()) return NegatedRef(lit.value());
+  return std::nullopt;
+}
+
+int CpModelProtoWithMapping::GetOrCreateLiteralForVarLtVar(int var1, int var2) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) return LookupConstant(0);
+
+  const std::pair<int, int> key = {var1, var2};
+  const auto it = var_lt_var_to_literal.find(key);
+  if (it != var_lt_var_to_literal.end()) return it->second;
+
+  const int lit = NewBoolVar();
+  AddVarLtVarLiteral(var1, var2, lit);
+  return lit;
+}
+
+void CpModelProtoWithMapping::AddVarLtVarLiteral(int var1, int var2, int lit) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) {
+    AddImplication({}, NegatedRef(lit));
+    return;
+  }
+
+  const std::pair<int, int> key = {var1, var2};
+  const auto it = var_lt_var_to_literal.find(key);
+  if (it != var_lt_var_to_literal.end()) {
+    AddLinearConstraint({}, Domain(0), {{lit, 1}, {it->second, -1}});
+    ++num_var_op_var_reif_cached;
+  } else {
+    var_lt_var_to_literal[key] = lit;
+
+    if (VariableIsBoolean(var1) && VariableIsBoolean(var2)) {
+      // bool_var => var1 < var2 => !var1 && var2
+      BoolArgumentProto* is_lt = AddEnforcedConstraint(lit)->mutable_bool_and();
+      is_lt->add_literals(NegatedRef(var1));
+      is_lt->add_literals(var2);
+
+      // !bool_var => var1 >= var2 => var1 || !var2
+      BoolArgumentProto* is_ge =
+          AddEnforcedConstraint(NegatedRef(lit))->mutable_bool_or();
+      is_ge->add_literals(var1);
+      is_ge->add_literals(NegatedRef(var2));
+    } else {
+      AddLinearConstraint({lit},
+                          Domain(std::numeric_limits<int64_t>::min(), -1),
+                          {{var1, 1}, {var2, -1}});
+      AddLinearConstraint({NegatedRef(lit)},
+                          Domain(0, std::numeric_limits<int64_t>::max()),
+                          {{var1, 1}, {var2, -1}});
+    }
+  }
+}
+
+std::optional<int> CpModelProtoWithMapping::GetVarLtVarLiteral(int var1,
+                                                               int var2) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) return LookupConstant(0);
+  const std::pair<int, int> key = {var1, var2};
+  const auto it = var_lt_var_to_literal.find(key);
+  if (it != var_lt_var_to_literal.end()) return it->second;
+  return std::nullopt;
+}
+
+int CpModelProtoWithMapping::GetOrCreateLiteralForVarLeVar(int var1, int var2) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) return LookupConstant(1);
+  return NegatedRef(GetOrCreateLiteralForVarLtVar(var2, var1));
+}
+
+void CpModelProtoWithMapping::AddVarLeVarLiteral(int var1, int var2, int lit) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) {
+    AddImplication({}, lit);
+    return;
+  }
+
+  AddVarLtVarLiteral(var2, var1, NegatedRef(lit));
+}
+
+std::optional<int> CpModelProtoWithMapping::GetVarLeVarLiteral(int var1,
+                                                               int var2) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  if (var1 == var2) return LookupConstant(1);
+
+  const std::optional<int> lit = GetVarLtVarLiteral(var2, var1);
+  if (lit.has_value()) return NegatedRef(lit.value());
+  return std::nullopt;
+}
+
+void CpModelProtoWithMapping::AddVarOrVarLiteral(int var1, int var2, int lit) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  CHECK(VariableIsBoolean(var1));
+  CHECK(VariableIsBoolean(var2));
+  if (var1 == var2) {
+    AddLinearConstraint({}, Domain(0), {{var1, 1}, {lit, -1}});
+    return;
+  }
+  if (var1 > var2) std::swap(var1, var2);
+
+  const std::pair<int, int> key = {var1, var2};
+  const auto it = var_or_var_to_literal.find(key);
+  if (it != var_or_var_to_literal.end()) {
+    AddLinearConstraint({}, Domain(0), {{lit, 1}, {it->second, -1}});
+    ++num_var_op_var_reif_cached;
+  } else {
+    AddImplication({var1}, lit);
+    AddImplication({var2}, lit);
+    AddImplication({NegatedRef(var1), NegatedRef(var2)}, NegatedRef(lit));
+    var_or_var_to_literal[key] = lit;
+  }
+}
+
+void CpModelProtoWithMapping::AddVarAndVarLiteral(int var1, int var2, int lit) {
+  CHECK_NE(var1, kNoVar);
+  CHECK_NE(var2, kNoVar);
+  CHECK(VariableIsBoolean(var1));
+  CHECK(VariableIsBoolean(var2));
+  if (var1 == var2) {
+    AddLinearConstraint({}, Domain(0), {{var1, 1}, {lit, -1}});
+    return;
+  }
+  if (var1 > var2) std::swap(var1, var2);
+
+  const std::pair<int, int> key = {var1, var2};
+  const auto it = var_and_var_to_literal.find(key);
+  if (it != var_and_var_to_literal.end()) {
+    AddLinearConstraint({}, Domain(0), {{lit, 1}, {it->second, -1}});
+    ++num_var_op_var_reif_cached;
+  } else {
+    AddImplication({lit}, var1);
+    AddImplication({lit}, var2);
+    AddImplication({var1, var2}, lit);
+    var_and_var_to_literal[key] = lit;
+  }
 }
 
 int CpModelProtoWithMapping::GetOrCreateOptionalInterval(VarOrValue start,
@@ -596,7 +1072,7 @@ int CpModelProtoWithMapping::NonZeroLiteralFrom(VarOrValue size) {
 
   const IntegerVariableProto& var_proto = proto.variables(size.var);
   const Domain domain = ReadDomainFromProto(var_proto);
-  DCHECK_GE(domain.Min(), 0);
+  CHECK_GE(domain.Min(), 0);
   if (domain.Min() > 0) return LookupConstant(1);
   if (domain.Max() == 0) {
     return LookupConstant(0);
@@ -733,32 +1209,12 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     // not(x) => a == b
     ct->add_enforcement_literal(NegatedRef(x));
     auto* const refute = ct->mutable_linear();
-    FillDomainInProto(Domain(0), refute);
+    FillDomainInProto(0, refute);
     AddTermToLinearConstraint(a, 1, refute);
     AddTermToLinearConstraint(b, -1, refute);
 
     // x => a + b == 1
     AddLinearConstraint({x}, Domain(1), {{a, 1}, {b, 1}});
-  } else if (fz_ct.type == "array_bool_or") {
-    auto* arg = ct->mutable_bool_or();
-    for (const int var : LookupVars(fz_ct.arguments[0])) {
-      arg->add_literals(var);
-    }
-  } else if (fz_ct.type == "array_bool_or_negated") {
-    auto* arg = ct->mutable_bool_and();
-    for (const int var : LookupVars(fz_ct.arguments[0])) {
-      arg->add_literals(NegatedRef(var));
-    }
-  } else if (fz_ct.type == "array_bool_and") {
-    auto* arg = ct->mutable_bool_and();
-    for (const int var : LookupVars(fz_ct.arguments[0])) {
-      arg->add_literals(var);
-    }
-  } else if (fz_ct.type == "array_bool_and_negated") {
-    auto* arg = ct->mutable_bool_or();
-    for (const int var : LookupVars(fz_ct.arguments[0])) {
-      arg->add_literals(NegatedRef(var));
-    }
   } else if (fz_ct.type == "array_bool_xor") {
     auto* arg = ct->mutable_bool_xor();
     for (const int var : LookupVars(fz_ct.arguments[0])) {
@@ -777,7 +1233,7 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     FillAMinusBInDomain({0, 0}, fz_ct, ct);
   } else if (fz_ct.type == "bool_ne" || fz_ct.type == "bool_not") {
     auto* arg = ct->mutable_linear();
-    FillDomainInProto(Domain(1), arg);
+    FillDomainInProto(1, arg);
     AddTermToLinearConstraint(LookupVar(fz_ct.arguments[0]), 1, arg);
     AddTermToLinearConstraint(LookupVar(fz_ct.arguments[1]), 1, arg);
   } else if (fz_ct.type == "int_ne") {
@@ -798,11 +1254,11 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     auto* arg = ct->mutable_linear();
     const std::vector<int> vars = LookupVars(fz_ct.arguments[1]);
     if (fz_ct.arguments[2].IsVariable()) {
-      FillDomainInProto(Domain(0), arg);
+      FillDomainInProto(0, arg);
       AddTermToLinearConstraint(LookupVar(fz_ct.arguments[2]), -1, arg);
     } else {
       const int64_t v = fz_ct.arguments[2].Value();
-      FillDomainInProto(Domain(v), arg);
+      FillDomainInProto(v, arg);
     }
     for (int i = 0; i < vars.size(); ++i) {
       AddTermToLinearConstraint(vars[i], fz_ct.arguments[0].values[i], arg);
@@ -842,7 +1298,7 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     }
 
     auto* arg = ct->mutable_linear();
-    FillDomainInProto(Domain(set_size), arg);
+    FillDomainInProto(set_size, arg);
     AddTermToLinearConstraint(LookupVar(fz_ct.arguments[1]), 1, arg);
   } else if (fz_ct.type == "set_in") {
     auto* arg = ct->mutable_linear();
@@ -854,9 +1310,8 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
                             fz_ct.arguments[1].values.end()}),
                         arg);
     } else if (fz_ct.arguments[1].type == fz::Argument::INT_INTERVAL) {
-      FillDomainInProto(
-          Domain(fz_ct.arguments[1].values[0], fz_ct.arguments[1].values[1]),
-          arg);
+      FillDomainInProto(fz_ct.arguments[1].values[0],
+                        fz_ct.arguments[1].values[1], arg);
     } else {
       LOG(FATAL) << "Wrong format";
     }
@@ -869,7 +1324,6 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
                                    fz_ct.arguments[1].values.end()})
               .Complement(),
           arg);
-      AddTermToLinearConstraint(LookupVar(fz_ct.arguments[0]), 1, arg);
     } else if (fz_ct.arguments[1].type == fz::Argument::INT_INTERVAL) {
       FillDomainInProto(
           Domain(fz_ct.arguments[1].values[0], fz_ct.arguments[1].values[1])
@@ -878,6 +1332,7 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     } else {
       LOG(FATAL) << "Wrong format";
     }
+    AddTermToLinearConstraint(LookupVar(fz_ct.arguments[0]), 1, arg);
   } else if (fz_ct.type == "int_min") {
     auto* arg = ct->mutable_lin_max();
     *arg->add_exprs() = LookupExpr(fz_ct.arguments[0], /*negate=*/true);
@@ -912,7 +1367,7 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     *arg->mutable_target() = LookupExpr(fz_ct.arguments[1]);
   } else if (fz_ct.type == "int_plus") {
     auto* arg = ct->mutable_linear();
-    FillDomainInProto(Domain(0), arg);
+    FillDomainInProto(0, arg);
     AddTermToLinearConstraint(LookupVar(fz_ct.arguments[0]), 1, arg);
     AddTermToLinearConstraint(LookupVar(fz_ct.arguments[1]), 1, arg);
     AddTermToLinearConstraint(LookupVar(fz_ct.arguments[2]), -1, arg);
@@ -1034,11 +1489,86 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
         LOG(FATAL) << "Wrong constraint " << fz_ct.DebugString();
       }
     }
+  } else if (fz_ct.type == "ortools_arg_max_int" ||
+             fz_ct.type == "ortools_arg_max_bool") {
+    const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
+    const int num_vars = x.size();
+    const int z = LookupVar(fz_ct.arguments[1]);
+    const int64_t min_index = fz_ct.arguments[2].Value();
+    const int64_t multiplier = fz_ct.arguments[3].Value();
+    int64_t min_range = std::numeric_limits<int64_t>::max();
+    int64_t max_range = std::numeric_limits<int64_t>::min();
+    auto* max_array = ct->mutable_lin_max();
+    for (int i = 0; i < num_vars; ++i) {
+      const IntegerVariableProto& var_proto = proto.variables(x[i]);
+      const int64_t min_var = var_proto.domain(0);
+      const int64_t max_var = var_proto.domain(var_proto.domain_size() - 1);
+      const int64_t offset = num_vars - i;
+      int64_t min_expr_range = min_var * multiplier * num_vars + offset;
+      int64_t max_expr_range = max_var * multiplier * num_vars + offset;
+      if (multiplier == -1) std::swap(min_expr_range, max_expr_range);
+      min_range = std::min(min_range, min_expr_range);
+      max_range = std::max(max_range, max_expr_range);
+      auto* exprs = max_array->add_exprs();
+      exprs->add_vars(x[i]);
+      exprs->add_coeffs(num_vars * multiplier);
+      exprs->set_offset(offset);
+    }
+    const int max_var = NewIntVar(min_range, max_range);
+    max_array->mutable_target()->add_vars(max_var);
+    max_array->mutable_target()->add_coeffs(1);
+
+    for (const auto& [value, literal] : GetFullEncoding(z)) {
+      if (value < min_index || value >= min_index + num_vars) {
+        AddImplication({}, NegatedRef(literal));
+      }
+      const int64_t index = value - min_index;
+      AddLinearConstraint({literal}, Domain(index - num_vars),
+                          {{x[index], num_vars * multiplier}, {max_var, -1}});
+      AddLinearConstraint(
+          {NegatedRef(literal)},
+          {std::numeric_limits<int64_t>::min(), index - num_vars - 1},
+          {{x[index], num_vars * multiplier}, {max_var, -1}});
+    }
   } else if (fz_ct.type == "fzn_all_different_int") {
     auto* arg = ct->mutable_all_diff();
     for (int i = 0; i < fz_ct.arguments[0].Size(); ++i) {
       *arg->add_exprs() = LookupExprAt(fz_ct.arguments[0], i);
     }
+  } else if (fz_ct.type == "fzn_value_precede_int") {
+    const int64_t before = fz_ct.arguments[0].Value();
+    const int64_t after = fz_ct.arguments[1].Value();
+    const std::vector<int> x = LookupVars(fz_ct.arguments[2]);
+    if (x.empty()) return;
+
+    std::vector<int> hold(x.size());
+    hold[0] = LookupConstant(0);
+    for (int i = 1; i < x.size(); ++i) hold[i] = NewBoolVar();
+
+    if (absl::GetFlag(FLAGS_fz_use_light_encoding) && !sat_enumeration_) {
+      for (int i = 0; i < x.size(); ++i) {
+        const int is_before = GetOrCreateEncodingLiteral(x[i], before);
+        if (i + 1 < x.size()) {
+          AddImplication({is_before}, hold[i + 1]);
+          AddLinearConstraint({NegatedRef(is_before)}, Domain(0),
+                              {{hold[i], 1}, {hold[i + 1], -1}});
+        }
+        AddLinearConstraint({NegatedRef(hold[i])}, Domain(after).Complement(),
+                            {{x[i], 1}});
+      }
+      ++num_light_encodings;
+    } else {
+      for (int i = 0; i < x.size(); ++i) {
+        const int is_before = GetOrCreateEncodingLiteral(x[i], before);
+        const int is_after = GetOrCreateEncodingLiteral(x[i], after);
+        if (i + 1 < x.size()) {
+          AddImplication({is_before}, hold[i + 1]);
+          AddLinearConstraint({NegatedRef(is_before)}, Domain(0),
+                              {{hold[i], 1}, {hold[i + 1], -1}});
+        }
+        AddImplication({NegatedRef(hold[i])}, NegatedRef(is_after));
+      }
+    }
   } else if (fz_ct.type == "ortools_count_eq_cst") {
     const std::vector<VarOrValue> counts =
         LookupVarsOrValues(fz_ct.arguments[0]);
@@ -1053,16 +1583,16 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     }
 
     if (target.var == kNoVar) {
-      FillDomainInProto(Domain(target.value - fixed_contributions), arg);
+      FillDomainInProto(target.value - fixed_contributions, arg);
     } else {
-      FillDomainInProto(Domain(-fixed_contributions), arg);
+      FillDomainInProto(-fixed_contributions, arg);
       AddTermToLinearConstraint(target.var, -1, arg);
     }
 
     for (const VarOrValue& count : counts) {
       if (count.var != kNoVar) {
-        AddTermToLinearConstraint(
-            GetOrCreateLiteralForVarEqValue(count.var, value), 1, arg);
+        AddTermToLinearConstraint(GetOrCreateEncodingLiteral(count.var, value),
+                                  1, arg);
       }
     }
   } else if (fz_ct.type == "ortools_count_eq") {
@@ -1072,16 +1602,15 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     const VarOrValue target = LookupVarOrValue(fz_ct.arguments[2]);
     LinearConstraintProto* arg = ct->mutable_linear();
     if (target.var == kNoVar) {
-      FillDomainInProto(Domain(target.value), arg);
+      FillDomainInProto(target.value, arg);
     } else {
-      FillDomainInProto(Domain(0), arg);
+      FillDomainInProto(0, arg);
       AddTermToLinearConstraint(target.var, -1, arg);
     }
     for (const VarOrValue& count : counts) {
-      const int bool_var =
-          count.var == kNoVar
-              ? GetOrCreateLiteralForVarEqValue(var, count.value)
-              : GetOrCreateLiteralForVarEqVar(var, count.var);
+      const int bool_var = count.var == kNoVar
+                               ? GetOrCreateEncodingLiteral(var, count.value)
+                               : GetOrCreateLiteralForVarEqVar(var, count.var);
       AddTermToLinearConstraint(bool_var, 1, arg);
     }
   } else if (fz_ct.type == "ortools_circuit" ||
@@ -1117,7 +1646,7 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
           const int literal = proto.variables_size();
           {
             auto* new_var = proto.add_variables();
-            FillDomainInProto({0, 1}, new_var);
+            FillDomainInProto(0, 1, new_var);
           }
 
           // Add the arc.
@@ -1194,6 +1723,57 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
         arg->add_f_inverse(LookupConstant(i - num_variables));
       }
     }
+  } else if (fz_ct.type == "ortools_lex_less_int" ||
+             fz_ct.type == "ortools_lex_less_bool" ||
+             fz_ct.type == "ortools_lex_lesseq_int" ||
+             fz_ct.type == "ortools_lex_lesseq_bool") {
+    const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
+    const std::vector<int> y = LookupVars(fz_ct.arguments[1]);
+    const bool accepts_equals = fz_ct.type == "ortools_lex_lesseq_bool" ||
+                                fz_ct.type == "ortools_lex_lesseq_int";
+    const int false_literal = LookupConstant(0);
+    AddLexOrdering(x, y, NegatedRef(false_literal), accepts_equals);
+  } else if (fz_ct.type == "ortools_precede_chain_int") {
+    std::vector<int64_t> values;
+    if (fz_ct.arguments[0].type == fz::Argument::INT_INTERVAL) {
+      values.reserve(fz_ct.arguments[0].values[1] -
+                     fz_ct.arguments[0].values[0] + 1);
+      for (int64_t value = fz_ct.arguments[0].values[0];
+           value <= fz_ct.arguments[0].values[1]; ++value) {
+        values.push_back(value);
+      }
+    } else if (fz_ct.arguments[0].type == fz::Argument::INT_LIST) {
+      values = fz_ct.arguments[0].values;
+    } else {
+      LOG(FATAL) << "Unsupported argument type: " << fz_ct.arguments[0].type
+                 << " for " << fz_ct.arguments[0].DebugString();
+    }
+    const std::vector<int> x = LookupVars(fz_ct.arguments[1]);
+
+    if (x.empty()) return;
+    if (values.size() <= 1) return;
+
+    std::vector<int> row;
+    for (int r = 0; r + 1 < values.size(); ++r) {
+      row.clear();
+      const int64_t before = values[r];
+      const int64_t after = values[r + 1];
+      row.resize(x.size());
+      for (int i = 0; i < x.size(); ++i) {
+        row[i] = (i <= r ? LookupConstant(0) : NewBoolVar());
+      }
+
+      for (int i = 0; i < x.size(); ++i) {
+        const int is_before = GetOrCreateEncodingLiteral(x[i], before);
+        const int is_after = GetOrCreateEncodingLiteral(x[i], after);
+        if (i + 1 < x.size()) {
+          AddImplication({is_before}, row[i + 1]);
+          AddLinearConstraint({NegatedRef(is_before)}, Domain(0),
+                              {{row[i], 1}, {row[i + 1], -1}});
+        }
+        AddImplication({NegatedRef(row[i])}, NegatedRef(is_after));
+      }
+    }
   } else if (fz_ct.type == "fzn_disjunctive") {
     const std::vector<VarOrValue> starts =
         LookupVarsOrValues(fz_ct.arguments[0]);
@@ -1359,11 +1939,11 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     CHECK_EQ(fz_ct.arguments[2].type, fz::Argument::INT_LIST);
     const std::vector<int64_t> weights = fz_ct.arguments[2].values;
 
-    std::vector<absl::flat_hash_map<int64_t, int>> bin_encodings;
+    std::vector<absl::btree_map<int64_t, int>> bin_encodings;
     absl::btree_set<int64_t> all_bin_indices;
     bin_encodings.reserve(positions.size());
     for (int p = 0; p < positions.size(); ++p) {
-      absl::flat_hash_map<int64_t, int> encoding = FullyEncode(positions[p]);
+      absl::btree_map<int64_t, int> encoding = GetFullEncoding(positions[p]);
       for (const auto& [value, literal] : encoding) {
         all_bin_indices.insert(value);
       }
@@ -1388,10 +1968,10 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     CHECK_EQ(fz_ct.arguments[3].type, fz::Argument::INT_LIST);
     const std::vector<int64_t> weights = fz_ct.arguments[3].values;
 
-    std::vector<absl::flat_hash_map<int64_t, int>> bin_encodings;
+    std::vector<absl::btree_map<int64_t, int>> bin_encodings;
     bin_encodings.reserve(bins.size());
     for (int bin = 0; bin < bins.size(); ++bin) {
-      absl::flat_hash_map<int64_t, int> encoding = FullyEncode(bins[bin]);
+      absl::btree_map<int64_t, int> encoding = GetFullEncoding(bins[bin]);
       for (const auto& [value, literal] : encoding) {
         if (value < first_bin || value > last_bin) {
           AddImplication({}, NegatedRef(literal));  // not a valid index.
@@ -1427,10 +2007,10 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     CHECK_EQ(weights.size(), positions.size());
     CHECK_EQ(loads.size(), last_bin - first_bin + 1);
 
-    std::vector<absl::flat_hash_map<int64_t, int>> bin_encodings;
+    std::vector<absl::btree_map<int64_t, int>> bin_encodings;
     bin_encodings.reserve(positions.size());
     for (int p = 0; p < positions.size(); ++p) {
-      absl::flat_hash_map<int64_t, int> encoding = FullyEncode(positions[p]);
+      absl::btree_map<int64_t, int> encoding = GetFullEncoding(positions[p]);
       for (const auto& [value, literal] : encoding) {
         if (value < first_bin || value > last_bin) {
           AddImplication({}, NegatedRef(literal));  // not a valid index.
@@ -1463,14 +2043,22 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
     const int card = LookupVar(fz_ct.arguments[0]);
     const std::vector<int>& x = LookupVars(fz_ct.arguments[1]);
 
+    LinearConstraintProto* global_cardinality = ct->mutable_linear();
+    FillDomainInProto(x.size(), global_cardinality);
+
     absl::btree_map<int64_t, std::vector<int>> value_to_literals;
     for (int i = 0; i < x.size(); ++i) {
-      const absl::flat_hash_map<int64_t, int> encoding = FullyEncode(x[i]);
+      const absl::btree_map<int64_t, int> encoding = GetFullEncoding(x[i]);
       for (const auto& [value, literal] : encoding) {
         value_to_literals[value].push_back(literal);
+        AddTermToLinearConstraint(literal, 1, global_cardinality);
       }
     }
 
+    // Constrain the range of the card variable.
+    const int64_t max_size = std::min(x.size(), value_to_literals.size());
+    AddLinearConstraint({}, {1, max_size}, {{card, 1}});
+
     LinearConstraintProto* lin =
         AddLinearConstraint({}, Domain(0), {{card, -1}});
     for (const auto& [value, literals] : value_to_literals) {
@@ -1484,6 +2072,88 @@ void CpModelProtoWithMapping::FillConstraint(const fz::Constraint& fz_ct,
         is_present_constraint->add_literals(literal);
       }
     }
+  } else if (fz_ct.type == "ortools_global_cardinality") {
+    const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
+    CHECK_EQ(fz_ct.arguments[1].type, fz::Argument::INT_LIST);
+    const std::vector<int64_t>& values = fz_ct.arguments[1].values;
+    const std::vector<int> cards = LookupVars(fz_ct.arguments[2]);
+    const bool is_closed = fz_ct.arguments[3].Value() != 0;
+
+    const absl::flat_hash_set<int64_t> all_values(values.begin(), values.end());
+    absl::flat_hash_map<int64_t, std::vector<int>> value_to_literals;
+    bool exact_cover = true;
+
+    for (const int x_var : x) {
+      const absl::btree_map<int64_t, int> encoding = GetFullEncoding(x_var);
+      for (const auto& [value, literal] : encoding) {
+        if (all_values.contains(value)) {
+          value_to_literals[value].push_back(literal);
+        } else if (is_closed) {
+          AddImplication({}, NegatedRef(literal));
+        } else {
+          exact_cover = false;
+        }
+      }
+    }
+
+    for (int i = 0; i < cards.size(); ++i) {
+      const int64_t value = values[i];
+      const int card = cards[i];
+      LinearConstraintProto* lin =
+          AddLinearConstraint({}, Domain(0), {{card, -1}});
+      for (const int literal : value_to_literals[value]) {
+        AddTermToLinearConstraint(literal, 1, lin);
+      }
+    }
+
+    if (exact_cover) {
+      LinearConstraintProto* cover = AddLinearConstraint({}, Domain(x.size()));
+      for (const int card : cards) {
+        AddTermToLinearConstraint(card, 1, cover);
+      }
+    }
+  } else if (fz_ct.type == "ortools_global_cardinality_low_up") {
+    const std::vector<int> x = LookupVars(fz_ct.arguments[0]);
+    CHECK(fz_ct.arguments[1].type == fz::Argument::INT_LIST ||
+          fz_ct.arguments[1].type == fz::Argument::VOID_ARGUMENT);
+    const std::vector<int64_t>& values = fz_ct.arguments[1].values;
+    absl::Span<const int64_t> lbs = fz_ct.arguments[2].values;
+    absl::Span<const int64_t> ubs = fz_ct.arguments[3].values;
+    const bool is_closed = fz_ct.arguments[4].Value() != 0;
+
+    const absl::flat_hash_set<int64_t> all_values(values.begin(), values.end());
+    absl::flat_hash_map<int64_t, std::vector<int>> value_to_literals;
+    bool exact_cover = true;
+
+    for (const int x_var : x) {
+      const absl::btree_map<int64_t, int> encoding = GetFullEncoding(x_var);
+      for (const auto& [value, literal] : encoding) {
+        if (all_values.contains(value)) {
+          value_to_literals[value].push_back(literal);
+        } else if (is_closed) {
+          AddImplication({}, NegatedRef(literal));
+        } else {
+          exact_cover = false;
+        }
+      }
+    }
+
+    // Optimization: if sum(lbs) == length(x), then we can reduce ubs to lbs,
+    // and vice versa. the constraint is redundant.
+    const int64_t sum_lbs = absl::c_accumulate(lbs, 0);
+    const int64_t sum_ubs = absl::c_accumulate(ubs, 0);
+    if (exact_cover && sum_lbs == x.size()) {
+      ubs = lbs;
+    } else if (exact_cover && sum_ubs == x.size()) {
+      lbs = ubs;
+    }
+
+    for (int i = 0; i < values.size(); ++i) {
+      LinearConstraintProto* lin = AddLinearConstraint({}, {lbs[i], ubs[i]});
+      for (const int literal : value_to_literals[values[i]]) {
+        AddTermToLinearConstraint(literal, 1, lin);
+      }
+    }
   } else {
     LOG(FATAL) << " Not supported " << fz_ct.type;
   }
@@ -1515,7 +2185,20 @@ void CpModelProtoWithMapping::PutSetBooleansInCommonDomain(
     }
   }
 }
-// set_le_reif, set_lt_reif + disjoint and partition_set.
+
+void CpModelProtoWithMapping::FirstPass(const fz::Constraint& fz_ct) {
+  if (fz_ct.type == "set_card") {
+    if (!fz_ct.arguments[0].IsVariable() ||
+        !fz_ct.arguments[0].Var()->domain.is_a_set ||
+        !fz_ct.arguments[1].HasOneValue()) {
+      return;
+    }
+    std::shared_ptr<SetVariable> set_var = LookupSetVar(fz_ct.arguments[0]);
+    const int64_t fixed_card = fz_ct.arguments[1].Value();
+    set_var->fixed_card = fixed_card;
+  }
+}
+
 void CpModelProtoWithMapping::ExtractSetConstraint(
     const fz::Constraint& fz_ct) {
   if (fz_ct.type == "array_set_element") {
@@ -1591,7 +2274,7 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
     BoolArgumentProto* exactly_one =
         proto.add_constraints()->mutable_exactly_one();
     for (const int64_t value : index_domain.Values()) {
-      const int index_literal = GetOrCreateLiteralForVarEqValue(index, value);
+      const int index_literal = GetOrCreateEncodingLiteral(index, value);
       exactly_one->add_literals(index_literal);
 
       std::shared_ptr<SetVariable> set_var =
@@ -1621,6 +2304,93 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
         }
       }
     }
+  } else if (fz_ct.type == "fzn_all_different_set") {
+    const int num_vars = fz_ct.arguments[0].Size();
+    if (num_vars == 0) return;
+
+    std::vector<std::shared_ptr<SetVariable>> set_vars;
+    set_vars.reserve(num_vars);
+    for (int i = 0; i < num_vars; ++i) {
+      set_vars.push_back(LookupSetVarAt(fz_ct.arguments[0], i));
+    }
+    std::vector<std::vector<int>> var_booleans(num_vars);
+    std::vector<std::vector<int>*> var_booleans_ptrs(num_vars);
+    for (int i = 0; i < set_vars.size(); ++i) {
+      var_booleans_ptrs[i] = &var_booleans[i];
+    }
+    PutSetBooleansInCommonDomain(set_vars, var_booleans_ptrs);
+    for (int i = 0; i + 1 < num_vars; ++i) {
+      for (int j = i + 1; j < num_vars; ++j) {
+        AddLiteralVectorsNotEqual(var_booleans[i], var_booleans[j]);
+      }
+    }
+  } else if (fz_ct.type == "fzn_all_disjoint") {
+    const int num_vars = fz_ct.arguments[0].Size();
+    if (num_vars == 0) return;
+
+    absl::btree_map<int64_t, std::vector<int>> value_to_candidates;
+    for (int i = 0; i < num_vars; ++i) {
+      const std::shared_ptr<SetVariable> set_var =
+          LookupSetVarAt(fz_ct.arguments[0], i);
+      for (int j = 0; j < set_var->sorted_values.size(); ++j) {
+        const int64_t value = set_var->sorted_values[j];
+        const int literal = set_var->var_indices[j];
+        value_to_candidates[value].push_back(literal);
+      }
+    }
+    for (const auto& [value, candidates] : value_to_candidates) {
+      BoolArgumentProto* amo = proto.add_constraints()->mutable_at_most_one();
+      for (const int literal : candidates) {
+        amo->add_literals(literal);
+      }
+    }
+  } else if (fz_ct.type == "fzn_disjoint") {
+    std::vector<int> x_literals, y_literals;
+    PutSetBooleansInCommonDomain(
+        {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1])},
+        {&x_literals, &y_literals});
+    for (int i = 0; i < x_literals.size(); ++i) {
+      BoolArgumentProto* at_least_one_false =
+          proto.add_constraints()->mutable_bool_or();
+      at_least_one_false->add_literals(NegatedRef(x_literals[i]));
+      at_least_one_false->add_literals(NegatedRef(y_literals[i]));
+    }
+  } else if (fz_ct.type == "fzn_partition_set") {
+    const int num_vars = fz_ct.arguments[0].Size();
+    if (num_vars == 0) return;
+
+    absl::flat_hash_set<int64_t> universe;
+    if (fz_ct.arguments[1].type == fz::Argument::INT_INTERVAL) {
+      for (int64_t v = fz_ct.arguments[1].values[0];
+           v <= fz_ct.arguments[1].values[1]; ++v) {
+        universe.insert(v);
+      }
+    } else {
+      CHECK_EQ(fz_ct.arguments[1].type, fz::Argument::INT_LIST);
+      universe = absl::flat_hash_set<int64_t>(fz_ct.arguments[1].values.begin(),
+                                              fz_ct.arguments[1].values.end());
+    }
+
+    absl::btree_map<int64_t, std::vector<int>> value_to_candidates;
+    for (int i = 0; i < num_vars; ++i) {
+      const std::shared_ptr<SetVariable> set_var =
+          LookupSetVarAt(fz_ct.arguments[0], i);
+      for (int j = 0; j < set_var->sorted_values.size(); ++j) {
+        const int64_t value = set_var->sorted_values[j];
+        const int literal = set_var->var_indices[j];
+        if (!universe.contains(value)) {
+          AddImplication({}, NegatedRef(literal));
+        } else {
+          value_to_candidates[value].push_back(literal);
+        }
+      }
+    }
+    for (const auto& [value, candidates] : value_to_candidates) {
+      BoolArgumentProto* ex1 = proto.add_constraints()->mutable_exactly_one();
+      for (const int literal : candidates) {
+        ex1->add_literals(literal);
+      }
+    }
   } else if (fz_ct.type == "set_card") {
     std::shared_ptr<SetVariable> set_var = LookupSetVar(fz_ct.arguments[0]);
     VarOrValue var_or_value = LookupVarOrValue(fz_ct.arguments[1]);
@@ -1628,16 +2398,15 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
       ConstraintProto* ct = proto.add_constraints();
       if (var_or_value.var == kNoVar) {
         set_var->card_var_index = LookupConstant(var_or_value.value);
-        FillDomainInProto(Domain(var_or_value.value), ct->mutable_linear());
+        FillDomainInProto(var_or_value.value, ct->mutable_linear());
       } else {
         set_var->card_var_index = var_or_value.var;
-        FillDomainInProto(Domain(0), ct->mutable_linear());
+        FillDomainInProto(0, ct->mutable_linear());
         AddTermToLinearConstraint(var_or_value.var, -1, ct->mutable_linear());
       }
       for (const int bool_var : set_var->var_indices) {
         AddTermToLinearConstraint(bool_var, 1, ct->mutable_linear());
       }
-
     } else {
       if (var_or_value.var == kNoVar) {
         AddLinearConstraint({}, Domain(var_or_value.value),
@@ -1653,9 +2422,42 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
     std::shared_ptr<SetVariable> set_var = LookupSetVar(fz_ct.arguments[1]);
     if (var_or_value.var == kNoVar) {
       const int index = set_var->find_value_index(var_or_value.value);
-      // TODO(user): Improve me.
+      // TODO(user): Improve behavior and reporting when failing.
       CHECK_NE(index, -1);
       AddImplication({}, set_var->var_indices[index]);
+    } else if (set_var->fixed_card.has_value() &&
+               set_var->fixed_card.value() == 1) {
+      // We have a one to one mapping between the set_var and the full encoding
+      // of the variable.
+      //
+      // Cache the mapping of set_var values to literals.
+      absl::flat_hash_map<int64_t, int> set_value_to_literal;
+      for (int i = 0; i < set_var->sorted_values.size(); ++i) {
+        set_value_to_literal[set_var->sorted_values[i]] =
+            set_var->var_indices[i];
+      }
+
+      // Reduce the domain of the target variable.
+      AddLinearConstraint({}, Domain::FromValues(set_var->sorted_values),
+                          {{var_or_value.var, 1}});
+
+      absl::flat_hash_set<int> var_values;
+      const Domain var_domain =
+          ReadDomainFromProto(proto.variables(var_or_value.var));
+      for (const int64_t value : var_domain.Values()) {
+        const auto it = set_value_to_literal.find(value);
+        // Non-covered values are fixed to 0 by the above domain reduction.
+        if (it == set_value_to_literal.end()) continue;
+        AddVarEqValueLiteral(var_or_value.var, value, it->second);
+        var_values.insert(value);
+      }
+
+      // Zero out set literals not covered by the full encoding.
+      for (int i = 0; i < set_var->sorted_values.size(); ++i) {
+        if (!var_values.contains(set_var->sorted_values[i])) {
+          AddImplication({}, NegatedRef(set_var->var_indices[i]));
+        }
+      }
     } else {
       // We express `v \in set({v_i}, {b_i})` by N+1 constraints:
       // v \in {v_i}
@@ -1682,9 +2484,9 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
       if (index == -1) {
         AddImplication({}, NegatedRef(enforcement_literal));
       } else {
-        const int set_literal = set_var->var_indices[index];
-        AddImplication({set_literal}, enforcement_literal);
-        AddImplication({enforcement_literal}, set_literal);
+        AddLinearConstraint(
+            {}, Domain(0),
+            {{set_var->var_indices[index], 1}, {enforcement_literal, -1}});
       }
     } else {
       // Reduce the domain of the target variable.
@@ -1699,8 +2501,8 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
         const int64_t value = set_var->sorted_values[i];
         const int set_value_literal = set_var->var_indices[i];
         // Let's create the literal as we are going to reuse it.
-        const int not_var_value_literal = NegatedRef(
-            GetOrCreateLiteralForVarEqValue(var_or_value.var, value));
+        const int not_var_value_literal =
+            NegatedRef(GetOrCreateEncodingLiteral(var_or_value.var, value));
 
         AddImplication({enforcement_literal, NegatedRef(set_value_literal)},
                        not_var_value_literal);
@@ -1715,35 +2517,22 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
         {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1]),
          LookupSetVar(fz_ct.arguments[2])},
         {&x_literals, &y_literals, &r_literals});
-
     if (fz_ct.type == "set_intersect") {
-      // Implement the intersection logic.
       for (int i = 0; i < x_literals.size(); ++i) {
-        AddImplication({r_literals[i]}, x_literals[i]);
-        AddImplication({r_literals[i]}, y_literals[i]);
-        AddImplication({x_literals[i], y_literals[i]}, r_literals[i]);
+        AddVarAndVarLiteral(x_literals[i], y_literals[i], r_literals[i]);
       }
     } else if (fz_ct.type == "set_union") {
-      // Implement the union logic.
       for (int i = 0; i < x_literals.size(); ++i) {
-        AddImplication({x_literals[i]}, r_literals[i]);
-        AddImplication({y_literals[i]}, r_literals[i]);
-        AddImplication({NegatedRef(x_literals[i]), NegatedRef(y_literals[i])},
-                       NegatedRef(r_literals[i]));
+        AddVarOrVarLiteral(x_literals[i], y_literals[i], r_literals[i]);
       }
     } else if (fz_ct.type == "set_symdiff") {
       for (int i = 0; i < x_literals.size(); ++i) {
-        AddLinearConstraint({r_literals[i]}, Domain(1),
-                            {{x_literals[i], 1}, {y_literals[i], 1}});
-        AddLinearConstraint({NegatedRef(r_literals[i])}, Domain(0),
-                            {{x_literals[i], 1}, {y_literals[i], -1}});
+        AddVarEqVarLiteral(x_literals[i], y_literals[i],
+                           NegatedRef(r_literals[i]));
       }
     } else if (fz_ct.type == "set_diff") {
       for (int i = 0; i < x_literals.size(); ++i) {
-        AddImplication({r_literals[i]}, x_literals[i]);
-        AddImplication({r_literals[i]}, NegatedRef(y_literals[i]));
-        AddImplication({x_literals[i], NegatedRef(y_literals[i])},
-                       r_literals[i]);
+        AddVarLtVarLiteral(y_literals[i], x_literals[i], r_literals[i]);
       }
     }
   } else if (fz_ct.type == "set_subset" || fz_ct.type == "set_superset" ||
@@ -1762,8 +2551,8 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
       } else if (fz_ct.type == "set_superset") {
         AddImplication({y_lit}, x_lit);
       } else if (fz_ct.type == "set_eq") {
-        AddImplication({x_lit}, y_lit);
-        AddImplication({y_lit}, x_lit);
+        // We use the linear as it is easier for the presolve.
+        AddLinearConstraint({}, Domain(0), {{x_lit, 1}, {y_lit, -1}});
       } else {
         LOG(FATAL) << "Unsupported " << fz_ct.type;
       }
@@ -1773,20 +2562,7 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
     PutSetBooleansInCommonDomain(
         {LookupSetVar(fz_ct.arguments[0]), LookupSetVar(fz_ct.arguments[1])},
         {&x_literals, &y_literals});
-
-    BoolArgumentProto* bool_or = proto.add_constraints()->mutable_bool_or();
-    for (int i = 0; i < x_literals.size(); ++i) {
-      const int lit = NewBoolVar();
-
-      bool_or->add_literals(NegatedRef(lit));
-
-      const int x_lit = x_literals[i];
-      const int y_lit = y_literals[i];
-
-      AddLinearConstraint({lit}, Domain(0), {{x_lit, 1}, {y_lit, -1}});
-      AddLinearConstraint({NegatedRef(lit)}, Domain(1),
-                          {{x_lit, 1}, {y_lit, 1}});
-    }
+    AddLiteralVectorsNotEqual(x_literals, y_literals);
   } else if (fz_ct.type == "set_eq_reif" || fz_ct.type == "set_ne_reif" ||
              fz_ct.type == "set_subset_reif" ||
              fz_ct.type == "set_superset_reif") {
@@ -1797,49 +2573,28 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
     const int enforcement_literal = LookupVar(fz_ct.arguments[2]);
     const int num_values = x_literals.size();
 
-    const int card_var = NewIntVar(0, x_literals.size());
-    LinearConstraintProto* sum =
-        AddLinearConstraint({}, Domain(0), {{card_var, -1}});
-    for (int i = 0; i < num_values; ++i) {
-      const int lit = NewBoolVar();
-
-      AddTermToLinearConstraint(lit, 1, sum);
-
-      const int x_lit = x_literals[i];
-      const int y_lit = y_literals[i];
-
-      if (fz_ct.type == "set_eq_reif" || fz_ct.type == "set_ne_reif") {
-        AddLinearConstraint({lit}, Domain(0), {{x_lit, 1}, {y_lit, -1}});
-        AddLinearConstraint({NegatedRef(lit)}, Domain(1),
-                            {{x_lit, 1}, {y_lit, 1}});
-      } else if (fz_ct.type == "set_subset_reif") {
-        ConstraintProto* le_ct = AddEnforcedConstraint(lit);
-        le_ct->mutable_bool_or()->add_literals(NegatedRef(x_lit));
-        le_ct->mutable_bool_or()->add_literals(y_lit);
-
-        ConstraintProto* gt_ct = AddEnforcedConstraint(NegatedRef(lit));
-        gt_ct->mutable_bool_and()->add_literals(x_lit);
-        gt_ct->mutable_bool_and()->add_literals(NegatedRef(y_lit));
-      } else if (fz_ct.type == "set_superset_reif") {
-        ConstraintProto* ge_ct = AddEnforcedConstraint(lit);
-        ge_ct->mutable_bool_or()->add_literals(x_lit);
-        ge_ct->mutable_bool_or()->add_literals(NegatedRef(y_lit));
-
-        ConstraintProto* lt_ct = AddEnforcedConstraint(NegatedRef(lit));
-        lt_ct->mutable_bool_and()->add_literals(NegatedRef(x_lit));
-        lt_ct->mutable_bool_and()->add_literals(y_lit);
-      }
-    }
-
-    // Link the enforcement literal to the cardinality variable.
     int e = enforcement_literal;
     if (fz_ct.type == "set_ne_reif") {
       e = NegatedRef(enforcement_literal);
     }
-    AddLinearConstraint({e}, Domain(num_values), {{card_var, 1}});
-    AddLinearConstraint({NegatedRef(e)}, Domain(0, num_values - 1),
-                        {{card_var, 1}});
-  } else if (fz_ct.type == "set_le" || fz_ct.type == "set_lt") {
+    BoolArgumentProto* all_true = AddEnforcedConstraint(e)->mutable_bool_and();
+    BoolArgumentProto* one_false =
+        AddEnforcedConstraint(NegatedRef(e))->mutable_bool_or();
+    for (int i = 0; i < num_values; ++i) {
+      int lit;
+      if (fz_ct.type == "set_eq_reif" || fz_ct.type == "set_ne_reif") {
+        lit = GetOrCreateLiteralForVarEqVar(x_literals[i], y_literals[i]);
+      } else if (fz_ct.type == "set_subset_reif") {
+        lit = GetOrCreateLiteralForVarLeVar(x_literals[i], y_literals[i]);
+      } else {
+        DCHECK_EQ(fz_ct.type, "set_superset_reif");
+        lit = GetOrCreateLiteralForVarLeVar(y_literals[i], x_literals[i]);
+      }
+      all_true->add_literals(lit);
+      one_false->add_literals(NegatedRef(lit));
+    }
+  } else if (fz_ct.type == "set_le" || fz_ct.type == "set_lt" ||
+             fz_ct.type == "set_le_reif" || fz_ct.type == "set_lt_reif") {
     // set_le is tricky. Let's see all possible sets of size four in their
     // lexicographical order and their bit representation:
     // {}        0000
@@ -1860,13 +2615,13 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
     // {4}       0001
     //
     // The example above clearly show that we cannot simply force the bit
-    // representation to be in lexicographical order, which would be relatively
-    // easy to do. The underlying reason is that the empty (sub-)set compares
-    // before other sets. To work-around this, we define a larger bit
-    // representation where between each two bits we add a new bit saying
-    // whether all the bits to its right are zero or not. This way the empty set
-    // is mapped from 0000 to 10101010, since every time the bits to the right
-    // are zero. For the example above, we get:
+    // representation to be in lexicographical order, which would be
+    // relatively easy to do. The underlying reason is that the empty
+    // (sub-)set compares before other sets. To work-around this, we define a
+    // larger bit representation where between each two bits we add a new bit
+    // saying whether all the bits to its right are zero or not. This way the
+    // empty set is mapped from 0000 to 10101010, since every time the bits to
+    // the right are zero. For the example above, we get:
     // {}        10101010
     // {1}       01101010
     // {1,2}     01011010
@@ -1917,144 +2672,360 @@ void CpModelProtoWithMapping::ExtractSetConstraint(
       }
     }
 
-    std::swap(x_literals, y_literals);  // Reverse the order.
-
-    const bool accept_equals = fz_ct.type == "set_le";
-
-    // Now compare the bit representation using the lexicographic ordering.
-    std::vector<int> eq_literals;
-    BoolArgumentProto* le_or_ct = proto.add_constraints()->mutable_bool_or();
-    for (int i = 0; i < x_literals.size(); ++i) {
-      const int lt_lit = NewBoolVar();
-      ConstraintProto* lt_ct = proto.add_constraints();
-      // (x < y) <=> (~x && y) <=> lt_lit
-      lt_ct->add_enforcement_literal(lt_lit);
-      lt_ct->mutable_bool_and()->add_literals(NegatedRef(x_literals[i]));
-      lt_ct->mutable_bool_and()->add_literals(y_literals[i]);
-      ConstraintProto* lt_ct_rev = proto.add_constraints();
-      lt_ct_rev->add_enforcement_literal(NegatedRef(x_literals[i]));
-      lt_ct_rev->add_enforcement_literal(y_literals[i]);
-      lt_ct_rev->mutable_bool_and()->add_literals(lt_lit);
-
-      // lt_for_index => eq[0] && eq[1] && ... && eq[i-1] && lt[i]
-      const int lt_for_index = NewBoolVar();
-      ConstraintProto* lt_for_index_ct = proto.add_constraints();
-      lt_for_index_ct->add_enforcement_literal(lt_for_index);
-      for (const int eq_lit : eq_literals) {
-        lt_for_index_ct->mutable_bool_and()->add_literals(eq_lit);
-      }
-      lt_for_index_ct->mutable_bool_and()->add_literals(lt_lit);
-
-      le_or_ct->add_literals(lt_for_index);
-
-      const int eq_lit = NewBoolVar();
-      AddLinearConstraint({eq_lit}, Domain(0),
-                          {{x_literals[i], 1}, {y_literals[i], -1}});
-      AddLinearConstraint({NegatedRef(eq_lit)}, Domain(1),
-                          {{x_literals[i], 1}, {y_literals[i], 1}});
-      eq_literals.push_back(eq_lit);
-    }
-    if (accept_equals) {
-      // eq_lit => eq[0] && eq[1] && ... && eq[i-1] && eq[i]
-      const int eq_lit = NewBoolVar();
-      ConstraintProto* eq_ct = proto.add_constraints();
-      eq_ct->add_enforcement_literal(eq_lit);
-      for (const int eq_lit : eq_literals) {
-        eq_ct->mutable_bool_and()->add_literals(eq_lit);
-      }
-
-      le_or_ct->add_literals(eq_lit);
+    const bool accept_equals =
+        fz_ct.type == "set_le" || fz_ct.type == "set_le_reif";
+    const bool is_reif =
+        fz_ct.type == "set_le_reif" || fz_ct.type == "set_lt_reif";
+    const int enforcement_literal =
+        is_reif ? LookupVar(fz_ct.arguments[2]) : LookupConstant(1);
+    AddLexOrdering(y_literals, x_literals, enforcement_literal, accept_equals);
+    if (is_reif) {
+      // set_le_reif:
+      //    -  l => x <= y
+      //    - ~l => y < x
+      // set_lt_reif:
+      //    -  l => x < y
+      //    - ~l => y <= x
+      AddLexOrdering(x_literals, y_literals, NegatedRef(enforcement_literal),
+                     !accept_equals);
     }
   } else {
     LOG(FATAL) << "Not supported " << fz_ct.DebugString();
   }
 }  // NOLINT(readability/fn_size)
 
-void CpModelProtoWithMapping::FillReifOrImpliedConstraint(
-    const fz::Constraint& fz_ct, ConstraintProto* ct) {
-  // Start by adding a non-reified version of the same constraint.
-  std::string simplified_type;
-  if (absl::EndsWith(fz_ct.type, "_reif")) {
-    // Remove _reif.
-    simplified_type = fz_ct.type.substr(0, fz_ct.type.size() - 5);
-  } else if (absl::EndsWith(fz_ct.type, "_imp")) {
-    // Remove _imp.
-    simplified_type = fz_ct.type.substr(0, fz_ct.type.size() - 4);
+void CpModelProtoWithMapping::FillReifiedOrImpliedConstraint(
+    const fz::Constraint& fz_ct) {
+  // Start by processing the constraints that are cached.
+  if (fz_ct.type == "int_eq_reif" || fz_ct.type == "bool_eq_reif") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    if (left.var == kNoVar) std::swap(left, right);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      CHECK_EQ(right.var, kNoVar);
+      if (left.value == right.value) {
+        AddImplication({}, e);
+      } else {
+        AddImplication({}, NegatedRef(e));
+      }
+    } else if (right.var == kNoVar) {
+      AddVarEqValueLiteral(left.var, right.value, e);
+    } else {
+      AddVarEqVarLiteral(left.var, right.var, e);
+    }
+  } else if (fz_ct.type == "int_eq_imp" || fz_ct.type == "bool_eq_imp") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    if (left.var == kNoVar) std::swap(left, right);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      CHECK_EQ(right.var, kNoVar);
+      if (left.value != right.value) {
+        AddImplication({}, NegatedRef(e));
+      }
+    } else if (right.var == kNoVar) {
+      const std::optional<int> lit = GetEncodingLiteral(left.var, right.value);
+      if (lit.has_value()) {
+        AddImplication({e}, lit.value());
+        ++num_var_op_var_imp_cached;
+      } else {
+        AddLinearConstraint({e}, Domain(right.value), {{left.var, 1}});
+      }
+    } else {
+      const std::optional<int> lit = GetVarEqVarLiteral(left.var, right.var);
+      if (lit.has_value()) {
+        AddImplication({e}, lit.value());
+        ++num_var_op_var_imp_cached;
+      } else {
+        AddLinearConstraint({e}, Domain(0), {{left.var, 1}, {right.var, -1}});
+      }
+    }
+  } else if (fz_ct.type == "int_ne_reif" || fz_ct.type == "bool_ne_reif") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    if (left.var == kNoVar) std::swap(left, right);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      CHECK_EQ(right.var, kNoVar);
+      if (left.value != right.value) {
+        AddImplication({}, e);
+      } else {
+        AddImplication({}, NegatedRef(e));
+      }
+    } else if (right.var == kNoVar) {
+      AddVarEqValueLiteral(left.var, right.value, NegatedRef(e));
+    } else {
+      AddVarEqVarLiteral(left.var, right.var, NegatedRef(e));
+    }
+  } else if (fz_ct.type == "int_ne_imp" || fz_ct.type == "bool_ne_imp") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    if (left.var == kNoVar) std::swap(left, right);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      CHECK_EQ(right.var, kNoVar);
+      if (left.value == right.value) {
+        AddImplication({}, NegatedRef(e));
+      }
+    } else if (right.var == kNoVar) {
+      const std::optional<int> lit = GetEncodingLiteral(left.var, right.value);
+      if (lit.has_value()) {
+        AddImplication({e}, NegatedRef(lit.value()));
+        ++num_var_op_var_imp_cached;
+      } else {
+        AddLinearConstraint({e}, Domain(right.value).Complement(),
+                            {{left.var, 1}});
+      }
+    } else {
+      const std::optional<int> lit = GetVarNeVarLiteral(left.var, right.var);
+      if (lit.has_value()) {
+        AddImplication({e}, lit.value());
+        ++num_var_op_var_imp_cached;
+      } else {
+        AddLinearConstraint({e}, Domain(0).Complement(),
+                            {{left.var, 1}, {right.var, -1}});
+      }
+    }
+  } else if (fz_ct.type == "int_le_reif" || fz_ct.type == "bool_le_reif") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      if (right.var == kNoVar) {
+        if (left.value <= right.value) {
+          AddImplication({}, e);
+        } else {
+          AddImplication({}, NegatedRef(e));
+        }
+      } else {
+        AddVarGeValueLiteral(right.var, left.value, e);
+      }
+    } else if (right.var == kNoVar) {
+      AddVarLeValueLiteral(left.var, right.value, e);
+    } else {
+      AddVarLeVarLiteral(left.var, right.var, e);
+    }
+  } else if (fz_ct.type == "int_le_imp" || fz_ct.type == "bool_le_imp") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      if (right.var == kNoVar) {
+        if (left.value > right.value) {
+          AddImplication({}, NegatedRef(e));
+        }
+      } else {
+        AddLinearConstraint({e},
+                            {left.value, std::numeric_limits<int64_t>::max()},
+                            {{right.var, 1}});
+      }
+    } else if (right.var == kNoVar) {
+      AddLinearConstraint({e},
+                          {std::numeric_limits<int64_t>::min(), right.value},
+                          {{left.var, 1}});
+    } else {
+      const std::optional<int> lit = GetVarLeVarLiteral(left.var, right.var);
+      if (lit.has_value()) {
+        AddImplication({e}, lit.value());
+        ++num_var_op_var_imp_cached;
+      } else {
+        AddLinearConstraint({e}, {std::numeric_limits<int64_t>::min(), 0},
+                            {{left.var, 1}, {right.var, -1}});
+      }
+    }
+  } else if (fz_ct.type == "int_ge_reif" || fz_ct.type == "bool_ge_reif") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      if (right.var == kNoVar) {
+        if (left.value >= right.value) {
+          AddImplication({}, e);
+        } else {
+          AddImplication({}, NegatedRef(e));
+        }
+      } else {
+        AddVarLeValueLiteral(right.var, left.value, e);
+      }
+    } else if (right.var == kNoVar) {
+      AddVarGeValueLiteral(left.var, right.value, e);
+    } else {
+      AddVarLeVarLiteral(right.var, left.var, e);
+    }
+  } else if (fz_ct.type == "int_lt_reif" || fz_ct.type == "bool_lt_reif") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      if (right.var == kNoVar) {
+        if (left.value < right.value) {
+          AddImplication({}, e);
+        } else {
+          AddImplication({}, NegatedRef(e));
+        }
+      } else {
+        AddVarGtValueLiteral(right.var, left.value, e);
+      }
+    } else if (right.var == kNoVar) {
+      AddVarLtValueLiteral(left.var, right.value, e);
+    } else {
+      AddVarLtVarLiteral(left.var, right.var, e);
+    }
+  } else if (fz_ct.type == "int_gt_reif" || fz_ct.type == "bool_gt_reif") {
+    VarOrValue left = LookupVarOrValue(fz_ct.arguments[0]);
+    VarOrValue right = LookupVarOrValue(fz_ct.arguments[1]);
+    const int e = LookupVar(fz_ct.arguments[2]);
+    if (left.var == kNoVar) {
+      if (right.var == kNoVar) {
+        if (left.value < right.value) {
+          AddImplication({}, e);
+        } else {
+          AddImplication({}, NegatedRef(e));
+        }
+      } else {
+        AddVarLtValueLiteral(right.var, left.value, e);
+      }
+    } else if (right.var == kNoVar) {
+      AddVarGtValueLiteral(left.var, right.value, e);
+    } else {
+      AddVarLtVarLiteral(right.var, left.var, e);
+    }
+  } else if (fz_ct.type == "array_bool_or") {
+    const std::vector<int> literals = LookupVars(fz_ct.arguments[0]);
+    const int e = LookupVar(fz_ct.arguments[1]);
+    switch (literals.size()) {
+      case 0: {
+        AddImplication({}, NegatedRef(e));
+        break;
+      }
+      case 1: {
+        AddLinearConstraint({}, Domain(0), {{literals[0], 1}, {e, -1}});
+        break;
+      }
+      case 2: {
+        AddVarOrVarLiteral(literals[0], literals[1], e);
+        break;
+      }
+      default: {
+        ConstraintProto* imply = AddEnforcedConstraint(e);
+        for (int i = 0; i < literals.size(); ++i) {
+          imply->mutable_bool_or()->add_literals(literals[i]);
+        }
+        ConstraintProto* refute = AddEnforcedConstraint(NegatedRef(e));
+        for (int i = 0; i < literals.size(); ++i) {
+          refute->mutable_bool_and()->add_literals(NegatedRef(literals[i]));
+        }
+      }
+    }
+  } else if (fz_ct.type == "array_bool_and") {
+    const std::vector<int> literals = LookupVars(fz_ct.arguments[0]);
+    const int e = LookupVar(fz_ct.arguments[1]);
+    switch (literals.size()) {
+      case 0: {
+        AddImplication({}, e);
+        break;
+      }
+      case 1: {
+        AddLinearConstraint({}, Domain(0), {{literals[0], 1}, {e, -1}});
+        break;
+      }
+      case 2: {
+        AddVarAndVarLiteral(literals[0], literals[1], e);
+        break;
+      }
+      default: {
+        ConstraintProto* imply = AddEnforcedConstraint(e);
+        for (int i = 0; i < literals.size(); ++i) {
+          imply->mutable_bool_and()->add_literals(literals[i]);
+        }
+        ConstraintProto* refute = AddEnforcedConstraint(NegatedRef(e));
+        for (int i = 0; i < literals.size(); ++i) {
+          refute->mutable_bool_or()->add_literals(NegatedRef(literals[i]));
+        }
+      }
+    }
   } else {
-    // Keep name as it is an implicit reified constraint.
-    simplified_type = fz_ct.type;
+    // Start by adding a non-reified version of the same constraint.
+    ConstraintProto* ct = proto.add_constraints();
+    ct->set_name(fz_ct.type);
+    std::string simplified_type;
+    if (absl::EndsWith(fz_ct.type, "_reif")) {
+      // Remove _reif.
+      simplified_type = fz_ct.type.substr(0, fz_ct.type.size() - 5);
+    } else if (absl::EndsWith(fz_ct.type, "_imp")) {
+      // Remove _imp.
+      simplified_type = fz_ct.type.substr(0, fz_ct.type.size() - 4);
+    } else {
+      // Keep name as it is an implicit reified constraint.
+      simplified_type = fz_ct.type;
+    }
+
+    // We need a copy to be able to change the type of the constraint.
+    fz::Constraint copy = fz_ct;
+    copy.type = simplified_type;
+
+    // Create the CP-SAT constraint.
+    FillConstraint(copy, ct);
+
+    // In case of reified constraints, the type of the opposite constraint.
+    std::string negated_type;
+
+    // Fill enforcement_literal and set copy.type to the negated constraint.
+    if (simplified_type == "set_in") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
+      negated_type = "set_in_negated";
+    } else if (simplified_type == "bool_eq" || simplified_type == "int_eq") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
+      negated_type = "int_ne";
+    } else if (simplified_type == "bool_ne" || simplified_type == "int_ne") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
+      negated_type = "int_eq";
+    } else if (simplified_type == "bool_le" || simplified_type == "int_le") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
+      negated_type = "int_gt";
+    } else if (simplified_type == "bool_lt" || simplified_type == "int_lt") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
+      negated_type = "int_ge";
+    } else if (simplified_type == "bool_ge" || simplified_type == "int_ge") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
+      negated_type = "int_lt";
+    } else if (simplified_type == "bool_gt" || simplified_type == "int_gt") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
+      negated_type = "int_le";
+    } else if (simplified_type == "int_lin_eq") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
+      negated_type = "int_lin_ne";
+    } else if (simplified_type == "int_lin_ne") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
+      negated_type = "int_lin_eq";
+    } else if (simplified_type == "int_lin_le") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
+      negated_type = "int_lin_gt";
+    } else if (simplified_type == "int_lin_ge") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
+      negated_type = "int_lin_lt";
+    } else if (simplified_type == "int_lin_lt") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
+      negated_type = "int_lin_ge";
+    } else if (simplified_type == "int_lin_gt") {
+      ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
+      negated_type = "int_lin_le";
+    } else {
+      LOG(FATAL) << "Unsupported " << simplified_type;
+    }
+
+    // One way implication. We can stop here.
+    if (absl::EndsWith(fz_ct.type, "_imp")) return;
+
+    // Add the other side of the reification because CpModelProto only support
+    // half reification.
+    ConstraintProto* negated_ct =
+        AddEnforcedConstraint(NegatedRef(ct->enforcement_literal(0)));
+    negated_ct->set_name(fz_ct.type + " (negated)");
+    copy.type = negated_type;
+    FillConstraint(copy, negated_ct);
   }
-
-  // We need a copy to be able to change the type of the constraint.
-  fz::Constraint copy = fz_ct;
-  copy.type = simplified_type;
-
-  // Create the CP-SAT constraint.
-  FillConstraint(copy, ct);
-
-  // In case of reified constraints, the type of the opposite constraint.
-  std::string negated_type;
-
-  // Fill enforcement_literal and set copy.type to the negated constraint.
-  if (simplified_type == "array_bool_or") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[1]));
-    negated_type = "array_bool_or_negated";
-  } else if (simplified_type == "array_bool_and") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[1]));
-    negated_type = "array_bool_and_negated";
-  } else if (simplified_type == "set_in") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
-    negated_type = "set_in_negated";
-  } else if (simplified_type == "bool_eq" || simplified_type == "int_eq") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
-    negated_type = "int_ne";
-  } else if (simplified_type == "bool_ne" || simplified_type == "int_ne") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
-    negated_type = "int_eq";
-  } else if (simplified_type == "bool_le" || simplified_type == "int_le") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
-    negated_type = "int_gt";
-  } else if (simplified_type == "bool_lt" || simplified_type == "int_lt") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
-    negated_type = "int_ge";
-  } else if (simplified_type == "bool_ge" || simplified_type == "int_ge") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
-    negated_type = "int_lt";
-  } else if (simplified_type == "bool_gt" || simplified_type == "int_gt") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[2]));
-    negated_type = "int_le";
-  } else if (simplified_type == "int_lin_eq") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
-    negated_type = "int_lin_ne";
-  } else if (simplified_type == "int_lin_ne") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
-    negated_type = "int_lin_eq";
-  } else if (simplified_type == "int_lin_le") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
-    negated_type = "int_lin_gt";
-  } else if (simplified_type == "int_lin_ge") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
-    negated_type = "int_lin_lt";
-  } else if (simplified_type == "int_lin_lt") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
-    negated_type = "int_lin_ge";
-  } else if (simplified_type == "int_lin_gt") {
-    ct->add_enforcement_literal(LookupVar(fz_ct.arguments[3]));
-    negated_type = "int_lin_le";
-  } else {
-    LOG(FATAL) << "Unsupported " << simplified_type;
-  }
-
-  // One way implication. We can stop here.
-  if (absl::EndsWith(fz_ct.type, "_imp")) return;
-
-  // Add the other side of the reification because CpModelProto only support
-  // half reification.
-  ConstraintProto* negated_ct =
-      AddEnforcedConstraint(NegatedRef(ct->enforcement_literal(0)));
-  negated_ct->set_name(fz_ct.type + " (negated)");
-  copy.type = negated_type;
-  FillConstraint(copy, negated_ct);
 }
 
 void CpModelProtoWithMapping::TranslateSearchAnnotations(
@@ -2215,11 +3186,17 @@ std::string SolutionString(
     }
     result.append("[");
     for (int i = 0; i < output.flat_variables.size(); ++i) {
-      const int64_t value = value_func(output.flat_variables[i]);
-      if (output.display_as_boolean) {
-        result.append(value ? "true" : "false");
+      if (output.flat_variables[i]->domain.is_a_set) {
+        const std::vector<int64_t> values =
+            set_evaluator(output.flat_variables[i]);
+        absl::StrAppend(&result, "{", absl::StrJoin(values, ","), "}");
       } else {
-        absl::StrAppend(&result, value);
+        const int64_t value = value_func(output.flat_variables[i]);
+        if (output.display_as_boolean) {
+          result.append(value ? "true" : "false");
+        } else {
+          absl::StrAppend(&result, value);
+        }
       }
       if (i != output.flat_variables.size() - 1) {
         result.append(", ");
@@ -2327,16 +3304,19 @@ void SolveFzWithCpModelProto(const fz::Model& fz_model,
                              const std::string& sat_params,
                              SolverLogger* logger,
                              SolverLogger* solution_logger) {
-  CpModelProtoWithMapping m;
+  const bool enumerate_all_solutions_of_a_sat_problem =
+      p.search_all_solutions && fz_model.objective() == nullptr;
+  CpModelProtoWithMapping m(enumerate_all_solutions_of_a_sat_problem);
   m.proto.set_name(fz_model.name());
 
-  // The translation is easy, we create one variable per flatzinc variable,
-  // plus eventually a bunch of constant variables that will be created
+  // The translation is easy, we create one variable
+  // per flatzinc variable, plus eventually a bunch
+  // of constant variables that will be created
   // lazily.
   for (fz::Variable* fz_var : fz_model.variables()) {
     if (!fz_var->active) continue;
-    CHECK(!fz_var->domain.is_float)
-        << "CP-SAT does not support float variables";
+    CHECK(!fz_var->domain.is_float) << "CP-SAT does not support float "
+                                       "variables";
 
     if (fz_var->domain.is_a_set) {
       std::shared_ptr<SetVariable> set_var = std::make_shared<SetVariable>();
@@ -2371,20 +3351,22 @@ void SolveFzWithCpModelProto(const fz::Model& fz_model,
       var->set_name(fz_var->name);
       if (fz_var->domain.is_interval) {
         if (fz_var->domain.values.empty()) {
-          // The CP-SAT solver checks that constraints cannot overflow during
-          // their propagation. Because of that, we trim undefined variable
-          // domains (i.e. int in minizinc) to something hopefully large enough.
-          LOG_FIRST_N(WARNING, 1)
-              << "Using flag --fz_int_max for unbounded integer variables.";
+          // The CP-SAT solver checks that
+          // constraints cannot overflow during
+          // their propagation. Because of that, we
+          // trim undefined variable domains (i.e.
+          // int in minizinc) to something hopefully
+          // large enough.
+          LOG_FIRST_N(WARNING, 1) << "Using flag --fz_int_max for "
+                                     "unbounded integer variables.";
           LOG_FIRST_N(WARNING, 1)
               << "    actual domain is [" << -absl::GetFlag(FLAGS_fz_int_max)
               << ".." << absl::GetFlag(FLAGS_fz_int_max) << "]";
-          FillDomainInProto({-absl::GetFlag(FLAGS_fz_int_max),
-                             absl::GetFlag(FLAGS_fz_int_max)},
-                            var);
+          FillDomainInProto(-absl::GetFlag(FLAGS_fz_int_max),
+                            absl::GetFlag(FLAGS_fz_int_max), var);
         } else {
-          FillDomainInProto(
-              {fz_var->domain.values[0], fz_var->domain.values[1]}, var);
+          FillDomainInProto(fz_var->domain.values[0], fz_var->domain.values[1],
+                            var);
         }
       } else {
         FillDomainInProto(Domain::FromValues(fz_var->domain.values), var);
@@ -2393,23 +3375,33 @@ void SolveFzWithCpModelProto(const fz::Model& fz_model,
   }
 
   // Translate the constraints.
+
+  // First pass: extract useful information.
+  for (fz::Constraint* fz_ct : fz_model.constraints()) {
+    m.FirstPass(*fz_ct);
+  }
+
+  // Second pass: translate the constraints.
   for (fz::Constraint* fz_ct : fz_model.constraints()) {
     if (fz_ct == nullptr || !fz_ct->active) continue;
     if (m.ConstraintContainsSetVariables(*fz_ct)) {
       m.ExtractSetConstraint(*fz_ct);
     } else {
-      ConstraintProto* ct = m.proto.add_constraints();
-      ct->set_name(fz_ct->type);
       if (absl::EndsWith(fz_ct->type, "_reif") ||
           absl::EndsWith(fz_ct->type, "_imp") ||
           fz_ct->type == "array_bool_or" || fz_ct->type == "array_bool_and") {
-        m.FillReifOrImpliedConstraint(*fz_ct, ct);
+        m.FillReifiedOrImpliedConstraint(*fz_ct);
       } else {
+        ConstraintProto* ct = m.proto.add_constraints();
+        ct->set_name(fz_ct->type);
         m.FillConstraint(*fz_ct, ct);
       }
     }
   }
 
+  // Third pass: Implement the encoding constraints.
+  m.AddAllEncodingConstraints();
+
   // Fill the objective.
   if (fz_model.objective() != nullptr) {
     CpObjectiveProto* objective = m.proto.mutable_objective();
@@ -2435,6 +3427,21 @@ void SolveFzWithCpModelProto(const fz::Model& fz_model,
   // Fill the search order.
   m.TranslateSearchAnnotations(fz_model.search_annotations(), logger);
 
+  // Extra statistics.
+  SOLVER_LOG(logger,
+             "  - #var_op_value_reif cached: ", m.num_var_op_value_reif_cached);
+  SOLVER_LOG(logger,
+             "  - #var_op_var_reif cached: ", m.num_var_op_var_reif_cached);
+  SOLVER_LOG(logger,
+             "  - #var_op_var_imp cached: ", m.num_var_op_var_reif_cached);
+  SOLVER_LOG(logger, "  - #full domain encodings: ", m.num_full_encodings);
+  if (absl::GetFlag(FLAGS_fz_use_light_encoding)) {
+    SOLVER_LOG(logger,
+               "  - #partial domain encodings: ", m.num_partial_encodings);
+    SOLVER_LOG(logger,
+               "  - #light constraint encodings: ", m.num_light_encodings);
+  }
+
   if (p.search_all_solutions && !m.proto.has_objective()) {
     // Enumerate all sat solutions.
     m.parameters.set_enumerate_all_solutions(true);
@@ -2596,6 +3603,7 @@ void SolveFzWithCpModelProto(const fz::Model& fz_model,
   if (p.ortools_mode) {
     if (response.status() == CpSolverStatus::FEASIBLE ||
         response.status() == CpSolverStatus::OPTIMAL) {
+      // Display the solution if it is not already displayed.
       if (!p.display_all_solutions && !p.search_all_solutions) {
         // Already printed otherwise.
         const std::string solution_string = SolutionString(
@@ -2618,7 +3626,11 @@ void SolveFzWithCpModelProto(const fz::Model& fz_model,
         SOLVER_LOG(solution_logger, solution_string);
         SOLVER_LOG(solution_logger, "----------");
       }
-      if (response.status() == CpSolverStatus::OPTIMAL) {
+      const bool should_print_optimal =
+          response.status() == CpSolverStatus::OPTIMAL &&
+          (fz_model.objective() != nullptr || p.search_all_solutions);
+
+      if (should_print_optimal) {
         SOLVER_LOG(solution_logger, "==========");
       }
     } else if (response.status() == CpSolverStatus::INFEASIBLE) {
diff --git a/ortools/flatzinc/fz.cc b/ortools/flatzinc/fz.cc
index d0ddba5dec..85afa11865 100644
--- a/ortools/flatzinc/fz.cc
+++ b/ortools/flatzinc/fz.cc
@@ -68,6 +68,10 @@ ABSL_FLAG(bool, ortools_mode, kOrToolsMode,
           "Display solutions in the flatzinc format");
 ABSL_FLAG(bool, fz_check_all_solutions, DEBUG_MODE,
           "Checks all solutions returned by the solver.");
+ABSL_FLAG(bool, ignore_redundant_constraints, false,
+          "Ignore redundant constraints.");
+ABSL_FLAG(bool, ignore_symmetry_breaking_constraints, false,
+          "Ignore symmetry breaking constraints.");
 
 namespace operations_research {
 namespace fz {
@@ -161,6 +165,28 @@ Model ParseFlatzincModel(const std::string& input, bool input_is_filename,
   *parse_duration = timer.GetDuration();
   SOLVER_LOG(logger, "File ", (input_is_filename ? input : "stdin"),
              " parsed in ", absl::ToInt64Milliseconds(*parse_duration), " ms");
+
+  int num_redundant_constraints = 0;
+  int num_symmetry_breaking_constraints = 0;
+  for (Constraint* ct : model.constraints()) {
+    if (ct->is_redundant && absl::GetFlag(FLAGS_ignore_redundant_constraints)) {
+      ++num_redundant_constraints;
+      ct->MarkAsInactive();
+    }
+    if (ct->is_symmetric_breaking &&
+        absl::GetFlag(FLAGS_ignore_symmetry_breaking_constraints)) {
+      ++num_symmetry_breaking_constraints;
+      ct->MarkAsInactive();
+    }
+  }
+  if (num_redundant_constraints > 0) {
+    SOLVER_LOG(logger, "  - ignored redundant constraints: ",
+               num_redundant_constraints);
+  }
+  if (num_symmetry_breaking_constraints > 0) {
+    SOLVER_LOG(logger, "  - ignored symmetry breaking constraints: ",
+               num_symmetry_breaking_constraints);
+  }
   SOLVER_LOG(logger, "");
 
   // Print statistics.
diff --git a/ortools/flatzinc/model.cc b/ortools/flatzinc/model.cc
index 4964b6a22b..a7ae81f56d 100644
--- a/ortools/flatzinc/model.cc
+++ b/ortools/flatzinc/model.cc
@@ -809,13 +809,15 @@ std::string Variable::DebugString() const {
 // ----- Constraint -----
 
 std::string Constraint::DebugString() const {
-  const std::string strong = strong_propagation ? "strong propagation" : "";
+  const std::string strong = strong_propagation ? " strong propagation" : "";
   const std::string presolve_status_str =
-      active ? ""
-             : (presolve_propagation_done ? "[propagated during presolve]"
-                                          : "[removed during presolve]");
-  return absl::StrFormat("%s(%s)%s %s", type, JoinDebugString(arguments, ", "),
-                         strong, presolve_status_str);
+      active ? "" : " [removed during presolve]";
+  const std::string symmetric_breaking_str =
+      is_symmetric_breaking ? " symmetric breaking" : "";
+  const std::string redundant_str = is_redundant ? " redundant" : "";
+  return absl::StrCat(type, "(", JoinDebugString(arguments, ", "), ")", strong,
+                      presolve_status_str, symmetric_breaking_str,
+                      redundant_str);
 }
 
 void Constraint::RemoveArg(int arg_pos) {
@@ -1056,15 +1058,15 @@ Variable* Model::AddFloatConstant(double value) {
 }
 
 void Model::AddConstraint(absl::string_view id, std::vector<Argument> arguments,
-                          bool is_domain) {
+                          bool is_domain, bool symmetry, bool redundant) {
   Constraint* const constraint =
-      new Constraint(id, std::move(arguments), is_domain);
+      new Constraint(id, std::move(arguments), is_domain, symmetry, redundant);
   constraints_.push_back(constraint);
 }
 
 void Model::AddConstraint(absl::string_view id,
                           std::vector<Argument> arguments) {
-  AddConstraint(id, std::move(arguments), false);
+  AddConstraint(id, std::move(arguments), false, false, false);
 }
 
 void Model::AddOutput(SolutionOutputSpecs output) {
@@ -1146,33 +1148,60 @@ void ModelStatistics::PrintStatistics() const {
   SOLVER_LOG(logger_, "Model ", model_.name());
 
   // Variables.
-  int num_int_var = 0;
-  int num_float_var = 0;
-  int num_set_var = 0;
+  int num_bool_vars = 0;
+  int num_int_vars = 0;
+  int num_float_vars = 0;
+  int num_set_vars = 0;
   for (Variable* var : model_.variables()) {
     if (var->domain.is_float) {
-      ++num_float_var;
+      ++num_float_vars;
     } else if (var->domain.is_a_set) {
-      ++num_set_var;
+      ++num_set_vars;
+    } else if (var->domain.display_as_boolean) {
+      ++num_bool_vars;
     } else {
-      ++num_int_var;
+      ++num_int_vars;
     }
   }
-  if (num_int_var > 0) {
-    SOLVER_LOG(logger_, "  - integer variables:", num_int_var);
+  if (num_bool_vars > 0) {
+    SOLVER_LOG(logger_, "  - boolean variables:", num_bool_vars);
   }
-  if (num_float_var > 0) {
-    SOLVER_LOG(logger_, "  - float variables:", num_float_var);
+  if (num_int_vars > 0) {
+    SOLVER_LOG(logger_, "  - integer variables:", num_int_vars);
   }
-  if (num_set_var > 0) {
-    SOLVER_LOG(logger_, "  - set variables:", num_set_var);
+  if (num_float_vars > 0) {
+    SOLVER_LOG(logger_, "  - float variables:", num_float_vars);
+  }
+  if (num_set_vars > 0) {
+    SOLVER_LOG(logger_, "  - set variables:", num_set_vars);
   }
   SOLVER_LOG(logger_);
 
   // Constraints.
+  int num_redundant_constraints = 0;
+  int num_symmetry_breaking_constraints = 0;
+  for (Constraint* const ct : model_.constraints()) {
+    if (ct != nullptr && ct->active) {
+      if (ct->is_redundant) {
+        ++num_redundant_constraints;
+      }
+      if (ct->is_symmetric_breaking) {
+        ++num_symmetry_breaking_constraints;
+      }
+    }
+  }
   for (const auto& it : constraints_per_type_) {
     SOLVER_LOG(logger_, "  - ", it.first, ": ", it.second.size());
   }
+  SOLVER_LOG(logger_);
+  if (num_redundant_constraints > 0) {
+    SOLVER_LOG(logger_,
+               "  -  redundant constraints: ", num_redundant_constraints);
+  }
+  if (num_symmetry_breaking_constraints > 0) {
+    SOLVER_LOG(logger_, "  - symmetry breaking constraints: ",
+               num_symmetry_breaking_constraints);
+  }
   if (model_.objective() == nullptr) {
     SOLVER_LOG(logger_, "  - Satisfaction problem");
   } else {
diff --git a/ortools/flatzinc/model.h b/ortools/flatzinc/model.h
index fff8976ddb..3b6b3c8d80 100644
--- a/ortools/flatzinc/model.h
+++ b/ortools/flatzinc/model.h
@@ -218,12 +218,13 @@ struct Argument {
 // Constraint is on the heap, and owned by the global Model object.
 struct Constraint {
   Constraint(absl::string_view t, std::vector<Argument> args,
-             bool strong_propag)
+             bool strong_propag, bool sym, bool redundant)
       : type(t),
         arguments(std::move(args)),
         strong_propagation(strong_propag),
         active(true),
-        presolve_propagation_done(false) {}
+        is_symmetric_breaking(sym),
+        is_redundant(redundant) {}
 
   std::string DebugString() const;
 
@@ -250,8 +251,11 @@ struct Constraint {
   // presolve.
   bool active : 1;
 
-  // Indicates if presolve has finished propagating this constraint.
-  bool presolve_propagation_done : 1;
+  // Indicates if the constraint is a symmetric breaking constraint.
+  bool is_symmetric_breaking : 1;
+
+  // Indicates if the constraint is a redundant constraint.
+  bool is_redundant : 1;
 };
 
 // An annotation is a set of information. It has two use cases. One during
@@ -354,7 +358,7 @@ class Model {
   Variable* AddFloatConstant(double value);
   // Creates and add a constraint to the model.
   void AddConstraint(absl::string_view id, std::vector<Argument> arguments,
-                     bool is_domain);
+                     bool is_domain, bool symmetry, bool redundant);
   void AddConstraint(absl::string_view id, std::vector<Argument> arguments);
   void AddOutput(SolutionOutputSpecs output);
 
diff --git a/ortools/flatzinc/mznlib/fzn_all_different_set.mzn b/ortools/flatzinc/mznlib/fzn_all_different_set.mzn
new file mode 100644
index 0000000000..4f85127fa6
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_all_different_set.mzn
@@ -0,0 +1 @@
+predicate fzn_all_different_set(array [int] of var set of int: x)
diff --git a/ortools/flatzinc/mznlib/fzn_all_disjoint.mzn b/ortools/flatzinc/mznlib/fzn_all_disjoint.mzn
new file mode 100644
index 0000000000..f208372dd1
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_all_disjoint.mzn
@@ -0,0 +1 @@
+predicate fzn_all_disjoint(array [int] of var set of int: S);
diff --git a/ortools/flatzinc/mznlib/fzn_all_equal_int.mzn b/ortools/flatzinc/mznlib/fzn_all_equal_int.mzn
new file mode 100644
index 0000000000..8b604a3a27
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_all_equal_int.mzn
@@ -0,0 +1,4 @@
+predicate fzn_all_equal_int(array [int] of var int: x) =
+  if length(x) > 1 then
+    forall (i in index_set(x) diff {min(index_set(x))}) (x[min(index_set(x))] = x[i])
+  endif;
diff --git a/ortools/flatzinc/mznlib/fzn_all_equal_set.mzn b/ortools/flatzinc/mznlib/fzn_all_equal_set.mzn
new file mode 100644
index 0000000000..e177e94ef9
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_all_equal_set.mzn
@@ -0,0 +1,4 @@
+predicate fzn_all_equal_set(array [int] of var set of int: x) =
+  if length(x) > 1 then
+    forall (i in index_set(x) diff {min(index_set(x))}) (x[min(index_set(x))] = x[i])
+  endif;
diff --git a/ortools/flatzinc/mznlib/fzn_arg_max_bool.mzn b/ortools/flatzinc/mznlib/fzn_arg_max_bool.mzn
new file mode 100644
index 0000000000..061ce59541
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_arg_max_bool.mzn
@@ -0,0 +1,4 @@
+predicate ortools_arg_max_bool(array [int] of var bool: x, var int: z, int: min_index, int: multiplier);
+
+predicate fzn_maximum_arg_bool(array [int] of var bool: x, var int: z) =
+  ortools_arg_max_bool(x, z, min(index_set(x)), 1);
diff --git a/ortools/flatzinc/mznlib/fzn_arg_max_int.mzn b/ortools/flatzinc/mznlib/fzn_arg_max_int.mzn
new file mode 100644
index 0000000000..ca8ae038e0
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_arg_max_int.mzn
@@ -0,0 +1,4 @@
+predicate ortools_arg_max_int(array [int] of var int: x, var int: z, int: min_index, int: multiplier);
+
+predicate fzn_maximum_arg_int(array [int] of var int: x, var int: z) =
+  ortools_arg_max_int(x, z, min(index_set(x)), 1);
diff --git a/ortools/flatzinc/mznlib/fzn_arg_min_bool.mzn b/ortools/flatzinc/mznlib/fzn_arg_min_bool.mzn
new file mode 100644
index 0000000000..c400c5ae17
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_arg_min_bool.mzn
@@ -0,0 +1,4 @@
+predicate ortools_arg_max_bool(array [int] of var bool: x, var int: z, int: min_index, int: multiplier);
+
+predicate fzn_minimum_arg_bool(array [int] of var bool: x, var int: z) =
+  ortools_arg_max_bool(x, z, min(index_set(x)), -1);
diff --git a/ortools/flatzinc/mznlib/fzn_arg_min_int.mzn b/ortools/flatzinc/mznlib/fzn_arg_min_int.mzn
new file mode 100644
index 0000000000..d5704becc0
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_arg_min_int.mzn
@@ -0,0 +1,4 @@
+predicate ortools_arg_max_int(array [int] of var int: x, var int: z, int: min_index, int: multiplier);
+
+predicate fzn_minimum_arg_int(array [int] of var int: x, var int: z) =
+  ortools_arg_max_int(x, z, min(index_set(x)), -1);
diff --git a/ortools/flatzinc/mznlib/fzn_disjoint.mzn b/ortools/flatzinc/mznlib/fzn_disjoint.mzn
new file mode 100644
index 0000000000..d1eb375b07
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_disjoint.mzn
@@ -0,0 +1 @@
+predicate fzn_disjoint(var set of int: s1, var set of int: s2);
diff --git a/ortools/flatzinc/mznlib/fzn_global_cardinality.mzn b/ortools/flatzinc/mznlib/fzn_global_cardinality.mzn
new file mode 100644
index 0000000000..a606602f58
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_global_cardinality.mzn
@@ -0,0 +1,12 @@
+predicate ortools_global_cardinality(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of var int: counts,
+  bool: closed,
+);
+
+predicate fzn_global_cardinality(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of var int: counts,
+) = ortools_global_cardinality(x, cover, counts, false);
diff --git a/ortools/flatzinc/mznlib/fzn_global_cardinality_closed.mzn b/ortools/flatzinc/mznlib/fzn_global_cardinality_closed.mzn
new file mode 100644
index 0000000000..f40302c731
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_global_cardinality_closed.mzn
@@ -0,0 +1,12 @@
+predicate ortools_global_cardinality(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of var int: counts,
+  bool: closed,
+);
+
+predicate fzn_global_cardinality_closed(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of var int: counts,
+) = ortools_global_cardinality(x, cover, counts, true);
diff --git a/ortools/flatzinc/mznlib/fzn_global_cardinality_low_up.mzn b/ortools/flatzinc/mznlib/fzn_global_cardinality_low_up.mzn
new file mode 100644
index 0000000000..e64c3f4b7b
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_global_cardinality_low_up.mzn
@@ -0,0 +1,14 @@
+predicate ortools_global_cardinality_low_up(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of int: lbound,
+  array [int] of int: ubound,
+  bool: closed,
+);
+
+predicate fzn_global_cardinality_low_up(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of int: lbound,
+  array [int] of int: ubound,
+) = ortools_global_cardinality_low_up(x, cover, lbound, ubound, false);
diff --git a/ortools/flatzinc/mznlib/fzn_global_cardinality_low_up_closed.mzn b/ortools/flatzinc/mznlib/fzn_global_cardinality_low_up_closed.mzn
new file mode 100644
index 0000000000..30767565dc
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_global_cardinality_low_up_closed.mzn
@@ -0,0 +1,14 @@
+predicate ortools_global_cardinality_low_up(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of int: lbound,
+  array [int] of int: ubound,
+  bool: closed,
+);
+
+predicate fzn_global_cardinality_low_up_closed(
+  array [int] of var int: x,
+  array [int] of int: cover,
+  array [int] of int: lbound,
+  array [int] of int: ubound,
+) = ortools_global_cardinality_low_up(x, cover, lbound, ubound, true);
diff --git a/ortools/flatzinc/mznlib/fzn_lex_less_bool.mzn b/ortools/flatzinc/mznlib/fzn_lex_less_bool.mzn
new file mode 100644
index 0000000000..b7843a8e24
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_lex_less_bool.mzn
@@ -0,0 +1,14 @@
+%-----------------------------------------------------------------------------%
+% Requires that the array 'x' is strictly lexicographically less than array 'y'.
+% Compares them from first to last element, regardless of indices
+%-----------------------------------------------------------------------------%
+
+predicate ortools_lex_less_bool(
+  array [int] of var bool: x,
+  array [int] of var bool: y,
+);
+
+predicate fzn_lex_less_bool(
+  array [int] of var bool: x :: promise_ctx_antitone,
+  array [int] of var bool: y :: promise_ctx_monotone,
+) = ortools_lex_less_bool(x, y);
\ No newline at end of file
diff --git a/ortools/flatzinc/mznlib/fzn_lex_less_int.mzn b/ortools/flatzinc/mznlib/fzn_lex_less_int.mzn
new file mode 100644
index 0000000000..ca9993071e
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_lex_less_int.mzn
@@ -0,0 +1,14 @@
+%-----------------------------------------------------------------------------%
+% Requires that the array 'x' is strictly lexicographically less than array 'y'.
+% Compares them from first to last element, regardless of indices
+%-----------------------------------------------------------------------------%
+
+predicate ortools_lex_less_int(
+  array [int] of var int: x,
+  array [int] of var int: y,
+);
+
+predicate fzn_lex_less_int(
+  array [int] of var int: x :: promise_ctx_antitone,
+  array [int] of var int: y :: promise_ctx_monotone,
+) = ortools_lex_less_int(x, y);
\ No newline at end of file
diff --git a/ortools/flatzinc/mznlib/fzn_lex_lesseq_bool.mzn b/ortools/flatzinc/mznlib/fzn_lex_lesseq_bool.mzn
new file mode 100644
index 0000000000..48a063fd4b
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_lex_lesseq_bool.mzn
@@ -0,0 +1,14 @@
+%-----------------------------------------------------------------------------%
+% Requires that the array 'x' is lexicographically less than or equal to array 'y'.
+% Compares them from first to last element, regardless of indices
+%-----------------------------------------------------------------------------%
+
+predicate ortools_lex_lesseq_bool(
+  array [int] of var bool: x,
+  array [int] of var bool: y,
+);
+
+predicate fzn_lex_lesseq_bool(
+  array [int] of var bool: x :: promise_ctx_antitone,
+  array [int] of var bool: y :: promise_ctx_monotone,
+) = ortools_lex_lesseq_bool(x, y);
\ No newline at end of file
diff --git a/ortools/flatzinc/mznlib/fzn_lex_lesseq_int.mzn b/ortools/flatzinc/mznlib/fzn_lex_lesseq_int.mzn
new file mode 100644
index 0000000000..9fbee923ed
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_lex_lesseq_int.mzn
@@ -0,0 +1,14 @@
+%-----------------------------------------------------------------------------%
+% Requires that the array 'x' is lexicographically less than or equal to array 'y'.
+% Compares them from first to last element, regardless of indices
+%-----------------------------------------------------------------------------%
+
+predicate ortools_lex_lesseq_int(
+  array [int] of var int: x,
+  array [int] of var int: y,
+);
+
+predicate fzn_lex_lesseq_int(
+  array [int] of var int: x :: promise_ctx_antitone,
+  array [int] of var int: y :: promise_ctx_monotone,
+) = ortools_lex_lesseq_int(x, y);
\ No newline at end of file
diff --git a/ortools/flatzinc/mznlib/fzn_partition_set.mzn b/ortools/flatzinc/mznlib/fzn_partition_set.mzn
new file mode 100644
index 0000000000..1eece46c5e
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_partition_set.mzn
@@ -0,0 +1 @@
+predicate fzn_partition_set(array [int] of var set of int: S, set of int: universe);
diff --git a/ortools/flatzinc/mznlib/fzn_seq_precede_chain_int.mzn b/ortools/flatzinc/mznlib/fzn_seq_precede_chain_int.mzn
new file mode 100644
index 0000000000..b2bdc378e8
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_seq_precede_chain_int.mzn
@@ -0,0 +1,5 @@
+predicate ortools_precede_chain_int(array [int] of int: T,
+                                    array [int] of var int: X);
+
+predicate fzn_seq_precede_chain_int(array [int] of var int: X) =
+  ortools_precede_chain_int(1..max(ub_array(X), 1), X);
diff --git a/ortools/flatzinc/mznlib/fzn_value_precede_chain_int.mzn b/ortools/flatzinc/mznlib/fzn_value_precede_chain_int.mzn
new file mode 100644
index 0000000000..b70d637f98
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_value_precede_chain_int.mzn
@@ -0,0 +1,12 @@
+predicate ortools_precede_chain_int(array [int] of int: T,
+                                    array [int] of var int: X);
+
+predicate fzn_value_precede_chain_int(array [int] of int: T,
+                                      array [int] of var int: X) =
+  if length(T) <= 1 then
+    true
+  elseif length(T) == 2 then
+    fzn_value_precede_int(T[min(index_set(T))], T[max(index_set(T))], X)
+  else
+    ortools_precede_chain_int(T, X)
+  endif;
diff --git a/ortools/flatzinc/mznlib/fzn_value_precede_int.mzn b/ortools/flatzinc/mznlib/fzn_value_precede_int.mzn
new file mode 100644
index 0000000000..357c33e33b
--- /dev/null
+++ b/ortools/flatzinc/mznlib/fzn_value_precede_int.mzn
@@ -0,0 +1 @@
+predicate fzn_value_precede_int(int: s, int: t, array [int] of var int: x);
diff --git a/ortools/flatzinc/mznlib/redefinitions-2.0.2.mzn b/ortools/flatzinc/mznlib/redefinitions-2.0.2.mzn
index 88aa80cae5..8ccaea447c 100644
--- a/ortools/flatzinc/mznlib/redefinitions-2.0.2.mzn
+++ b/ortools/flatzinc/mznlib/redefinitions-2.0.2.mzn
@@ -1,7 +1,9 @@
-% Ignore.
-predicate symmetry_breaking_constraint(var bool: b) = b;
+% Tag constraints correctly.
+ann: symmetry_breaking;
+ann: redundant;
 
-predicate redundant_constraint(var bool: b) = b;
+predicate symmetry_breaking_constraint(var bool: b) = (b) :: symmetry_breaking;
+predicate redundant_constraint(var bool: b) = (b) :: redundant;
 
 % array_var_bool_element_nonshifted.
 predicate ortools_array_var_bool_element(var int: idx,
diff --git a/ortools/flatzinc/parser.tab.cc b/ortools/flatzinc/parser.tab.cc
index b4a4c2d513..137185a3c1 100644
--- a/ortools/flatzinc/parser.tab.cc
+++ b/ortools/flatzinc/parser.tab.cc
@@ -64,110 +64,112 @@
 #define YYPULL 1
 
 /* Substitute the type names.  */
-#define YYSTYPE ORFZ_STYPE
+#define YYSTYPE         ORFZ_STYPE
 /* Substitute the variable and function names.  */
-#define yyparse orfz_parse
-#define yylex orfz_lex
-#define yyerror orfz_error
-#define yydebug orfz_debug
-#define yynerrs orfz_nerrs
+#define yyparse         orfz_parse
+#define yylex           orfz_lex
+#define yyerror         orfz_error
+#define yydebug         orfz_debug
+#define yynerrs         orfz_nerrs
 
-#ifndef YY_CAST
-#ifdef __cplusplus
-#define YY_CAST(Type, Val) static_cast<Type>(Val)
-#define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type>(Val)
-#else
-#define YY_CAST(Type, Val) ((Type)(Val))
-#define YY_REINTERPRET_CAST(Type, Val) ((Type)(Val))
-#endif
-#endif
-#ifndef YY_NULLPTR
-#if defined __cplusplus
-#if 201103L <= __cplusplus
-#define YY_NULLPTR nullptr
-#else
-#define YY_NULLPTR 0
-#endif
-#else
-#define YY_NULLPTR ((void*)0)
-#endif
-#endif
+
+# ifndef YY_CAST
+#  ifdef __cplusplus
+#   define YY_CAST(Type, Val) static_cast<Type> (Val)
+#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
+#  else
+#   define YY_CAST(Type, Val) ((Type) (Val))
+#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
+#  endif
+# endif
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
+#  else
+#   define YY_NULLPTR ((void*)0)
+#  endif
+# endif
 
 #include "parser.tab.hh"
 /* Symbol kind.  */
-enum yysymbol_kind_t {
+enum yysymbol_kind_t
+{
   YYSYMBOL_YYEMPTY = -2,
-  YYSYMBOL_YYEOF = 0,                     /* "end of file"  */
-  YYSYMBOL_YYerror = 1,                   /* error  */
-  YYSYMBOL_YYUNDEF = 2,                   /* "invalid token"  */
-  YYSYMBOL_ARRAY = 3,                     /* ARRAY  */
-  YYSYMBOL_TOKEN_BOOL = 4,                /* TOKEN_BOOL  */
-  YYSYMBOL_CONSTRAINT = 5,                /* CONSTRAINT  */
-  YYSYMBOL_TOKEN_FLOAT = 6,               /* TOKEN_FLOAT  */
-  YYSYMBOL_TOKEN_INT = 7,                 /* TOKEN_INT  */
-  YYSYMBOL_MAXIMIZE = 8,                  /* MAXIMIZE  */
-  YYSYMBOL_MINIMIZE = 9,                  /* MINIMIZE  */
-  YYSYMBOL_OF = 10,                       /* OF  */
-  YYSYMBOL_PREDICATE = 11,                /* PREDICATE  */
-  YYSYMBOL_SATISFY = 12,                  /* SATISFY  */
-  YYSYMBOL_SET = 13,                      /* SET  */
-  YYSYMBOL_SOLVE = 14,                    /* SOLVE  */
-  YYSYMBOL_VAR = 15,                      /* VAR  */
-  YYSYMBOL_DOTDOT = 16,                   /* DOTDOT  */
-  YYSYMBOL_COLONCOLON = 17,               /* COLONCOLON  */
-  YYSYMBOL_IVALUE = 18,                   /* IVALUE  */
-  YYSYMBOL_SVALUE = 19,                   /* SVALUE  */
-  YYSYMBOL_IDENTIFIER = 20,               /* IDENTIFIER  */
-  YYSYMBOL_DVALUE = 21,                   /* DVALUE  */
-  YYSYMBOL_22_ = 22,                      /* ';'  */
-  YYSYMBOL_23_ = 23,                      /* '('  */
-  YYSYMBOL_24_ = 24,                      /* ')'  */
-  YYSYMBOL_25_ = 25,                      /* ','  */
-  YYSYMBOL_26_ = 26,                      /* ':'  */
-  YYSYMBOL_27_ = 27,                      /* '['  */
-  YYSYMBOL_28_ = 28,                      /* ']'  */
-  YYSYMBOL_29_ = 29,                      /* '='  */
-  YYSYMBOL_30_ = 30,                      /* '{'  */
-  YYSYMBOL_31_ = 31,                      /* '}'  */
-  YYSYMBOL_YYACCEPT = 32,                 /* $accept  */
-  YYSYMBOL_model = 33,                    /* model  */
-  YYSYMBOL_predicates = 34,               /* predicates  */
-  YYSYMBOL_predicate = 35,                /* predicate  */
-  YYSYMBOL_predicate_arguments = 36,      /* predicate_arguments  */
-  YYSYMBOL_predicate_argument = 37,       /* predicate_argument  */
-  YYSYMBOL_predicate_array_argument = 38, /* predicate_array_argument  */
-  YYSYMBOL_predicate_ints = 39,           /* predicate_ints  */
-  YYSYMBOL_variable_or_constant_declarations =
-      40, /* variable_or_constant_declarations  */
-  YYSYMBOL_variable_or_constant_declaration =
-      41,                              /* variable_or_constant_declaration  */
-  YYSYMBOL_optional_var_or_value = 42, /* optional_var_or_value  */
+  YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
+  YYSYMBOL_YYerror = 1,                    /* error  */
+  YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
+  YYSYMBOL_ARRAY = 3,                      /* ARRAY  */
+  YYSYMBOL_TOKEN_BOOL = 4,                 /* TOKEN_BOOL  */
+  YYSYMBOL_CONSTRAINT = 5,                 /* CONSTRAINT  */
+  YYSYMBOL_TOKEN_FLOAT = 6,                /* TOKEN_FLOAT  */
+  YYSYMBOL_TOKEN_INT = 7,                  /* TOKEN_INT  */
+  YYSYMBOL_MAXIMIZE = 8,                   /* MAXIMIZE  */
+  YYSYMBOL_MINIMIZE = 9,                   /* MINIMIZE  */
+  YYSYMBOL_OF = 10,                        /* OF  */
+  YYSYMBOL_PREDICATE = 11,                 /* PREDICATE  */
+  YYSYMBOL_SATISFY = 12,                   /* SATISFY  */
+  YYSYMBOL_SET = 13,                       /* SET  */
+  YYSYMBOL_SOLVE = 14,                     /* SOLVE  */
+  YYSYMBOL_VAR = 15,                       /* VAR  */
+  YYSYMBOL_DOTDOT = 16,                    /* DOTDOT  */
+  YYSYMBOL_COLONCOLON = 17,                /* COLONCOLON  */
+  YYSYMBOL_IVALUE = 18,                    /* IVALUE  */
+  YYSYMBOL_SVALUE = 19,                    /* SVALUE  */
+  YYSYMBOL_IDENTIFIER = 20,                /* IDENTIFIER  */
+  YYSYMBOL_DVALUE = 21,                    /* DVALUE  */
+  YYSYMBOL_22_ = 22,                       /* ';'  */
+  YYSYMBOL_23_ = 23,                       /* '('  */
+  YYSYMBOL_24_ = 24,                       /* ')'  */
+  YYSYMBOL_25_ = 25,                       /* ','  */
+  YYSYMBOL_26_ = 26,                       /* ':'  */
+  YYSYMBOL_27_ = 27,                       /* '['  */
+  YYSYMBOL_28_ = 28,                       /* ']'  */
+  YYSYMBOL_29_ = 29,                       /* '='  */
+  YYSYMBOL_30_ = 30,                       /* '{'  */
+  YYSYMBOL_31_ = 31,                       /* '}'  */
+  YYSYMBOL_YYACCEPT = 32,                  /* $accept  */
+  YYSYMBOL_model = 33,                     /* model  */
+  YYSYMBOL_predicates = 34,                /* predicates  */
+  YYSYMBOL_predicate = 35,                 /* predicate  */
+  YYSYMBOL_predicate_arguments = 36,       /* predicate_arguments  */
+  YYSYMBOL_predicate_argument = 37,        /* predicate_argument  */
+  YYSYMBOL_predicate_array_argument = 38,  /* predicate_array_argument  */
+  YYSYMBOL_predicate_ints = 39,            /* predicate_ints  */
+  YYSYMBOL_variable_or_constant_declarations = 40, /* variable_or_constant_declarations  */
+  YYSYMBOL_variable_or_constant_declaration = 41, /* variable_or_constant_declaration  */
+  YYSYMBOL_optional_var_or_value = 42,     /* optional_var_or_value  */
   YYSYMBOL_optional_var_or_value_array = 43, /* optional_var_or_value_array  */
-  YYSYMBOL_var_or_value_array = 44,          /* var_or_value_array  */
-  YYSYMBOL_var_or_value = 45,                /* var_or_value  */
-  YYSYMBOL_int_domain = 46,                  /* int_domain  */
-  YYSYMBOL_set_domain = 47,                  /* set_domain  */
-  YYSYMBOL_float_domain = 48,                /* float_domain  */
-  YYSYMBOL_domain = 49,                      /* domain  */
-  YYSYMBOL_integers = 50,                    /* integers  */
-  YYSYMBOL_integer = 51,                     /* integer  */
-  YYSYMBOL_floats = 52,                      /* floats  */
-  YYSYMBOL_float = 53,                       /* float  */
-  YYSYMBOL_const_literal = 54,               /* const_literal  */
-  YYSYMBOL_const_literals = 55,              /* const_literals  */
-  YYSYMBOL_constraints = 56,                 /* constraints  */
-  YYSYMBOL_constraint = 57,                  /* constraint  */
-  YYSYMBOL_arguments = 58,                   /* arguments  */
-  YYSYMBOL_argument = 59,                    /* argument  */
-  YYSYMBOL_annotations = 60,                 /* annotations  */
-  YYSYMBOL_annotation_arguments = 61,        /* annotation_arguments  */
-  YYSYMBOL_annotation = 62,                  /* annotation  */
-  YYSYMBOL_solve = 63                        /* solve  */
+  YYSYMBOL_var_or_value_array = 44,        /* var_or_value_array  */
+  YYSYMBOL_var_or_value = 45,              /* var_or_value  */
+  YYSYMBOL_int_domain = 46,                /* int_domain  */
+  YYSYMBOL_set_domain = 47,                /* set_domain  */
+  YYSYMBOL_float_domain = 48,              /* float_domain  */
+  YYSYMBOL_domain = 49,                    /* domain  */
+  YYSYMBOL_integers = 50,                  /* integers  */
+  YYSYMBOL_integer = 51,                   /* integer  */
+  YYSYMBOL_floats = 52,                    /* floats  */
+  YYSYMBOL_float = 53,                     /* float  */
+  YYSYMBOL_const_literal = 54,             /* const_literal  */
+  YYSYMBOL_const_literals = 55,            /* const_literals  */
+  YYSYMBOL_constraints = 56,               /* constraints  */
+  YYSYMBOL_constraint = 57,                /* constraint  */
+  YYSYMBOL_arguments = 58,                 /* arguments  */
+  YYSYMBOL_argument = 59,                  /* argument  */
+  YYSYMBOL_annotations = 60,               /* annotations  */
+  YYSYMBOL_annotation_arguments = 61,      /* annotation_arguments  */
+  YYSYMBOL_annotation = 62,                /* annotation  */
+  YYSYMBOL_solve = 63                      /* solve  */
 };
 typedef enum yysymbol_kind_t yysymbol_kind_t;
 
+
+
 /* Unqualified %code blocks.  */
-#line 36 "ortools/flatzinc/parser.yy"
+#line 49 "ortools/flatzinc/parser.yy"
 
 #include <cstdint>
 
@@ -181,17 +183,17 @@ using operations_research::fz::Argument;
 using operations_research::fz::Constraint;
 using operations_research::fz::ConvertAsIntegerOrDie;
 using operations_research::fz::Domain;
+using operations_research::fz::Variable;
 using operations_research::fz::Lookup;
 using operations_research::fz::Model;
-using operations_research::fz::ParserContext;
 using operations_research::fz::SolutionOutputSpecs;
-using operations_research::fz::Variable;
+using operations_research::fz::ParserContext;
 using operations_research::fz::VarRefOrValue;
 
 #line 194 "parser.tab.cc"
 
 #ifdef short
-#undef short
+# undef short
 #endif
 
 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
@@ -199,11 +201,11 @@ using operations_research::fz::VarRefOrValue;
    so that the code can choose integer types of a good width.  */
 
 #ifndef __PTRDIFF_MAX__
-#include <limits.h> /* INFRINGES ON USER NAME SPACE */
-#if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-#include <stdint.h> /* INFRINGES ON USER NAME SPACE */
-#define YY_STDINT_H
-#endif
+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
+#  define YY_STDINT_H
+# endif
 #endif
 
 /* Narrow types that promote to a signed type and that can represent a
@@ -233,16 +235,16 @@ typedef short yytype_int16;
    (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
    <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
 #ifdef __hpux
-#undef UINT_LEAST8_MAX
-#undef UINT_LEAST16_MAX
-#define UINT_LEAST8_MAX 255
-#define UINT_LEAST16_MAX 65535
+# undef UINT_LEAST8_MAX
+# undef UINT_LEAST16_MAX
+# define UINT_LEAST8_MAX 255
+# define UINT_LEAST16_MAX 65535
 #endif
 
 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
-#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H && \
-       UINT_LEAST8_MAX <= INT_MAX)
+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST8_MAX <= INT_MAX)
 typedef uint_least8_t yytype_uint8;
 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
 typedef unsigned char yytype_uint8;
@@ -252,8 +254,8 @@ typedef short yytype_uint8;
 
 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
-#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H && \
-       UINT_LEAST16_MAX <= INT_MAX)
+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST16_MAX <= INT_MAX)
 typedef uint_least16_t yytype_uint16;
 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
 typedef unsigned short yytype_uint16;
@@ -262,40 +264,42 @@ typedef int yytype_uint16;
 #endif
 
 #ifndef YYPTRDIFF_T
-#if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
-#define YYPTRDIFF_T __PTRDIFF_TYPE__
-#define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
-#elif defined PTRDIFF_MAX
-#ifndef ptrdiff_t
-#include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#endif
-#define YYPTRDIFF_T ptrdiff_t
-#define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
-#else
-#define YYPTRDIFF_T long
-#define YYPTRDIFF_MAXIMUM LONG_MAX
-#endif
+# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
+#  define YYPTRDIFF_T __PTRDIFF_TYPE__
+#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
+# elif defined PTRDIFF_MAX
+#  ifndef ptrdiff_t
+#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  endif
+#  define YYPTRDIFF_T ptrdiff_t
+#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
+# else
+#  define YYPTRDIFF_T long
+#  define YYPTRDIFF_MAXIMUM LONG_MAX
+# endif
 #endif
 
 #ifndef YYSIZE_T
-#ifdef __SIZE_TYPE__
-#define YYSIZE_T __SIZE_TYPE__
-#elif defined size_t
-#define YYSIZE_T size_t
-#elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-#include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#define YYSIZE_T size_t
-#else
-#define YYSIZE_T unsigned
-#endif
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned
+# endif
 #endif
 
-#define YYSIZE_MAXIMUM                                                   \
-  YY_CAST(YYPTRDIFF_T,                                                   \
-          (YYPTRDIFF_MAXIMUM < YY_CAST(YYSIZE_T, -1) ? YYPTRDIFF_MAXIMUM \
-                                                     : YY_CAST(YYSIZE_T, -1)))
+#define YYSIZE_MAXIMUM                                  \
+  YY_CAST (YYPTRDIFF_T,                                 \
+           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
+            ? YYPTRDIFF_MAXIMUM                         \
+            : YY_CAST (YYSIZE_T, -1)))
+
+#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
 
-#define YYSIZEOF(X) YY_CAST(YYPTRDIFF_T, sizeof(X))
 
 /* Stored state numbers (used for stacks). */
 typedef yytype_uint8 yy_state_t;
@@ -304,331 +308,316 @@ typedef yytype_uint8 yy_state_t;
 typedef int yy_state_fast_t;
 
 #ifndef YY_
-#if defined YYENABLE_NLS && YYENABLE_NLS
-#if ENABLE_NLS
-#include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#define YY_(Msgid) dgettext("bison-runtime", Msgid)
-#endif
-#endif
-#ifndef YY_
-#define YY_(Msgid) Msgid
-#endif
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
 #endif
 
+
 #ifndef YY_ATTRIBUTE_PURE
-#if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
-#define YY_ATTRIBUTE_PURE __attribute__((__pure__))
-#else
-#define YY_ATTRIBUTE_PURE
-#endif
+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
+# else
+#  define YY_ATTRIBUTE_PURE
+# endif
 #endif
 
 #ifndef YY_ATTRIBUTE_UNUSED
-#if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
-#define YY_ATTRIBUTE_UNUSED __attribute__((__unused__))
-#else
-#define YY_ATTRIBUTE_UNUSED
-#endif
+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+# else
+#  define YY_ATTRIBUTE_UNUSED
+# endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
-#if !defined lint || defined __GNUC__
-#define YY_USE(E) ((void)(E))
+#if ! defined lint || defined __GNUC__
+# define YY_USE(E) ((void) (E))
 #else
-#define YY_USE(E) /* empty */
+# define YY_USE(E) /* empty */
 #endif
 
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
-#if defined __GNUC__ && !defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
-#if __GNUC__ * 100 + __GNUC_MINOR__ < 407
-#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
-  _Pragma("GCC diagnostic push")            \
-      _Pragma("GCC diagnostic ignored \"-Wuninitialized\"")
+#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
+# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
+# else
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# endif
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
+    _Pragma ("GCC diagnostic pop")
 #else
-#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                 \
-  _Pragma("GCC diagnostic push")                            \
-      _Pragma("GCC diagnostic ignored \"-Wuninitialized\"") \
-          _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-#endif
-#define YY_IGNORE_MAYBE_UNINITIALIZED_END _Pragma("GCC diagnostic pop")
-#else
-#define YY_INITIAL_VALUE(Value) Value
+# define YY_INITIAL_VALUE(Value) Value
 #endif
 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-#define YY_IGNORE_MAYBE_UNINITIALIZED_END
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
 #endif
 #ifndef YY_INITIAL_VALUE
-#define YY_INITIAL_VALUE(Value) /* Nothing. */
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
 #endif
 
-#if defined __cplusplus && defined __GNUC__ && !defined __ICC && 6 <= __GNUC__
-#define YY_IGNORE_USELESS_CAST_BEGIN \
-  _Pragma("GCC diagnostic push")     \
-      _Pragma("GCC diagnostic ignored \"-Wuseless-cast\"")
-#define YY_IGNORE_USELESS_CAST_END _Pragma("GCC diagnostic pop")
+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
+# define YY_IGNORE_USELESS_CAST_BEGIN                          \
+    _Pragma ("GCC diagnostic push")                            \
+    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
+# define YY_IGNORE_USELESS_CAST_END            \
+    _Pragma ("GCC diagnostic pop")
 #endif
 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
-#define YY_IGNORE_USELESS_CAST_BEGIN
-#define YY_IGNORE_USELESS_CAST_END
+# define YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_END
 #endif
 
-#define YY_ASSERT(E) ((void)(0 && (E)))
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
 
 #if 1
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
-#ifdef YYSTACK_USE_ALLOCA
-#if YYSTACK_USE_ALLOCA
-#ifdef __GNUC__
-#define YYSTACK_ALLOC __builtin_alloca
-#elif defined __BUILTIN_VA_ARG_INCR
-#include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-#elif defined _AIX
-#define YYSTACK_ALLOC __alloca
-#elif defined _MSC_VER
-#include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-#define alloca _alloca
-#else
-#define YYSTACK_ALLOC alloca
-#if !defined _ALLOCA_H && !defined EXIT_SUCCESS
-#include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-/* Use EXIT_SUCCESS as a witness for stdlib.h.  */
-#ifndef EXIT_SUCCESS
-#define EXIT_SUCCESS 0
-#endif
-#endif
-#endif
-#endif
-#endif
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
 
-#ifdef YYSTACK_ALLOC
-/* Pacify GCC's 'empty if-body' warning.  */
-#define YYSTACK_FREE(Ptr) \
-  do { /* empty */        \
-    ;                     \
-  } while (0)
-#ifndef YYSTACK_ALLOC_MAXIMUM
-/* The OS might guarantee only one guard page at the bottom of the stack,
-   and a page size can be as small as 4096 bytes.  So we cannot safely
-   invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
-   to allow for a few compiler-allocated temporary stack slots.  */
-#define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-#endif
-#else
-#define YYSTACK_ALLOC YYMALLOC
-#define YYSTACK_FREE YYFREE
-#ifndef YYSTACK_ALLOC_MAXIMUM
-#define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-#endif
-#if (defined __cplusplus && !defined EXIT_SUCCESS && \
-     !((defined YYMALLOC || defined malloc) &&       \
-       (defined YYFREE || defined free)))
-#include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#ifndef EXIT_SUCCESS
-#define EXIT_SUCCESS 0
-#endif
-#endif
-#ifndef YYMALLOC
-#define YYMALLOC malloc
-#if !defined malloc && !defined EXIT_SUCCESS
-void* malloc(YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-#endif
-#endif
-#ifndef YYFREE
-#define YYFREE free
-#if !defined free && !defined EXIT_SUCCESS
-void free(void*); /* INFRINGES ON USER NAME SPACE */
-#endif
-#endif
-#endif
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
 #endif /* 1 */
 
-#if (!defined yyoverflow &&   \
-     (!defined __cplusplus || \
-      (defined ORFZ_STYPE_IS_TRIVIAL && ORFZ_STYPE_IS_TRIVIAL)))
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined ORFZ_STYPE_IS_TRIVIAL && ORFZ_STYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
-union yyalloc {
+union yyalloc
+{
   yy_state_t yyss_alloc;
   YYSTYPE yyvs_alloc;
 };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
-#define YYSTACK_GAP_MAXIMUM (YYSIZEOF(union yyalloc) - 1)
+# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
-#define YYSTACK_BYTES(N) \
-  ((N) * (YYSIZEOF(yy_state_t) + YYSIZEOF(YYSTYPE)) + YYSTACK_GAP_MAXIMUM)
+# define YYSTACK_BYTES(N) \
+     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
 
-#define YYCOPY_NEEDED 1
+# define YYCOPY_NEEDED 1
 
 /* Relocate STACK from its old location to the new one.  The
    local variables YYSIZE and YYSTACKSIZE give the old and new number of
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
-#define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
-  do {                                                                 \
-    YYPTRDIFF_T yynewbytes;                                            \
-    YYCOPY(&yyptr->Stack_alloc, Stack, yysize);                        \
-    Stack = &yyptr->Stack_alloc;                                       \
-    yynewbytes = yystacksize * YYSIZEOF(*Stack) + YYSTACK_GAP_MAXIMUM; \
-    yyptr += yynewbytes / YYSIZEOF(*yyptr);                            \
-  } while (0)
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYPTRDIFF_T yynewbytes;                                         \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
+      }                                                                 \
+    while (0)
 
 #endif
 
 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 /* Copy COUNT objects from SRC to DST.  The source and destination do
    not overlap.  */
-#ifndef YYCOPY
-#if defined __GNUC__ && 1 < __GNUC__
-#define YYCOPY(Dst, Src, Count) \
-  __builtin_memcpy(Dst, Src, YY_CAST(YYSIZE_T, (Count)) * sizeof(*(Src)))
-#else
-#define YYCOPY(Dst, Src, Count)                                  \
-  do {                                                           \
-    YYPTRDIFF_T yyi;                                             \
-    for (yyi = 0; yyi < (Count); yyi++) (Dst)[yyi] = (Src)[yyi]; \
-  } while (0)
-#endif
-#endif
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYPTRDIFF_T yyi;                      \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL 3
+#define YYFINAL  3
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST 307
+#define YYLAST   307
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS 32
+#define YYNTOKENS  32
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS 32
+#define YYNNTS  32
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES 100
+#define YYNRULES  100
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES 230
+#define YYNSTATES  230
 
 /* YYMAXUTOK -- Last valid token kind.  */
-#define YYMAXUTOK 276
+#define YYMAXUTOK   276
+
 
 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
    as returned by yylex, with out-of-bounds checking.  */
-#define YYTRANSLATE(YYX)                            \
-  (0 <= (YYX) && (YYX) <= YYMAXUTOK                 \
-       ? YY_CAST(yysymbol_kind_t, yytranslate[YYX]) \
-       : YYSYMBOL_YYUNDEF)
+#define YYTRANSLATE(YYX)                                \
+  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
+   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
+   : YYSYMBOL_YYUNDEF)
 
 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
    as returned by yylex.  */
-static const yytype_int8 yytranslate[] = {
-    0,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    23, 24, 2, 2,  25, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 26, 22,
-    2,  29, 2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  27, 2,  28, 2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 30, 2,  31, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 2, 2,  2,
-    2,  2,  2, 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  1, 2, 3,  4,
-    5,  6,  7, 8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
+static const yytype_int8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+      23,    24,     2,     2,    25,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,    26,    22,
+       2,    29,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,    27,     2,    28,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,    30,     2,    31,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21
+};
 
 #if ORFZ_DEBUG
 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
-static const yytype_int16 yyrline[] = {
-    0,   105, 105, 112, 116, 117, 122, 125, 126, 129, 130, 131, 132, 135, 136,
-    139, 140, 147, 148, 151, 170, 185, 196, 211, 222, 248, 298, 383, 384, 387,
-    388, 389, 392, 396, 402, 403, 404, 407, 412, 427, 448, 449, 450, 451, 458,
-    459, 460, 461, 468, 469, 474, 475, 476, 479, 480, 483, 484, 485, 490, 491,
-    494, 495, 496, 501, 502, 503, 508, 509, 512, 513, 519, 523, 529, 530, 533,
-    545, 546, 549, 550, 551, 552, 553, 558, 584, 601, 649, 658, 662, 665, 666,
-    669, 670, 671, 672, 686, 695, 701, 730, 739, 747, 758};
+static const yytype_int16 yyrline[] =
+{
+       0,   118,   118,   125,   129,   130,   135,   138,   139,   142,
+     143,   144,   145,   148,   149,   152,   153,   160,   161,   164,
+     183,   198,   209,   224,   235,   250,   300,   385,   386,   389,
+     390,   391,   394,   398,   404,   405,   406,   409,   414,   429,
+     450,   451,   452,   453,   460,   461,   462,   463,   470,   471,
+     476,   477,   478,   481,   482,   485,   486,   487,   492,   493,
+     496,   497,   498,   503,   504,   505,   510,   511,   514,   515,
+     521,   525,   531,   532,   535,   549,   550,   553,   554,   555,
+     556,   557,   562,   588,   605,   653,   662,   666,   669,   670,
+     673,   674,   675,   676,   690,   699,   705,   734,   743,   751,
+     762
+};
 #endif
 
 /** Accessing symbol of state STATE.  */
-#define YY_ACCESSING_SYMBOL(State) YY_CAST(yysymbol_kind_t, yystos[State])
+#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
 
 #if 1
 /* The user-facing name of the symbol whose (internal) number is
    YYSYMBOL.  No bounds checking.  */
-static const char* yysymbol_name(yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
+static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
 
 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
-static const char* const yytname[] = {"\"end of file\"",
-                                      "error",
-                                      "\"invalid token\"",
-                                      "ARRAY",
-                                      "TOKEN_BOOL",
-                                      "CONSTRAINT",
-                                      "TOKEN_FLOAT",
-                                      "TOKEN_INT",
-                                      "MAXIMIZE",
-                                      "MINIMIZE",
-                                      "OF",
-                                      "PREDICATE",
-                                      "SATISFY",
-                                      "SET",
-                                      "SOLVE",
-                                      "VAR",
-                                      "DOTDOT",
-                                      "COLONCOLON",
-                                      "IVALUE",
-                                      "SVALUE",
-                                      "IDENTIFIER",
-                                      "DVALUE",
-                                      "';'",
-                                      "'('",
-                                      "')'",
-                                      "','",
-                                      "':'",
-                                      "'['",
-                                      "']'",
-                                      "'='",
-                                      "'{'",
-                                      "'}'",
-                                      "$accept",
-                                      "model",
-                                      "predicates",
-                                      "predicate",
-                                      "predicate_arguments",
-                                      "predicate_argument",
-                                      "predicate_array_argument",
-                                      "predicate_ints",
-                                      "variable_or_constant_declarations",
-                                      "variable_or_constant_declaration",
-                                      "optional_var_or_value",
-                                      "optional_var_or_value_array",
-                                      "var_or_value_array",
-                                      "var_or_value",
-                                      "int_domain",
-                                      "set_domain",
-                                      "float_domain",
-                                      "domain",
-                                      "integers",
-                                      "integer",
-                                      "floats",
-                                      "float",
-                                      "const_literal",
-                                      "const_literals",
-                                      "constraints",
-                                      "constraint",
-                                      "arguments",
-                                      "argument",
-                                      "annotations",
-                                      "annotation_arguments",
-                                      "annotation",
-                                      "solve",
-                                      YY_NULLPTR};
+static const char *const yytname[] =
+{
+  "\"end of file\"", "error", "\"invalid token\"", "ARRAY", "TOKEN_BOOL",
+  "CONSTRAINT", "TOKEN_FLOAT", "TOKEN_INT", "MAXIMIZE", "MINIMIZE", "OF",
+  "PREDICATE", "SATISFY", "SET", "SOLVE", "VAR", "DOTDOT", "COLONCOLON",
+  "IVALUE", "SVALUE", "IDENTIFIER", "DVALUE", "';'", "'('", "')'", "','",
+  "':'", "'['", "']'", "'='", "'{'", "'}'", "$accept", "model",
+  "predicates", "predicate", "predicate_arguments", "predicate_argument",
+  "predicate_array_argument", "predicate_ints",
+  "variable_or_constant_declarations", "variable_or_constant_declaration",
+  "optional_var_or_value", "optional_var_or_value_array",
+  "var_or_value_array", "var_or_value", "int_domain", "set_domain",
+  "float_domain", "domain", "integers", "integer", "floats", "float",
+  "const_literal", "const_literals", "constraints", "constraint",
+  "arguments", "argument", "annotations", "annotation_arguments",
+  "annotation", "solve", YY_NULLPTR
+};
 
-static const char* yysymbol_name(yysymbol_kind_t yysymbol) {
+static const char *
+yysymbol_name (yysymbol_kind_t yysymbol)
+{
   return yytname[yysymbol];
 }
 #endif
@@ -2148,7 +2137,9 @@ yyreduce:
       std::vector<Annotation>* const annotations = (yyvsp[0].annotations);
 
       model->AddConstraint(identifier, arguments,
-                           ContainsId(annotations, "domain"));
+                           ContainsId(annotations, "domain"),
+                           ContainsId(annotations, "symmetry_breaking"),
+                           ContainsId(annotations, "redundant"));
       delete annotations;
       delete (yyvsp[-2].args);
     }
diff --git a/ortools/flatzinc/parser.yy b/ortools/flatzinc/parser.yy
index 6ee12935b3..61352098ac 100644
--- a/ortools/flatzinc/parser.yy
+++ b/ortools/flatzinc/parser.yy
@@ -234,27 +234,16 @@ variable_or_constant_declaration:
 }
 | ARRAY '[' IVALUE DOTDOT IVALUE ']' OF set_domain ':' IDENTIFIER
     annotations '=' '[' const_literals ']' {
-  // Declaration of a (named) constant array: See rule above.
+  // Declaration of a (named) set constant array: See rule above.
   CHECK_EQ($3, 1) << "Only [1..n] array are supported here.";
-  const int64_t num_constants = $5;
-  const Domain& domain = $8;
+  const int64_t num_domains = $5;
+  // const Domain& domain = $8;
   const std::string& identifier = $10;
   const std::vector<Domain>* const assignments = $14;
   const std::vector<Annotation>* const annotations = $11;
   CHECK(assignments != nullptr);
-  CHECK_EQ(num_constants, assignments->size());
-
-  if (!AllDomainsHaveOneValue(*assignments)) {
-    context->domain_array_map[identifier] = *assignments;
-    // TODO(user): check that all assignments are included in the domain.
-  } else {
-    std::vector<int64_t> values(num_constants);
-    for (int i = 0; i < num_constants; ++i) {
-      values[i] = (*assignments)[i].values.front();
-      CHECK(domain.Contains(values[i]));
-    }
-    context->integer_array_map[identifier] = values;
-  }
+  CHECK_EQ(num_domains, assignments->size());
+  context->domain_array_map[identifier] = *assignments;
   delete assignments;
   delete annotations;
 }
@@ -549,7 +538,9 @@ constraint :
   const std::vector<Argument>& arguments = *$4;
   std::vector<Annotation>* const annotations = $6;
 
-  model->AddConstraint(identifier, arguments, ContainsId(annotations, "domain"));
+  model->AddConstraint(identifier, arguments, ContainsId(annotations, "domain"),
+                       ContainsId(annotations, "symmetry_breaking"),
+                       ContainsId(annotations, "redundant"));
   delete annotations;
   delete $4;
 }
diff --git a/ortools/flatzinc/parser_main.cc b/ortools/flatzinc/parser_main.cc
index eb479748b6..47dd1a6848 100644
--- a/ortools/flatzinc/parser_main.cc
+++ b/ortools/flatzinc/parser_main.cc
@@ -18,12 +18,10 @@
 #include <cstddef>
 #include <string>
 
+#include "absl/base/log_severity.h"
 #include "absl/flags/flag.h"
-#include "absl/flags/parse.h"
-#include "absl/flags/usage.h"
 #include "absl/log/check.h"
-#include "absl/log/flags.h"
-#include "absl/log/initialize.h"
+#include "absl/log/globals.h"
 #include "absl/strings/match.h"
 #include "ortools/base/init_google.h"
 #include "ortools/base/timer.h"
@@ -77,9 +75,8 @@ int main(int argc, char** argv) {
   const char kUsage[] =
       "Parses a flatzinc .fzn file, optionally presolve it, and prints it in "
       "human-readable format";
-  absl::SetProgramUsageMessage(kUsage);
-  absl::ParseCommandLine(argc, argv);
-  absl::InitializeLog();
+  absl::SetStderrThreshold(absl::LogSeverityAtLeast::kInfo);
+  InitGoogle(kUsage, &argc, &argv, /*remove_flags=*/true);
   operations_research::fz::ParseFile(absl::GetFlag(FLAGS_input));
   return 0;
 }
diff --git a/ortools/glop/BUILD.bazel b/ortools/glop/BUILD.bazel
index 56a7c2862b..6ad186182d 100644
--- a/ortools/glop/BUILD.bazel
+++ b/ortools/glop/BUILD.bazel
@@ -20,34 +20,13 @@ package(
     default_visibility = ["//visibility:public"],
 )
 
-config_setting(
-    name = "on_linux",
-    constraint_values = [
-        "@platforms//os:linux",
-    ],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = [
-        "@platforms//os:macos",
-    ],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = [
-        "@platforms//os:windows",
-    ],
-)
-
 # Floating-point code in this directory must not be compiled with
 # dangerous optimizations. For example do not assume that FP expressions
 # are associative. This is what -fno-fast-math is for.
 SAFE_FP_CODE = select({
-    "on_linux": ["-fno-fast-math"],
-    "on_macos": [],  # no_fast_math is the default.
-    "on_windows": [],  # /fp:precise is the default.
+    "@platforms//os:linux": ["-fno-fast-math"],
+    "@platforms//os:macos": [],  # no_fast_math is the default.
+    "@platforms//os:windows": [],  # /fp:precise is the default.
     "//conditions:default": [],
 })
 
diff --git a/ortools/glpk/BUILD.bazel b/ortools/glpk/BUILD.bazel
index e23aef60c5..16dfa0574b 100644
--- a/ortools/glpk/BUILD.bazel
+++ b/ortools/glpk/BUILD.bazel
@@ -20,6 +20,11 @@ cc_library(
     name = "glpk_env_deleter",
     srcs = ["glpk_env_deleter.cc"],
     hdrs = ["glpk_env_deleter.h"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         "//ortools/base",
         "@glpk",
@@ -30,6 +35,11 @@ cc_library(
     name = "glpk_formatters",
     srcs = ["glpk_formatters.cc"],
     hdrs = ["glpk_formatters.h"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         "//ortools/base",
         "@abseil-cpp//absl/strings",
@@ -40,6 +50,11 @@ cc_library(
 cc_library(
     name = "glpk_computational_form",
     hdrs = ["glpk_computational_form.h"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         "@glpk",
     ],
diff --git a/ortools/graph/BUILD.bazel b/ortools/graph/BUILD.bazel
index b5602ce58d..5fb8114224 100644
--- a/ortools/graph/BUILD.bazel
+++ b/ortools/graph/BUILD.bazel
@@ -17,21 +17,6 @@ load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
 load("@rules_cc//cc:cc_library.bzl", "cc_library")
 load("@rules_cc//cc:cc_test.bzl", "cc_test")
 
-config_setting(
-    name = "on_linux",
-    constraint_values = ["@platforms//os:linux"],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = ["@platforms//os:macos"],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = ["@platforms//os:windows"],
-)
-
 cc_library(
     name = "graph",
     hdrs = ["graph.h"],
@@ -197,6 +182,7 @@ cc_test(
     name = "bidirectional_dijkstra_test",
     size = "small",
     srcs = ["bidirectional_dijkstra_test.cc"],
+    tags = ["manual"],
     deps = [
         ":bidirectional_dijkstra",
         ":bounded_dijkstra",
@@ -533,9 +519,7 @@ cc_library(
     srcs = ["min_cost_flow.cc"],
     hdrs = ["min_cost_flow.h"],
     copts = select({
-        "on_linux": [],
-        "on_macos": [],
-        "on_windows": ["/Zc:preprocessor"],
+        "@platforms//os:windows": ["/Zc:preprocessor"],
         "//conditions:default": [],
     }),
     visibility = ["//visibility:public"],
@@ -629,17 +613,6 @@ cc_test(
     ],
 )
 
-cc_test(
-    name = "line_graph_test",
-    srcs = ["line_graph_test.cc"],
-    deps = [
-        ":line_graph",
-        "//ortools/base:gmock_main",
-        "//ortools/graph",
-        "@abseil-cpp//absl/base:core_headers",
-    ],
-)
-
 # Linear Assignment with full-featured interface and efficient
 # implementation.
 cc_library(
@@ -770,12 +743,6 @@ cc_library(
     ],
 )
 
-cc_library(
-    name = "line_graph",
-    hdrs = ["line_graph.h"],
-    deps = ["@abseil-cpp//absl/log"],
-)
-
 cc_test(
     name = "rooted_tree_test",
     srcs = ["rooted_tree_test.cc"],
@@ -860,7 +827,6 @@ cc_library(
     deps = [
         "//ortools/base",
         "//ortools/base:map_util",
-        "//ortools/base:ptr_util",
         "//ortools/base:stl_util",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
diff --git a/ortools/graph/bidirectional_dijkstra.h b/ortools/graph/bidirectional_dijkstra.h
index 54c5153ac1..fe82dc5d06 100644
--- a/ortools/graph/bidirectional_dijkstra.h
+++ b/ortools/graph/bidirectional_dijkstra.h
@@ -373,7 +373,7 @@ void BidirectionalDijkstra<GraphType, DistanceType>::PerformHalfSearch(
         // Release the node mutex, now that we can, to prevent deadlocks when
         // we try acquiring the global search mutex.
         node_mutex_[top.node].Unlock();
-        absl::MutexLock search_lock(&search_mutex_);
+        absl::MutexLock search_lock(search_mutex_);
         if (meeting_distance < best_meeting_point_.distance) {
           best_meeting_point_ = {top.node, meeting_distance};
           DVLOG(2) << (dir ? "BACKWARD" : "FORWARD")
@@ -388,7 +388,7 @@ void BidirectionalDijkstra<GraphType, DistanceType>::PerformHalfSearch(
     // should stop the search, based on the other radius.
     DistanceType potentially_interesting_distance_upper_bound;
     {
-      absl::MutexLock lock(&search_mutex_);
+      absl::MutexLock lock(search_mutex_);
       current_search_radius_[dir] = top.distance;
       potentially_interesting_distance_upper_bound =
           best_meeting_point_.distance - current_search_radius_[Reverse(dir)];
@@ -427,7 +427,7 @@ void BidirectionalDijkstra<GraphType, DistanceType>::PerformHalfSearch(
         // protection of a Mutex.
         DistanceType meeting_distance = infinity();
         {
-          absl::MutexLock node_lock(&node_mutex_[head]);
+          absl::MutexLock node_lock(node_mutex_[head]);
           distances_[dir][head] = candidate_distance;
           // Did we reach a meeting point?
           if (is_settled_[Reverse(dir)][head]) {
@@ -441,7 +441,7 @@ void BidirectionalDijkstra<GraphType, DistanceType>::PerformHalfSearch(
         // Mutex -- this is fine performance-wise because it happens rarely.
         // To avoid deadlocks, we make sure that 'node_mutex' is no longer held.
         if (meeting_distance != infinity()) {
-          absl::MutexLock search_lock(&search_mutex_);
+          absl::MutexLock search_lock(search_mutex_);
           if (meeting_distance < best_meeting_point_.distance) {
             best_meeting_point_ = {head, meeting_distance};
             DVLOG(2) << (dir ? "BACKWARD" : "FORWARD")
diff --git a/ortools/graph/generic_max_flow_test.cc b/ortools/graph/generic_max_flow_test.cc
index 5fa975ac78..141dbce016 100644
--- a/ortools/graph/generic_max_flow_test.cc
+++ b/ortools/graph/generic_max_flow_test.cc
@@ -294,6 +294,7 @@ constexpr bool operator>=(StrongUint16 a, StrongUint16 b) { return a.v >= b.v; }
 constexpr bool operator>(StrongUint16 a, StrongUint16 b) { return a.v > b.v; }
 constexpr bool operator<(StrongUint16 a, StrongUint16 b) { return a.v < b.v; }
 constexpr bool operator==(StrongUint16 a, StrongUint16 b) { return a.v == b.v; }
+constexpr bool operator!=(StrongUint16 a, StrongUint16 b) { return a.v != b.v; }
 
 // This is a bit hacky, but we need to define the overload in the std namespace.
 }  // namespace
@@ -333,8 +334,10 @@ TYPED_TEST(GenericMaxFlowTest, SmallFlowTypes) {
     max_flow_A.SetArcCapacity(arc, capa);
     max_flow_B.SetArcCapacity(arc, capa);
   }
-  EXPECT_EQ(max_flow_A.Solve(), MaxFlowA::OPTIMAL);
-  EXPECT_EQ(max_flow_B.Solve(), MaxFlowB::OPTIMAL);
+  EXPECT_TRUE(max_flow_A.Solve());
+  EXPECT_EQ(max_flow_A.status(), MaxFlowA::OPTIMAL);
+  EXPECT_TRUE(max_flow_B.Solve());
+  EXPECT_EQ(max_flow_B.status(), MaxFlowB::OPTIMAL);
   EXPECT_EQ(max_flow_A.GetOptimalFlow(), max_flow_B.GetOptimalFlow());
 }
 
diff --git a/ortools/graph/java/BUILD.bazel b/ortools/graph/java/BUILD.bazel
index 4818a86092..cf26da752c 100644
--- a/ortools/graph/java/BUILD.bazel
+++ b/ortools/graph/java/BUILD.bazel
@@ -15,11 +15,11 @@
 
 load("@contrib_rules_jvm//java:defs.bzl", "java_junit5_test")
 load("@rules_jvm_external//:defs.bzl", "artifact")
-load("//bazel:swig_java.bzl", "ortools_java_wrap_cc")
+load("//bazel:swig_java.bzl", "java_wrap_cc")
 
-ortools_java_wrap_cc(
+java_wrap_cc(
     name = "graph",
-    src = "graph.swig",
+    srcs = ["graph.swig"],
     module = "graph",
     package = "com.google.ortools.graph",
     swig_includes = [
diff --git a/ortools/graph/line_graph.h b/ortools/graph/line_graph.h
deleted file mode 100644
index ee849cfdbf..0000000000
--- a/ortools/graph/line_graph.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2010-2025 Google LLC
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef OR_TOOLS_GRAPH_LINE_GRAPH_H_
-#define OR_TOOLS_GRAPH_LINE_GRAPH_H_
-
-#include "absl/log/log.h"
-
-namespace operations_research {
-
-// Builds a directed line graph for `graph` (see "directed line graph" in
-// http://en.wikipedia.org/wiki/Line_graph). Arcs of the original graph
-// become nodes and the new graph contains only nodes created from arcs in the
-// original graph (we use the notation (a->b) for these new nodes); the index
-// of the node (a->b) in the new graph is exactly the same as the index of the
-// arc a->b in the original graph.
-// An arc from node (a->b) to node (c->d) in the new graph is added if and only
-// if b == c in the original graph.
-// This method expects that `line_graph` is an empty graph (it has no nodes
-// and no arcs).
-// Returns false on an error.
-template <typename GraphType>
-bool BuildLineGraph(const GraphType& graph, GraphType* const line_graph) {
-  if (line_graph == nullptr) {
-    LOG(DFATAL) << "line_graph must not be NULL";
-    return false;
-  }
-  if (line_graph->num_nodes() != 0) {
-    LOG(DFATAL) << "line_graph must be empty";
-    return false;
-  }
-  // Sizing then filling.
-  using NodeIndex = typename GraphType::NodeIndex;
-  using ArcIndex = typename GraphType::ArcIndex;
-  ArcIndex num_arcs = 0;
-  for (const ArcIndex arc : graph.AllForwardArcs()) {
-    const NodeIndex head = graph.Head(arc);
-    num_arcs += graph.OutDegree(head);
-  }
-  line_graph->Reserve(graph.num_arcs(), num_arcs);
-  for (const ArcIndex arc : graph.AllForwardArcs()) {
-    const NodeIndex head = graph.Head(arc);
-    for (const ArcIndex outgoing_arc : graph.OutgoingArcs(head)) {
-      line_graph->AddArc(arc, outgoing_arc);
-    }
-  }
-  return true;
-}
-
-}  // namespace operations_research
-
-#endif  // OR_TOOLS_GRAPH_LINE_GRAPH_H_
diff --git a/ortools/graph/line_graph_test.cc b/ortools/graph/line_graph_test.cc
deleted file mode 100644
index 5ffeb913ef..0000000000
--- a/ortools/graph/line_graph_test.cc
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2010-2025 Google LLC
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "ortools/graph/line_graph.h"
-
-#include "absl/base/macros.h"
-#include "gtest/gtest.h"
-#include "ortools/graph/graph.h"
-
-namespace operations_research {
-namespace {
-
-// Empty fixture templates to collect the types of graphs on which we want to
-// base the shortest paths template instances that we test.
-template <typename GraphType>
-class LineGraphDeathTest : public testing::Test {};
-template <typename GraphType>
-class LineGraphTest : public testing::Test {};
-
-typedef testing::Types<::util::ListGraph<>, ::util::ReverseArcListGraph<>>
-    GraphTypesForLineGraphTesting;
-
-TYPED_TEST_SUITE(LineGraphDeathTest, GraphTypesForLineGraphTesting);
-TYPED_TEST_SUITE(LineGraphTest, GraphTypesForLineGraphTesting);
-
-TYPED_TEST(LineGraphDeathTest, NullLineGraph) {
-  TypeParam graph;
-#ifndef NDEBUG
-  EXPECT_DEATH(BuildLineGraph<TypeParam>(graph, nullptr),
-               "line_graph must not be NULL");
-#else
-  EXPECT_FALSE(BuildLineGraph<TypeParam>(graph, nullptr));
-#endif
-}
-
-TYPED_TEST(LineGraphDeathTest, NonEmptyLineGraph) {
-  TypeParam graph;
-  TypeParam line_graph(1, 1);
-  line_graph.AddArc(0, 0);
-#ifndef NDEBUG
-  EXPECT_DEATH(BuildLineGraph<TypeParam>(graph, &line_graph),
-               "line_graph must be empty");
-#else
-  EXPECT_FALSE(BuildLineGraph<TypeParam>(graph, &line_graph));
-#endif
-}
-
-TYPED_TEST(LineGraphDeathTest, LineGraphOfEmptyGraph) {
-  TypeParam graph;
-  TypeParam line_graph;
-  EXPECT_TRUE(BuildLineGraph<TypeParam>(graph, &line_graph));
-  EXPECT_EQ(0, line_graph.num_nodes());
-  EXPECT_EQ(0, line_graph.num_arcs());
-}
-
-TYPED_TEST(LineGraphTest, LineGraphOfSingleton) {
-  TypeParam graph(1, 1);
-  graph.AddArc(0, 0);
-  TypeParam line_graph;
-  EXPECT_TRUE(BuildLineGraph<TypeParam>(graph, &line_graph));
-  EXPECT_EQ(1, line_graph.num_nodes());
-  EXPECT_EQ(1, line_graph.num_arcs());
-}
-
-TYPED_TEST(LineGraphTest, LineGraph) {
-  const typename TypeParam::NodeIndex kNodes = 4;
-  const typename TypeParam::ArcIndex kArcs[][2] = {
-      {0, 1}, {0, 2}, {1, 2}, {2, 0}, {2, 3}};
-  const typename TypeParam::ArcIndex kExpectedLineArcs[][2] = {
-      {0, 2}, {2, 3}, {3, 0}, {3, 1}, {2, 4}, {1, 4}, {1, 3}};
-  TypeParam graph(kNodes, ABSL_ARRAYSIZE(kArcs));
-  for (int i = 0; i < ABSL_ARRAYSIZE(kArcs); ++i) {
-    graph.AddArc(kArcs[i][0], kArcs[i][1]);
-  }
-  TypeParam line_graph;
-  EXPECT_TRUE(BuildLineGraph<TypeParam>(graph, &line_graph));
-  EXPECT_EQ(ABSL_ARRAYSIZE(kArcs), line_graph.num_nodes());
-  EXPECT_EQ(ABSL_ARRAYSIZE(kExpectedLineArcs), line_graph.num_arcs());
-  for (int i = 0; i < ABSL_ARRAYSIZE(kExpectedLineArcs); ++i) {
-    const typename TypeParam::NodeIndex expected_tail = kExpectedLineArcs[i][0];
-    const typename TypeParam::NodeIndex expected_head = kExpectedLineArcs[i][1];
-    bool found = false;
-    for (const auto arc : line_graph.OutgoingArcs(expected_tail)) {
-      if (line_graph.Head(arc) == expected_head) {
-        found = true;
-        break;
-      }
-    }
-    EXPECT_TRUE(found) << expected_tail << " " << expected_head;
-  }
-}
-
-}  // namespace
-}  // namespace operations_research
diff --git a/ortools/graph/samples/code_samples.bzl b/ortools/graph/samples/code_samples.bzl
index 176a7da3cb..c347f79218 100644
--- a/ortools/graph/samples/code_samples.bzl
+++ b/ortools/graph/samples/code_samples.bzl
@@ -75,8 +75,6 @@ def code_sample_py(name):
             requirement("absl-py"),
             requirement("numpy"),
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
     py_test(
@@ -91,8 +89,6 @@ def code_sample_py(name):
             requirement("absl-py"),
             requirement("numpy"),
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
 def code_sample_cc_py(name):
diff --git a/ortools/init/java/BUILD.bazel b/ortools/init/java/BUILD.bazel
index fad473f8ac..b1194417a9 100644
--- a/ortools/init/java/BUILD.bazel
+++ b/ortools/init/java/BUILD.bazel
@@ -13,16 +13,16 @@
 
 # Description: java wrapping of the C++ code at ../
 
-load("//bazel:swig_java.bzl", "ortools_java_wrap_cc")
+load("//bazel:swig_java.bzl", "java_wrap_cc")
 
-ortools_java_wrap_cc(
+java_wrap_cc(
     name = "init",
-    src = "init.i",
+    srcs = ["init.i"],
     module = "operations_research_init",
     package = "com.google.ortools.init",
     swig_includes = [
         "//ortools/base:base_swig",
-        "//ortools/util/java:absl_string_view_swig",
+        "//ortools/util/java:absl_string_view.swig",
     ],
     visibility = ["//visibility:public"],
     deps = [
diff --git a/ortools/init/python/BUILD.bazel b/ortools/init/python/BUILD.bazel
index b541eeb843..9e1a2dc4e5 100644
--- a/ortools/init/python/BUILD.bazel
+++ b/ortools/init/python/BUILD.bazel
@@ -37,7 +37,6 @@ pybind_extension(
 py_test(
     name = "init_test",
     srcs = ["init_test.py"],
-    python_version = "PY3",
     deps = [
         ":init",
         requirement("absl-py"),
diff --git a/ortools/java/com/google/ortools/BUILD.bazel b/ortools/java/com/google/ortools/BUILD.bazel
index 188af3bce3..4153265e46 100644
--- a/ortools/java/com/google/ortools/BUILD.bazel
+++ b/ortools/java/com/google/ortools/BUILD.bazel
@@ -12,6 +12,7 @@
 # limitations under the License.
 
 load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_java//java:java_library.bzl", "java_library")
 
 # Utilities to load native libraries in java or-tools.
 cc_binary(
diff --git a/ortools/java/com/google/ortools/modelbuilder/BUILD.bazel b/ortools/java/com/google/ortools/modelbuilder/BUILD.bazel
index 27065e7aa0..d256b1e8a4 100644
--- a/ortools/java/com/google/ortools/modelbuilder/BUILD.bazel
+++ b/ortools/java/com/google/ortools/modelbuilder/BUILD.bazel
@@ -11,9 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+load("@rules_java//java:java_library.bzl", "java_library")
+
 package(default_visibility = ["//visibility:public"])
 
-# Utilities to load native libraries in java or-tools.
+# Additional dependency to use when using the wrapped model_builder library.
 java_library(
     name = "modelbuilder",
     srcs = [
@@ -29,7 +31,6 @@ java_library(
         "Variable.java",
         "WeightedSumExpression.java",
     ],
-    visibility = ["//visibility:public"],
     deps = [
         "//ortools/java/com/google/ortools:Loader",
         "//ortools/linear_solver/java:modelbuilder",
diff --git a/ortools/java/com/google/ortools/sat/BUILD.bazel b/ortools/java/com/google/ortools/sat/BUILD.bazel
index 9f3f6f13bc..ebfb8fc2b8 100644
--- a/ortools/java/com/google/ortools/sat/BUILD.bazel
+++ b/ortools/java/com/google/ortools/sat/BUILD.bazel
@@ -11,9 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+load("@rules_java//java:java_library.bzl", "java_library")
+
 package(default_visibility = ["//visibility:public"])
 
-# Utilities to load native libraries in java or-tools.
+# Additional dependency to use when using the wrapped sat solver library.
 java_library(
     name = "sat",
     srcs = [
@@ -41,7 +43,6 @@ java_library(
         "TableConstraint.java",
         "WeightedSumExpression.java",
     ],
-    visibility = ["//visibility:public"],
     deps = [
         "//ortools/java/com/google/ortools:Loader",
         "//ortools/sat:cp_model_java_proto",
diff --git a/ortools/java/pom-full.xml.in b/ortools/java/pom-full.xml.in
index 791f7b6f3f..397c11e455 100644
--- a/ortools/java/pom-full.xml.in
+++ b/ortools/java/pom-full.xml.in
@@ -109,7 +109,7 @@
   <dependency>
     <groupId>com.google.protobuf</groupId>
     <artifactId>protobuf-java</artifactId>
-    <version>4.31.1</version>
+    <version>4.32.0</version>
   </dependency>
 </dependencies>
 
diff --git a/ortools/java/pom-local.xml.in b/ortools/java/pom-local.xml.in
index 64b2c51221..06e1060664 100644
--- a/ortools/java/pom-local.xml.in
+++ b/ortools/java/pom-local.xml.in
@@ -81,7 +81,7 @@
   <dependency>
     <groupId>com.google.protobuf</groupId>
     <artifactId>protobuf-java</artifactId>
-    <version>4.31.1</version>
+    <version>4.32.0</version>
   </dependency>
 </dependencies>
 
diff --git a/ortools/linear_solver/cbc_interface.cc b/ortools/linear_solver/cbc_interface.cc
index dc97d229eb..34c0d2b57d 100644
--- a/ortools/linear_solver/cbc_interface.cc
+++ b/ortools/linear_solver/cbc_interface.cc
@@ -395,7 +395,7 @@ MPSolver::ResultStatus CBCInterface::Solve(const MPSolverParameters& param) {
 
   VLOG(1) << "cbc result status: " << tmp_status;
   /* Final status of problem
-     (info from cbc/.../CbcSolver.cpp,
+     (info from third_party/cbc/.../CbcSolver.cpp,
       See http://cs?q="cbc+status"+file:CbcSolver.cpp)
      Some of these can be found out by is...... functions
      -1 before branchAndBound
diff --git a/ortools/linear_solver/csharp/linear_solver.i b/ortools/linear_solver/csharp/linear_solver.i
index 875c76c106..8089d99106 100644
--- a/ortools/linear_solver/csharp/linear_solver.i
+++ b/ortools/linear_solver/csharp/linear_solver.i
@@ -11,9 +11,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// This .i file is only used in the open-source export of
-// util/operations_research (github or-tools)
-//
 // It exposes the linear programming and integer programming solver.
 //
 // The C# API is quite different from the C++ API; mostly because it
diff --git a/ortools/linear_solver/gurobi_interface.cc b/ortools/linear_solver/gurobi_interface.cc
index 26cb42dd4b..4c8e2e20c1 100644
--- a/ortools/linear_solver/gurobi_interface.cc
+++ b/ortools/linear_solver/gurobi_interface.cc
@@ -168,7 +168,7 @@ class GurobiInterface : public MPSolverInterface {
   }
 
   bool InterruptSolve() override {
-    const absl::MutexLock lock(&hold_interruptions_mutex_);
+    const absl::MutexLock lock(hold_interruptions_mutex_);
     if (model_ != nullptr) GRBterminate(model_);
     return true;
   }
@@ -663,7 +663,7 @@ GurobiInterface::~GurobiInterface() {
 
 void GurobiInterface::Reset() {
   // We hold calls to GRBterminate() until the new model_ is ready.
-  const absl::MutexLock lock(&hold_interruptions_mutex_);
+  const absl::MutexLock lock(hold_interruptions_mutex_);
 
   GRBmodel* old_model = model_;
   CheckedGurobiCall(GRBnewmodel(global_env_, &model_, solver_->name_.c_str(),
diff --git a/ortools/linear_solver/highs_interface.cc b/ortools/linear_solver/highs_interface.cc
index ec4c372767..d780825e5b 100644
--- a/ortools/linear_solver/highs_interface.cc
+++ b/ortools/linear_solver/highs_interface.cc
@@ -15,6 +15,7 @@
 
 #include <atomic>
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -102,6 +103,7 @@ class HighsInterface : public MPSolverInterface {
   void NonIncrementalChange();
 
   const bool solve_as_a_mip_;
+  std::optional<HighsSolveInfo> solve_info_;
 };
 
 HighsInterface::HighsInterface(MPSolver* const solver, bool solve_as_a_mip)
@@ -140,8 +142,9 @@ MPSolver::ResultStatus HighsInterface::Solve(const MPSolverParameters& param) {
   }
 
   // Set parameters.
+  solve_info_ = HighsSolveInfo();
   absl::StatusOr<MPSolutionResponse> response =
-      HighsSolveProto(std::move(request));
+      HighsSolveProto(std::move(request), &*solve_info_);
 
   if (!response.ok()) {
     LOG(ERROR) << "Unexpected error solving with Highs: " << response.status();
@@ -163,7 +166,10 @@ MPSolver::ResultStatus HighsInterface::Solve(const MPSolverParameters& param) {
   return result_status_;
 }
 
-void HighsInterface::Reset() { ResetExtractionInformation(); }
+void HighsInterface::Reset() {
+  ResetExtractionInformation();
+  solve_info_.reset();
+}
 
 void HighsInterface::SetOptimizationDirection(bool maximize) {
   NonIncrementalChange();
@@ -215,8 +221,9 @@ int64_t HighsInterface::iterations() const {
 }
 
 int64_t HighsInterface::nodes() const {
-  LOG(DFATAL) << "Number of nodes only available for discrete problems";
-  return MPSolverInterface::kUnknownNumberOfNodes;
+  QCHECK(solve_info_.has_value())
+      << "Number of nodes only available after solve";
+  return solve_info_->mip_node_count;
 }
 
 MPSolver::BasisStatus HighsInterface::row_status(int constraint_index) const {
diff --git a/ortools/linear_solver/java/BUILD.bazel b/ortools/linear_solver/java/BUILD.bazel
index 0cf3c00226..ff9a9a8247 100644
--- a/ortools/linear_solver/java/BUILD.bazel
+++ b/ortools/linear_solver/java/BUILD.bazel
@@ -15,16 +15,16 @@
 
 load("@contrib_rules_jvm//java:defs.bzl", "java_junit5_test")
 load("@rules_jvm_external//:defs.bzl", "artifact")
-load("//bazel:swig_java.bzl", "ortools_java_wrap_cc")
+load("//bazel:swig_java.bzl", "java_wrap_cc")
 
-ortools_java_wrap_cc(
+java_wrap_cc(
     name = "modelbuilder",
-    src = "modelbuilder.swig",
+    srcs = ["modelbuilder.swig"],
     module = "modelbuilder",
     package = "com.google.ortools.modelbuilder",
     swig_includes = [
         "//ortools/base:base_swig",
-        "//ortools/util/java:vector_swig",
+        "//ortools/util/java:vector.swig",
     ],
     visibility = ["//visibility:public"],
     deps = [
diff --git a/ortools/linear_solver/linear_solver.cc b/ortools/linear_solver/linear_solver.cc
index 7058e72038..8c781bceca 100644
--- a/ortools/linear_solver/linear_solver.cc
+++ b/ortools/linear_solver/linear_solver.cc
@@ -1376,7 +1376,7 @@ absl::Status MPSolver::LoadSolutionFromProto(const MPSolutionResponse& response,
 
 void MPSolver::Clear() {
   {
-    absl::MutexLock lock(&global_count_mutex_);
+    absl::MutexLock lock(global_count_mutex_);
     global_num_variables_ += variables_.size();
     global_num_constraints_ += constraints_.size();
   }
@@ -1909,13 +1909,13 @@ int64_t MPSolver::global_num_constraints_ = 0;
 
 // static
 int64_t MPSolver::global_num_variables() {
-  absl::MutexLock lock(&global_count_mutex_);
+  absl::MutexLock lock(global_count_mutex_);
   return global_num_variables_;
 }
 
 // static
 int64_t MPSolver::global_num_constraints() {
-  absl::MutexLock lock(&global_count_mutex_);
+  absl::MutexLock lock(global_count_mutex_);
   return global_num_constraints_;
 }
 
diff --git a/ortools/linear_solver/linear_solver.proto b/ortools/linear_solver/linear_solver.proto
index d4abec9006..f50cf8fc66 100644
--- a/ortools/linear_solver/linear_solver.proto
+++ b/ortools/linear_solver/linear_solver.proto
@@ -576,7 +576,6 @@ enum MPSolverResponseStatus {
   // Implementation error: the requested solver implementation is not
   // available (see MPModelRequest.solver_type).
   // The linear solver binary was probably not linked with the required library,
-  // eg //ortools/linear_solver:linear_solver_scip for SCIP.
   MPSOLVER_SOLVER_TYPE_UNAVAILABLE = 0x7;
   // Some of the selected options were incompatible, e.g. a cancellable solve
   // was requested via SolverClient::SolveMipRemotely() with an underlying
diff --git a/ortools/linear_solver/proto_solver/highs_proto_solver.cc b/ortools/linear_solver/proto_solver/highs_proto_solver.cc
index 5a0c564e9e..41622b11f0 100644
--- a/ortools/linear_solver/proto_solver/highs_proto_solver.cc
+++ b/ortools/linear_solver/proto_solver/highs_proto_solver.cc
@@ -46,7 +46,7 @@ absl::Status SetSolverSpecificParameters(const std::string& parameters,
                                          Highs& highs);
 
 absl::StatusOr<MPSolutionResponse> HighsSolveProto(
-    LazyMutableCopy<MPModelRequest> request) {
+    LazyMutableCopy<MPModelRequest> request, HighsSolveInfo* solve_info) {
   MPSolutionResponse response;
   const std::optional<LazyMutableCopy<MPModelProto>> optional_model =
       GetMPModelOrPopulateResponse(request, &response);
@@ -262,6 +262,10 @@ absl::StatusOr<MPSolutionResponse> HighsSolveProto(
     }
   }
 
+  if (solve_info != nullptr) {
+    solve_info->mip_node_count = highs.getInfo().mip_node_count;
+  }
+
   const absl::Duration solving_duration = absl::Now() - time_before;
   user_timer.Stop();
   response.mutable_solve_info()->set_solve_wall_time_seconds(
diff --git a/ortools/linear_solver/proto_solver/highs_proto_solver.h b/ortools/linear_solver/proto_solver/highs_proto_solver.h
index 633373b471..152c380eac 100644
--- a/ortools/linear_solver/proto_solver/highs_proto_solver.h
+++ b/ortools/linear_solver/proto_solver/highs_proto_solver.h
@@ -14,8 +14,7 @@
 #ifndef OR_TOOLS_LINEAR_SOLVER_PROTO_SOLVER_HIGHS_PROTO_SOLVER_H_
 #define OR_TOOLS_LINEAR_SOLVER_PROTO_SOLVER_HIGHS_PROTO_SOLVER_H_
 
-#include <functional>
-#include <string>
+#include <cstdint>
 
 #include "absl/status/statusor.h"
 #include "ortools/linear_solver/linear_solver.pb.h"
@@ -23,9 +22,16 @@
 
 namespace operations_research {
 
-// Solve the input MIP model with the HIGHS solver.
+// Information about the Highs solve.
+struct HighsSolveInfo {
+  int64_t mip_node_count;  // The number of nodes generated by the MIP solver.
+};
+
+// Solve the input MIP model with the HIGHS solver and fills `solve_info` if
+// provided.
 absl::StatusOr<MPSolutionResponse> HighsSolveProto(
-    LazyMutableCopy<MPModelRequest> request);
+    LazyMutableCopy<MPModelRequest> request,
+    HighsSolveInfo* solve_info = nullptr);
 
 }  // namespace operations_research
 
diff --git a/ortools/linear_solver/samples/code_samples.bzl b/ortools/linear_solver/samples/code_samples.bzl
index 41be2f3cd0..5b387375d0 100644
--- a/ortools/linear_solver/samples/code_samples.bzl
+++ b/ortools/linear_solver/samples/code_samples.bzl
@@ -58,8 +58,6 @@ def code_sample_py(name):
             "//ortools/init/python:init",
             "//ortools/linear_solver/python:model_builder",
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
     py_test(
@@ -77,8 +75,6 @@ def code_sample_py(name):
             requirement("numpy"),
             requirement("pandas"),
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
 def code_sample_java(name):
diff --git a/ortools/linear_solver/scip_callback.cc b/ortools/linear_solver/scip_callback.cc
index c8b68353eb..0762e82284 100644
--- a/ortools/linear_solver/scip_callback.cc
+++ b/ortools/linear_solver/scip_callback.cc
@@ -166,7 +166,7 @@ ScipSeparationResult RunSeparation(internal::ScipCallbackRunner* runner,
         CHECK_OK(SCIP_TO_STATUS(SCIPreleaseRow(scip, &row)));
         // TODO(user): when infeasible is true, it better to have the scip
         // return status be cutoff instead of cutting plane added (e.g. see
-        // cs/scip/src/scip/cons_knapsack.c). However, as we use
+        // cs/third_party/scip/src/scip/cons_knapsack.c). However, as we use
         // SCIPaddRow(), it isn't clear this will even happen.
         if (result != ScipSeparationResult::kLazyConstraintAdded) {
           // NOTE(user): if we have already found a violated lazy constraint,
diff --git a/ortools/linear_solver/scip_interface.cc b/ortools/linear_solver/scip_interface.cc
index 0db85273a6..ce7e906da0 100644
--- a/ortools/linear_solver/scip_interface.cc
+++ b/ortools/linear_solver/scip_interface.cc
@@ -138,7 +138,7 @@ class SCIPInterface : public MPSolverInterface {
   }
 
   bool InterruptSolve() override {
-    const absl::MutexLock lock(&hold_interruptions_mutex_);
+    const absl::MutexLock lock(hold_interruptions_mutex_);
     if (scip_ == nullptr) {
       LOG_IF(DFATAL, status_.ok()) << "scip_ is null is unexpected here, since "
                                       "status_ did not report any error";
@@ -280,7 +280,7 @@ SCIPInterface::~SCIPInterface() { DeleteSCIP(); }
 
 void SCIPInterface::Reset() {
   // We hold calls to SCIPinterruptSolve() until the new scip_ is fully built.
-  const absl::MutexLock lock(&hold_interruptions_mutex_);
+  const absl::MutexLock lock(hold_interruptions_mutex_);
 
   // Remove existing one but keep it alive to copy parameters from it.
   SCIP* old_scip = DeleteSCIP(/*return_scip=*/true);
diff --git a/ortools/lp_data/BUILD.bazel b/ortools/lp_data/BUILD.bazel
index 15cd8880c9..6c1f665716 100644
--- a/ortools/lp_data/BUILD.bazel
+++ b/ortools/lp_data/BUILD.bazel
@@ -15,34 +15,13 @@ load("@rules_cc//cc:cc_library.bzl", "cc_library")
 
 package(default_visibility = ["//visibility:public"])
 
-config_setting(
-    name = "on_linux",
-    constraint_values = [
-        "@platforms//os:linux",
-    ],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = [
-        "@platforms//os:macos",
-    ],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = [
-        "@platforms//os:windows",
-    ],
-)
-
 # Floating-point code in this directory must not be compiled with
 # dangerous optimizations. For example do not assume that FP expressions
 # are associative. This is what -fno-fast-math is for.
 SAFE_FP_CODE = select({
-    "on_linux": ["-fno-fast-math"],
-    "on_macos": [],  # no_fast_math is the default.
-    "on_windows": [],  # /fp:precise is the default.
+    "@platforms//os:linux": ["-fno-fast-math"],
+    "@platforms//os:macos": [],  # no_fast_math is the default.
+    "@platforms//os:windows": [],  # /fp:precise is the default.
     "//conditions:default": [],
 })
 
@@ -247,7 +226,6 @@ cc_library(
         ":lp_data",
         ":proto_utils",
         "//ortools/base",
-        "//ortools/base:case",
         "//ortools/base:map_util",
         "//ortools/linear_solver:linear_solver_cc_proto",
         "@abseil-cpp//absl/status:statusor",
diff --git a/ortools/lp_data/lp_decomposer.cc b/ortools/lp_data/lp_decomposer.cc
index a5f244a650..154c12a87c 100644
--- a/ortools/lp_data/lp_decomposer.cc
+++ b/ortools/lp_data/lp_decomposer.cc
@@ -36,7 +36,7 @@ LPDecomposer::LPDecomposer()
     : original_problem_(nullptr), clusters_(), mutex_() {}
 
 void LPDecomposer::Decompose(const LinearProgram* linear_problem) {
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   original_problem_ = linear_problem;
   clusters_.clear();
 
@@ -69,12 +69,12 @@ void LPDecomposer::Decompose(const LinearProgram* linear_problem) {
 }
 
 int LPDecomposer::GetNumberOfProblems() const {
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   return clusters_.size();
 }
 
 const LinearProgram& LPDecomposer::original_problem() const {
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   return *original_problem_;
 }
 
@@ -85,7 +85,7 @@ void LPDecomposer::ExtractLocalProblem(int problem_index, LinearProgram* lp) {
 
   lp->Clear();
 
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   const std::vector<ColIndex>& cluster = clusters_[problem_index];
   StrictITIVector<ColIndex, ColIndex> global_to_local(
       original_problem_->num_variables(), kInvalidCol);
@@ -143,7 +143,7 @@ DenseRow LPDecomposer::AggregateAssignments(
     absl::Span<const DenseRow> assignments) const {
   CHECK_EQ(assignments.size(), clusters_.size());
 
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   DenseRow global_assignment(original_problem_->num_variables(),
                              Fractional(0.0));
   for (int problem = 0; problem < assignments.size(); ++problem) {
@@ -163,7 +163,7 @@ DenseRow LPDecomposer::ExtractLocalAssignment(int problem_index,
   CHECK_LT(problem_index, clusters_.size());
   CHECK_EQ(assignment.size(), original_problem_->num_variables());
 
-  absl::MutexLock mutex_lock(&mutex_);
+  absl::MutexLock mutex_lock(mutex_);
   const std::vector<ColIndex>& cluster = clusters_[problem_index];
   DenseRow local_assignment(ColIndex(cluster.size()), Fractional(0.0));
   for (int i = 0; i < cluster.size(); ++i) {
diff --git a/ortools/math_opt/core/python/BUILD.bazel b/ortools/math_opt/core/python/BUILD.bazel
index 4aec371d30..c372b6d0fd 100644
--- a/ortools/math_opt/core/python/BUILD.bazel
+++ b/ortools/math_opt/core/python/BUILD.bazel
@@ -11,9 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-load("@pip_deps//:requirements.bzl", "requirement")
 load("@pybind11_bazel//:build_defs.bzl", "pybind_extension")
-load("@rules_python//python:py_test.bzl", "py_test")
 
 package(default_visibility = ["//ortools/math_opt:__subpackages__"])
 
@@ -60,24 +58,3 @@ pybind_extension(
             "@pybind11_protobuf//pybind11_protobuf:native_proto_caster",
         ],
 )
-
-py_test(
-    name = "solver_test",
-    size = "small",
-    srcs = ["solver_test.py"],
-    deps = [
-        ":solver",
-        requirement("absl-py"),
-        "//ortools/math_opt:callback_py_pb2",
-        "//ortools/math_opt:model_parameters_py_pb2",
-        "//ortools/math_opt:model_py_pb2",
-        "//ortools/math_opt:model_update_py_pb2",
-        "//ortools/math_opt:parameters_py_pb2",
-        "//ortools/math_opt:result_py_pb2",
-        "//ortools/math_opt/solvers:cp_sat_solver",
-        "//ortools/math_opt/solvers:glop_solver",
-        "//ortools/math_opt/solvers:gscip_solver",
-        "//ortools/util/python:pybind_solve_interrupter",
-        "@pybind11_abseil//pybind11_abseil:status",
-    ],
-)
diff --git a/ortools/math_opt/cpp/BUILD.bazel b/ortools/math_opt/cpp/BUILD.bazel
index 90d1e05cfd..0ecfa61008 100644
--- a/ortools/math_opt/cpp/BUILD.bazel
+++ b/ortools/math_opt/cpp/BUILD.bazel
@@ -11,6 +11,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+load("@protobuf//bazel:cc_proto_library.bzl", "cc_proto_library")
+load("@protobuf//bazel:proto_library.bzl", "proto_library")
 load("@rules_cc//cc:cc_library.bzl", "cc_library")
 load("@rules_cc//cc:cc_test.bzl", "cc_test")
 
@@ -184,6 +186,71 @@ cc_library(
     ],
 )
 
+# Same as `variable_and_expressions` but activates the counters of instances of
+# LinearExpression. Only for tests.
+cc_library(
+    name = "variable_and_expressions_with_counters",
+    testonly = 1,
+    srcs = ["variable_and_expressions.cc"],
+    hdrs = ["variable_and_expressions.h"],
+    defines = ["MATH_OPT_USE_EXPRESSION_COUNTERS"],
+    deps = [
+        ":formatters",
+        ":key_types",
+        "//ortools/base",
+        "//ortools/base:intops",
+        "//ortools/base:map_util",
+        "//ortools/math_opt/storage:model_storage",
+        "//ortools/math_opt/storage:model_storage_item",
+        "//ortools/math_opt/storage:model_storage_types",
+        "//ortools/util:fp_roundtrip_conv",
+        "@abseil-cpp//absl/base:core_headers",
+        "@abseil-cpp//absl/container:flat_hash_map",
+        "@abseil-cpp//absl/log",
+        "@abseil-cpp//absl/log:check",
+        "@abseil-cpp//absl/strings",
+    ],
+)
+
+cc_test(
+    name = "variable_and_expressions_test",
+    srcs = ["variable_and_expressions_test.cc"],
+    deps = [
+        ":matchers",
+        ":variable_and_expressions",
+        "//ortools/base:gmock",
+        "//ortools/base:gmock_main",
+        "//ortools/math_opt/elemental:elements",
+        "//ortools/math_opt/storage:model_storage",
+        "//ortools/util:fp_roundtrip_conv",
+        "//ortools/util:fp_roundtrip_conv_testing",
+        "@abseil-cpp//absl/container:flat_hash_map",
+        "@abseil-cpp//absl/strings",
+        "@abseil-cpp//absl/strings:str_format",
+    ],
+)
+
+# Same as `variable_and_expressions_test` but activates the counters of
+# instances of LinearExpression and the associated tests.
+cc_test(
+    name = "variable_and_expressions_with_counters_test",
+    srcs = ["variable_and_expressions_test.cc"],
+    defines = ["MATH_OPT_USE_EXPRESSION_COUNTERS"],
+    deps = [
+        ":matchers",
+        ":variable_and_expressions_with_counters",
+        "//ortools/base:gmock",
+        "//ortools/base:gmock_main",
+        "//ortools/math_opt/elemental:elements",
+        "//ortools/math_opt/storage:model_storage",
+        "//ortools/util:fp_roundtrip_conv",
+        "//ortools/util:fp_roundtrip_conv_testing",
+        "@abseil-cpp//absl/container:flat_hash_map",
+        "@abseil-cpp//absl/strings",
+        "@abseil-cpp//absl/strings:str_format",
+    ],
+)
+
 cc_library(
     name = "objective",
     srcs = ["objective.cc"],
@@ -199,6 +266,20 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "objective_test",
+    srcs = ["objective_test.cc"],
+    deps = [
+        ":objective",
+        ":variable_and_expressions",
+        "//ortools/base:gmock",
+        "//ortools/base:gmock_main",
+        "//ortools/math_opt/storage:model_storage",
+        "//ortools/math_opt/storage:model_storage_types",
+        "@abseil-cpp//absl/strings",
+    ],
+)
+
 cc_library(
     name = "linear_constraint",
     hdrs = ["linear_constraint.h"],
@@ -215,6 +296,24 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "linear_constraint_test",
+    srcs = ["linear_constraint_test.cc"],
+    deps = [
+        ":linear_constraint",
+        ":matchers",
+        ":model",
+        ":variable_and_expressions",
+        "//ortools/base:gmock",
+        "//ortools/base:gmock_main",
+        "//ortools/base:intops",
+        "//ortools/math_opt/constraints/util:model_util",
+        "//ortools/math_opt/storage:model_storage",
+        "//ortools/math_opt/storage:model_storage_types",
+        "@abseil-cpp//absl/strings",
+    ],
+)
+
 cc_library(
     name = "solution",
     srcs = ["solution.cc"],
@@ -243,6 +342,26 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "solution_test",
+    srcs = ["solution_test.cc"],
+    deps = [
+        ":enums_testing",
+        ":linear_constraint",
+        ":matchers",
+        ":math_opt",
+        ":objective",
+        ":solution",
+        ":variable_and_expressions",
+        "//ortools/base:gmock",
+        "//ortools/base:gmock_main",
+        "//ortools/math_opt:solution_cc_proto",
+        "//ortools/math_opt:sparse_containers_cc_proto",
+        "//ortools/math_opt/storage:model_storage",
+        "@abseil-cpp//absl/status",
+    ],
+)
+
 cc_library(
     name = "solve_result",
     srcs = ["solve_result.cc"],
@@ -291,6 +410,21 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "map_filter_test",
+    srcs = ["map_filter_test.cc"],
+    deps = [
+        ":linear_constraint",
+        ":map_filter",
+        ":model",
+        ":variable_and_expressions",
+        "//ortools/base:gmock_main",
+        "//ortools/math_opt:sparse_containers_cc_proto",
+        "//ortools/math_opt/storage:model_storage",
+        "@abseil-cpp//absl/status",
+    ],
+)
+
 cc_library(
     name = "callback",
     srcs = ["callback.cc"],
@@ -331,6 +465,20 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "key_types_test",
+    srcs = ["key_types_test.cc"],
+    deps = [
+        ":key_types",
+        ":variable_and_expressions",
+        "//ortools/base:gmock_main",
+        "//ortools/math_opt/storage:model_storage",
+        "@abseil-cpp//absl/container:flat_hash_set",
+        "@abseil-cpp//absl/status",
+        "@google_benchmark//:benchmark",
+    ],
+)
+
 cc_library(
     name = "model_solve_parameters",
     srcs = ["model_solve_parameters.cc"],
@@ -415,6 +563,17 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "solve_arguments_test",
+    srcs = ["solve_arguments_test.cc"],
+    deps = [
+        ":math_opt",
+        ":solve_arguments",
+        "//ortools/base:gmock_main",
+        "@abseil-cpp//absl/status",
+    ],
+)
+
 cc_library(
     name = "solve",
     srcs = ["solve.cc"],
@@ -452,6 +611,17 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "streamable_solver_init_arguments_test",
+    srcs = ["streamable_solver_init_arguments_test.cc"],
+    deps = [
+        ":streamable_solver_init_arguments",
+        "//ortools/base:gmock_main",
+        "//ortools/math_opt:parameters_cc_proto",
+        "//ortools/math_opt/solvers:gurobi_cc_proto",
+    ],
+)
+
 cc_library(
     name = "parameters",
     srcs = ["parameters.cc"],
@@ -467,6 +637,7 @@ cc_library(
         "//ortools/math_opt/solvers:gurobi_cc_proto",
         "//ortools/math_opt/solvers:highs_cc_proto",
         "//ortools/math_opt/solvers/gscip:gscip_cc_proto",
+        "//ortools/pdlp:solvers_cc_proto",
         "//ortools/port:proto_utils",
         "//ortools/sat:sat_parameters_cc_proto",
         "//ortools/util:status_macros",
@@ -502,6 +673,22 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "matchers_test",
+    srcs = ["matchers_test.cc"],
+    deps = [
+        ":matchers",
+        ":math_opt",
+        ":model",
+        ":solution",
+        ":solve_result",
+        "//ortools/base:gmock",
+        "//ortools/base:gmock_main",
+        "@abseil-cpp//absl/container:flat_hash_map",
+        "@abseil-cpp//absl/strings",
+    ],
+)
+
 cc_library(
     name = "enums",
     hdrs = ["enums.h"],
@@ -512,6 +699,31 @@ cc_library(
     ],
 )
 
+proto_library(
+    name = "enums_test_proto",
+    srcs = ["enums_test.proto"],
+)
+
+cc_proto_library(
+    name = "enums_test_cc_proto",
+    deps = [":enums_test_proto"],
+)
+
+cc_test(
+    name = "enums_test",
+    srcs = ["enums_test.cc"],
+    deps = [
+        ":enums",
+        ":enums_test_cc_proto",
+        ":enums_testing",
+        "//ortools/base:gmock_main",
+        "//ortools/base:logging",
+        "//ortools/math_opt/testing:stream",
+        "@abseil-cpp//absl/strings",
+        "@abseil-cpp//absl/types:span",
+    ],
+)
+
 cc_library(
     name = "enums_testing",
     testonly = True,
@@ -538,6 +750,16 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "statistics_test",
+    srcs = ["statistics_test.cc"],
+    deps = [
+        ":model",
+        ":statistics",
+        "//ortools/base:gmock_main",
+    ],
+)
+
 cc_library(
     name = "formatters",
     hdrs = ["formatters.h"],
@@ -582,6 +804,35 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "compute_infeasible_subsystem_result_test",
+    srcs = ["compute_infeasible_subsystem_result_test.cc"],
+    deps = [
+        ":compute_infeasible_subsystem_result",
+        ":enums",
+        ":linear_constraint",
+        ":matchers",
+        ":model",
+        ":solve_result",
+        ":variable_and_expressions",
+        "//ortools/base:gmock_main",
+        "//ortools/base:status_macros",
+        "//ortools/math_opt:infeasible_subsystem_cc_proto",
+        "//ortools/math_opt:result_cc_proto",
+        "//ortools/math_opt/constraints/indicator:indicator_constraint",
+        "//ortools/math_opt/constraints/quadratic:quadratic_constraint",
+        "//ortools/math_opt/constraints/second_order_cone:second_order_cone_constraint",
+        "//ortools/math_opt/constraints/sos:sos1_constraint",
+        "//ortools/math_opt/constraints/sos:sos2_constraint",
+        "//ortools/math_opt/storage:model_storage",
+        "//ortools/math_opt/testing:stream",
+        "@abseil-cpp//absl/container:flat_hash_map",
+        "@abseil-cpp//absl/container:flat_hash_set",
+        "@abseil-cpp//absl/status",
+        "@abseil-cpp//absl/status:statusor",
+    ],
+)
+
 cc_library(
     name = "compute_infeasible_subsystem_arguments",
     hdrs = ["compute_infeasible_subsystem_arguments.h"],
@@ -605,6 +856,15 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "solver_resources_test",
+    srcs = ["solver_resources_test.cc"],
+    deps = [
+        ":solver_resources",
+        "//ortools/base:gmock_main",
+    ],
+)
+
 cc_library(
     name = "solve_impl",
     srcs = ["solve_impl.cc"],
diff --git a/ortools/math_opt/cpp/CMakeLists.txt b/ortools/math_opt/cpp/CMakeLists.txt
index ba86195715..8dbf3aa918 100644
--- a/ortools/math_opt/cpp/CMakeLists.txt
+++ b/ortools/math_opt/cpp/CMakeLists.txt
@@ -36,9 +36,9 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
+    ortools::base_gmock
     absl::log
     absl::status
     absl::strings
-    GTest::gmock
   TESTING
 )
diff --git a/ortools/math_opt/cpp/callback_test.cc b/ortools/math_opt/cpp/callback_test.cc
new file mode 100644
index 0000000000..1a17138b1a
--- /dev/null
+++ b/ortools/math_opt/cpp/callback_test.cc
@@ -0,0 +1,358 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/callback.h"
+
+#include <limits>
+#include <optional>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
+#include "absl/time/time.h"
+#include "google/protobuf/duration.pb.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/protoutil.h"
+#include "ortools/math_opt/callback.pb.h"
+#include "ortools/math_opt/cpp/enums_testing.h"
+#include "ortools/math_opt/cpp/map_filter.h"
+#include "ortools/math_opt/cpp/model.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+#include "ortools/math_opt/storage/model_storage.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+using ::testing::EqualsProto;
+using ::testing::EquivToProto;
+using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::Pair;
+using ::testing::UnorderedElementsAre;
+using ::testing::status::IsOkAndHolds;
+using ::testing::status::StatusIs;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(CallbackEvent, EnumTest, CallbackEvent);
+
+TEST(CallbackDataTest, Creation) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Variable y(&storage, storage.AddVariable("y"));
+  CallbackDataProto proto;
+  proto.set_event(CALLBACK_EVENT_MIP_NODE);
+  auto var_values = proto.mutable_primal_solution_vector();
+  var_values->add_ids(0);
+  var_values->add_ids(1);
+  var_values->add_values(3.0);
+  var_values->add_values(5.0);
+  ASSERT_OK_AND_ASSIGN(*proto.mutable_runtime(),
+                       util_time::EncodeGoogleApiProto(absl::Seconds(11)));
+  proto.mutable_presolve_stats()->set_removed_variables(3);
+  proto.mutable_simplex_stats()->set_iteration_count(12);
+  proto.mutable_barrier_stats()->set_primal_objective(10.0);
+  proto.mutable_mip_stats()->set_explored_nodes(4);
+  CallbackData cb_data(&storage, proto);
+  EXPECT_EQ(cb_data.event, CallbackEvent::kMipNode);
+  ASSERT_TRUE(cb_data.solution.has_value());
+  EXPECT_THAT(*cb_data.solution,
+              UnorderedElementsAre(Pair(x, 3.0), Pair(y, 5.0)));
+  EXPECT_EQ(cb_data.runtime, absl::Seconds(11));
+  EXPECT_THAT(cb_data.presolve_stats, EqualsProto("removed_variables: 3"));
+  EXPECT_THAT(cb_data.simplex_stats, EqualsProto("iteration_count: 12"));
+  EXPECT_THAT(cb_data.barrier_stats, EqualsProto("primal_objective: 10.0"));
+  EXPECT_THAT(cb_data.mip_stats, EqualsProto("explored_nodes: 4"));
+
+  EXPECT_OK(cb_data.CheckModelStorage(&storage));
+  const ModelStorage other_storage;
+  EXPECT_THAT(cb_data.CheckModelStorage(&other_storage),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid variable")));
+
+  EXPECT_THAT(cb_data.Proto(), IsOkAndHolds(EquivToProto(proto)));
+}
+
+TEST(CallbackDataTest, CreationWithEventConstructor) {
+  CallbackData cb_data(CallbackEvent::kMipNode, absl::Seconds(10));
+  EXPECT_EQ(cb_data.event, CallbackEvent::kMipNode);
+  EXPECT_EQ(cb_data.runtime, absl::Seconds(10));
+}
+
+TEST(CallbackDataTest, NoSolution) {
+  ModelStorage storage;
+  CallbackDataProto proto;
+  proto.set_event(CALLBACK_EVENT_MIP_NODE);
+  proto.mutable_mip_stats()->set_explored_nodes(4);
+  CallbackData cb_data(&storage, proto);
+  EXPECT_EQ(cb_data.event, CallbackEvent::kMipNode);
+  EXPECT_FALSE(cb_data.solution.has_value());
+  EXPECT_THAT(cb_data.mip_stats, EqualsProto("explored_nodes: 4"));
+
+  EXPECT_OK(cb_data.CheckModelStorage(&storage));
+  const ModelStorage other_storage;
+  EXPECT_OK(cb_data.CheckModelStorage(&other_storage));
+
+  EXPECT_THAT(cb_data.Proto(), IsOkAndHolds(EquivToProto(proto)));
+}
+
+TEST(CallbackDataTest, EmptySolution) {
+  ModelStorage storage;
+  CallbackDataProto proto;
+  proto.set_event(CALLBACK_EVENT_MIP_NODE);
+  proto.mutable_primal_solution_vector();
+  proto.mutable_mip_stats()->set_explored_nodes(4);
+  CallbackData cb_data(&storage, proto);
+  EXPECT_EQ(cb_data.event, CallbackEvent::kMipNode);
+  ASSERT_TRUE(cb_data.solution.has_value());
+  EXPECT_THAT(*cb_data.solution, IsEmpty());
+  EXPECT_THAT(cb_data.mip_stats, EqualsProto("explored_nodes: 4"));
+
+  EXPECT_OK(cb_data.CheckModelStorage(&storage));
+  const ModelStorage other_storage;
+  EXPECT_OK(cb_data.CheckModelStorage(&other_storage));
+
+  EXPECT_THAT(cb_data.Proto(), IsOkAndHolds(EquivToProto(proto)));
+}
+
+TEST(CallbackDataTest, InvalidRuntime) {
+  EXPECT_THAT(
+      CallbackData(
+          /*event=*/CallbackEvent::kPresolve,
+          /*runtime=*/absl::InfiniteDuration())
+          .Proto(),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("runtime")));
+}
+
+TEST(CallbackRegistrationTest, ProtoRoundtrip) {
+  Model model;
+  model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+
+  // Test with all fields set, and boolean fields to true (non default
+  // value). Here we assume we use the same function for the mip_node_filter and
+  // the mip_solution_filter, and thus test the skip_zero_values with one and
+  // the filter_by_ids for the other.
+  {
+    CallbackRegistrationProto registration_proto;
+    registration_proto.add_request_registration(CALLBACK_EVENT_MIP_SOLUTION);
+    registration_proto.add_request_registration(CALLBACK_EVENT_MIP_NODE);
+    registration_proto.mutable_mip_node_filter()->set_skip_zero_values(true);
+    registration_proto.mutable_mip_solution_filter()->set_filter_by_ids(true);
+    registration_proto.mutable_mip_solution_filter()->add_filtered_ids(y.id());
+    registration_proto.set_add_cuts(true);
+    registration_proto.set_add_lazy_constraints(true);
+
+    ASSERT_OK_AND_ASSIGN(
+        const CallbackRegistration registration,
+        CallbackRegistration::FromProto(model, registration_proto));
+
+    EXPECT_OK(registration.CheckModelStorage(model.storage()));
+    EXPECT_THAT(registration.Proto(), EquivToProto(registration_proto));
+  }
+
+  // Test with boolean field to false (default value).
+  {
+    CallbackRegistrationProto registration_proto;
+    registration_proto.set_add_cuts(false);
+    registration_proto.set_add_lazy_constraints(false);
+
+    ASSERT_OK_AND_ASSIGN(
+        const CallbackRegistration registration,
+        CallbackRegistration::FromProto(model, registration_proto));
+
+    EXPECT_OK(registration.CheckModelStorage(model.storage()));
+    EXPECT_THAT(registration.Proto(), EquivToProto(registration_proto));
+  }
+}
+
+TEST(CallbackRegistrationTest, CheckModelStorageMixedModels) {
+  ModelStorage storage_1;
+  const Variable x(&storage_1, storage_1.AddVariable("x"));
+  ModelStorage storage_2;
+  const Variable y(&storage_2, storage_2.AddVariable("y"));
+  CallbackRegistration registration;
+  registration.events = {CallbackEvent::kMipNode, CallbackEvent::kMipSolution};
+  registration.mip_node_filter.filtered_keys = {x};
+  registration.mip_solution_filter.filtered_keys = {y};
+  EXPECT_THAT(registration.CheckModelStorage(&storage_1),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(CallbackRegistrationTest, FromProtoBadEvent) {
+  CallbackRegistrationProto registration_proto;
+  registration_proto.add_request_registration(CALLBACK_EVENT_UNSPECIFIED);
+  ASSERT_THAT(
+      CallbackRegistration::FromProto(Model{}, registration_proto),
+      StatusIs(
+          absl::StatusCode::kInvalidArgument,
+          AllOf(HasSubstr("CallbackRegistrationProto.request_registration[0]"),
+                HasSubstr("CALLBACK_EVENT_UNSPECIFIED"))));
+}
+
+TEST(CallbackRegistrationTest, FromProtoRepeatedEvent) {
+  CallbackRegistrationProto registration_proto;
+  registration_proto.add_request_registration(CALLBACK_EVENT_MIP_NODE);
+  registration_proto.add_request_registration(CALLBACK_EVENT_MIP_NODE);
+  ASSERT_THAT(
+      CallbackRegistration::FromProto(Model{}, registration_proto),
+      StatusIs(
+          absl::StatusCode::kInvalidArgument,
+          AllOf(HasSubstr("CallbackRegistrationProto.request_registration[1]"),
+                HasSubstr("mip_node"))));
+}
+
+TEST(CallbackRegistrationTest, FromProtoInvalidMipSolutionFilterId) {
+  CallbackRegistrationProto registration_proto;
+  registration_proto.mutable_mip_solution_filter()->set_filter_by_ids(true);
+  registration_proto.mutable_mip_solution_filter()->add_filtered_ids(1);
+  ASSERT_THAT(CallbackRegistration::FromProto(Model{}, registration_proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       AllOf(HasSubstr("mip_solution_filter"),
+                             HasSubstr("id: 1 not in model"))));
+}
+
+TEST(CallbackRegistrationTest, FromProtoInvalidMipNodeFilterId) {
+  CallbackRegistrationProto registration_proto;
+  registration_proto.mutable_mip_node_filter()->set_filter_by_ids(true);
+  registration_proto.mutable_mip_node_filter()->add_filtered_ids(1);
+  ASSERT_THAT(CallbackRegistration::FromProto(Model{}, registration_proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       AllOf(HasSubstr("mip_node_filter"),
+                             HasSubstr("id: 1 not in model"))));
+}
+
+TEST(CallbackResultTest, ProtoRoundtrip) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+
+  // Here we don't start with the proto, as below we also test
+  // AddLazyConstraint() and AddUserCut() behavior. We instead start with a
+  // CallbackResult and build an expected proto.
+  CallbackResult result;
+  result.terminate = true;
+  result.suggested_solutions.push_back({{x, 2.0}, {y, 3.0}});
+  result.suggested_solutions.push_back({{y, 5.5}});
+  result.AddLazyConstraint(x + y <= 2.0);
+  result.AddUserCut(y <= 1.0);
+  result.AddUserCut(-1.0 <= 2 * x + y);
+
+  CallbackResultProto expected_result_proto;
+  expected_result_proto.set_terminate(true);
+  {
+    CallbackResultProto::GeneratedLinearConstraint& cut =
+        *expected_result_proto.add_cuts();
+    cut.set_lower_bound(-kInf);
+    cut.set_upper_bound(2.0);
+    cut.set_is_lazy(true);
+    cut.mutable_linear_expression()->add_ids(0);
+    cut.mutable_linear_expression()->add_values(1.0);
+    cut.mutable_linear_expression()->add_ids(1);
+    cut.mutable_linear_expression()->add_values(1.0);
+  }
+  {
+    CallbackResultProto::GeneratedLinearConstraint& cut =
+        *expected_result_proto.add_cuts();
+    cut.set_lower_bound(-kInf);
+    cut.set_upper_bound(1.0);
+    cut.set_is_lazy(false);
+    cut.mutable_linear_expression()->add_ids(1);
+    cut.mutable_linear_expression()->add_values(1.0);
+  }
+  {
+    CallbackResultProto::GeneratedLinearConstraint& cut =
+        *expected_result_proto.add_cuts();
+    cut.set_lower_bound(-1.0);
+    cut.set_upper_bound(kInf);
+    cut.set_is_lazy(false);
+    cut.mutable_linear_expression()->add_ids(0);
+    cut.mutable_linear_expression()->add_values(2.0);
+    cut.mutable_linear_expression()->add_ids(1);
+    cut.mutable_linear_expression()->add_values(1.0);
+  }
+  {
+    SparseDoubleVectorProto& suggested_solution =
+        *expected_result_proto.add_suggested_solutions();
+    suggested_solution.add_ids(0);
+    suggested_solution.add_values(2.0);
+    suggested_solution.add_ids(1);
+    suggested_solution.add_values(3.0);
+  }
+  {
+    SparseDoubleVectorProto& suggested_solution =
+        *expected_result_proto.add_suggested_solutions();
+    suggested_solution.add_ids(1);
+    suggested_solution.add_values(5.5);
+  }
+
+  EXPECT_OK(result.CheckModelStorage(model.storage()));
+  EXPECT_THAT(result.Proto(), EqualsProto(expected_result_proto));
+
+  // Now test the round trip using the expected proto.
+  {
+    ASSERT_OK_AND_ASSIGN(
+        const CallbackResult result_from_proto,
+        CallbackResult::FromProto(model, expected_result_proto));
+    EXPECT_THAT(result_from_proto.Proto(), EqualsProto(expected_result_proto));
+  }
+}
+
+TEST(CallbackResultTest, MixedModels) {
+  ModelStorage storage_1;
+  const Variable x(&storage_1, storage_1.AddVariable("x"));
+  ModelStorage storage_2;
+  const Variable y(&storage_2, storage_2.AddVariable("y"));
+  CallbackResult result;
+  result.AddLazyConstraint(x <= 1.0);
+  result.suggested_solutions.push_back({{y, 1.0}});
+  EXPECT_THAT(result.CheckModelStorage(&storage_1),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(CallbackResultTest, FromProtoBadCutVariable) {
+  CallbackResultProto result_proto;
+  {
+    CallbackResultProto::GeneratedLinearConstraint& cut =
+        *result_proto.add_cuts();
+    cut.mutable_linear_expression()->add_ids(1);
+    cut.mutable_linear_expression()->add_values(1.0);
+  }
+  EXPECT_THAT(
+      CallbackResult::FromProto(Model{}, result_proto),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr("CallbackResultProto.cuts[0].linear_expression")));
+}
+
+TEST(CallbackResultTest, FromProtoBadSolutionVariable) {
+  CallbackResultProto result_proto;
+  {
+    SparseDoubleVectorProto& suggested_solution =
+        *result_proto.add_suggested_solutions();
+    suggested_solution.add_ids(1);
+    suggested_solution.add_values(5.5);
+  }
+  EXPECT_THAT(
+      CallbackResult::FromProto(Model{}, result_proto),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr("CallbackResultProto.suggested_solutions[0]")));
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/compute_infeasible_subsystem_result_test.cc b/ortools/math_opt/cpp/compute_infeasible_subsystem_result_test.cc
new file mode 100644
index 0000000000..d2c67468fa
--- /dev/null
+++ b/ortools/math_opt/cpp/compute_infeasible_subsystem_result_test.cc
@@ -0,0 +1,590 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/compute_infeasible_subsystem_result.h"
+
+#include <cstdint>
+#include <string>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/status_macros.h"
+#include "ortools/math_opt/constraints/indicator/indicator_constraint.h"
+#include "ortools/math_opt/constraints/quadratic/quadratic_constraint.h"
+#include "ortools/math_opt/constraints/second_order_cone/second_order_cone_constraint.h"
+#include "ortools/math_opt/constraints/sos/sos1_constraint.h"
+#include "ortools/math_opt/constraints/sos/sos2_constraint.h"
+#include "ortools/math_opt/cpp/enums.h"
+#include "ortools/math_opt/cpp/linear_constraint.h"
+#include "ortools/math_opt/cpp/matchers.h"
+#include "ortools/math_opt/cpp/model.h"
+#include "ortools/math_opt/cpp/solve_result.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/infeasible_subsystem.pb.h"
+#include "ortools/math_opt/result.pb.h"
+#include "ortools/math_opt/storage/model_storage.h"
+#include "ortools/math_opt/testing/stream.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::EqualsProto;
+using ::testing::HasSubstr;
+using ::testing::Pair;
+using ::testing::status::IsOkAndHolds;
+using ::testing::status::StatusIs;
+
+MATCHER_P2(ProtoBoundsAre, lower, upper, "") {
+  return arg.lower() == lower && arg.upper() == upper;
+}
+
+ModelSubsetProto::Bounds BuildBoundsProto(const bool lower, const bool upper) {
+  ModelSubsetProto::Bounds proto;
+  proto.set_lower(lower);
+  proto.set_upper(upper);
+  return proto;
+}
+
+TEST(ModelSubsetBoundsTest, FromProto) {
+  EXPECT_EQ(ModelSubset::Bounds::FromProto(ModelSubsetProto::Bounds()),
+            (ModelSubset::Bounds{.lower = false, .upper = false}));
+  EXPECT_EQ(ModelSubset::Bounds::FromProto(BuildBoundsProto(false, true)),
+            (ModelSubset::Bounds{.lower = false, .upper = true}));
+  EXPECT_EQ(ModelSubset::Bounds::FromProto(BuildBoundsProto(true, false)),
+            (ModelSubset::Bounds{.lower = true, .upper = false}));
+  EXPECT_EQ(ModelSubset::Bounds::FromProto(BuildBoundsProto(true, true)),
+            (ModelSubset::Bounds{.lower = true, .upper = true}));
+}
+
+TEST(ModelSubsetBoundsTest, Proto) {
+  EXPECT_THAT(ModelSubset::Bounds().Proto(), ProtoBoundsAre(false, false));
+  EXPECT_THAT((ModelSubset::Bounds{.lower = false, .upper = true}.Proto()),
+              ProtoBoundsAre(false, true));
+  EXPECT_THAT((ModelSubset::Bounds{.lower = true, .upper = false}.Proto()),
+              ProtoBoundsAre(true, false));
+  EXPECT_THAT((ModelSubset::Bounds{.lower = true, .upper = true}.Proto()),
+              ProtoBoundsAre(true, true));
+}
+
+TEST(ModelSubsetBoundsTest, Streaming) {
+  EXPECT_EQ(StreamToString(ModelSubset::Bounds()),
+            "{lower: false, upper: false}");
+  EXPECT_EQ((StreamToString(ModelSubset::Bounds{.lower = true, .upper = true})),
+            "{lower: true, upper: true}");
+}
+
+struct SimpleModel {
+  SimpleModel()
+      : var(model.AddVariable("var")),
+        lin(model.AddLinearConstraint("lin")),
+        quad(model.AddQuadraticConstraint(
+            BoundedQuadraticExpression{0.0, 0.0, 0.0}, "quad")),
+        soc(model.AddSecondOrderConeConstraint({}, 0.0, "soc")),
+        sos1(model.AddSos1Constraint({}, {}, "sos1")),
+        sos2(model.AddSos2Constraint({}, {}, "sos2")),
+        indicator(model.AddIndicatorConstraint(
+            var, BoundedLinearExpression{0.0, 0.0, 0.0}, false, "indicator")) {}
+
+  ModelSubset SimpleModelSubset() const {
+    ModelSubset model_subset;
+    {
+      const ModelSubset::Bounds bounds{.lower = true, .upper = false};
+      model_subset.variable_bounds[var] = bounds;
+      model_subset.linear_constraints[lin] = bounds;
+      model_subset.quadratic_constraints[quad] = bounds;
+    }
+    model_subset.variable_integrality.insert(var);
+    model_subset.second_order_cone_constraints.insert(soc);
+    model_subset.sos1_constraints.insert(sos1);
+    model_subset.sos2_constraints.insert(sos2);
+    model_subset.indicator_constraints.insert(indicator);
+    return model_subset;
+  }
+
+  ModelSubsetProto SimpleModelSubsetProto() const {
+    ModelSubsetProto proto;
+    {
+      ModelSubsetProto::Bounds bounds;
+      bounds.set_lower(true);
+      bounds.set_upper(false);
+      (*proto.mutable_variable_bounds())[var.id()] = bounds;
+      proto.add_variable_integrality(var.id());
+      (*proto.mutable_linear_constraints())[lin.id()] = bounds;
+      (*proto.mutable_quadratic_constraints())[quad.id()] = bounds;
+    }
+    proto.add_second_order_cone_constraints(soc.id());
+    proto.add_sos1_constraints(sos1.id());
+    proto.add_sos2_constraints(sos2.id());
+    proto.add_indicator_constraints(indicator.id());
+    return proto;
+  }
+
+  Model model;
+  Variable var;
+  LinearConstraint lin;
+  QuadraticConstraint quad;
+  SecondOrderConeConstraint soc;
+  Sos1Constraint sos1;
+  Sos2Constraint sos2;
+  IndicatorConstraint indicator;
+};
+
+TEST(ModelSubsetTest, ProtoEmptyOk) {
+  EXPECT_THAT(ModelSubset().Proto(), EqualsProto(ModelSubsetProto()));
+}
+
+TEST(ModelSubsetTest, ProtoSimpleOk) {
+  const SimpleModel model;
+  const ModelSubset model_subset = model.SimpleModelSubset();
+  const ModelSubsetProto proto = model_subset.Proto();
+  EXPECT_THAT(proto.variable_bounds(),
+              ElementsAre(Pair(model.var.id(), ProtoBoundsAre(true, false))));
+  EXPECT_THAT(proto.variable_integrality(), ElementsAre(model.var.id()));
+  EXPECT_THAT(proto.linear_constraints(),
+              ElementsAre(Pair(model.lin.id(), ProtoBoundsAre(true, false))));
+  EXPECT_THAT(proto.quadratic_constraints(),
+              ElementsAre(Pair(model.quad.id(), ProtoBoundsAre(true, false))));
+  EXPECT_THAT(proto.second_order_cone_constraints(),
+              ElementsAre(model.soc.id()));
+  EXPECT_THAT(proto.sos1_constraints(), ElementsAre(model.sos1.id()));
+  EXPECT_THAT(proto.sos2_constraints(), ElementsAre(model.sos2.id()));
+  EXPECT_THAT(proto.indicator_constraints(), ElementsAre(model.indicator.id()));
+}
+
+TEST(ModelSubsetTest, FromProtoEmptyOk) {
+  ModelStorage storage;
+  ASSERT_OK_AND_ASSIGN(const ModelSubset subset,
+                       ModelSubset::FromProto(&storage, ModelSubsetProto()));
+  EXPECT_TRUE(subset.empty());
+}
+
+TEST(ModelSubsetTest, FromProtoSimpleOk) {
+  const SimpleModel model;
+  ASSERT_OK_AND_ASSIGN(const ModelSubset subset,
+                       ModelSubset::FromProto(model.model.storage(),
+                                              model.SimpleModelSubsetProto()));
+  EXPECT_THAT(subset.variable_bounds,
+              ElementsAre(Pair(model.var, ModelSubset::Bounds{
+                                              .lower = true, .upper = false})));
+  EXPECT_THAT(subset.variable_integrality, ElementsAre(model.var));
+  EXPECT_THAT(subset.linear_constraints,
+              ElementsAre(Pair(model.lin, ModelSubset::Bounds{
+                                              .lower = true, .upper = false})));
+  EXPECT_THAT(
+      subset.quadratic_constraints,
+      ElementsAre(Pair(model.quad,
+                       ModelSubset::Bounds{.lower = true, .upper = false})));
+  EXPECT_THAT(subset.sos1_constraints, ElementsAre(model.sos1));
+  EXPECT_THAT(subset.sos2_constraints, ElementsAre(model.sos2));
+  EXPECT_THAT(subset.indicator_constraints, ElementsAre(model.indicator));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidVariableBounds) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  (*proto.mutable_variable_bounds())[2] = ModelSubsetProto::Bounds();
+  EXPECT_THAT(
+      ModelSubset::FromProto(&storage, proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("no variable")));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidVariableIntegrality) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  proto.add_variable_integrality(2);
+  EXPECT_THAT(
+      ModelSubset::FromProto(&storage, proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("no variable")));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidLinearConstraint) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  (*proto.mutable_linear_constraints())[2] = ModelSubsetProto::Bounds();
+  EXPECT_THAT(ModelSubset::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no linear constraint")));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidQuadraticConstraint) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  (*proto.mutable_quadratic_constraints())[2] = ModelSubsetProto::Bounds();
+  EXPECT_THAT(ModelSubset::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no quadratic constraint")));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidSecondOrderConeConstraint) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  proto.add_second_order_cone_constraints(2);
+  EXPECT_THAT(ModelSubset::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no second-order cone constraint")));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidSos1Constraint) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  proto.add_sos1_constraints(2);
+  EXPECT_THAT(ModelSubset::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no SOS1 constraint")));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidSos2Constraint) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  proto.add_sos2_constraints(2);
+  EXPECT_THAT(ModelSubset::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no SOS2 constraint")));
+}
+
+TEST(ModelSubsetTest, FromProtoInvalidIndicatorConstraint) {
+  ModelStorage storage;
+  ModelSubsetProto proto;
+  proto.add_indicator_constraints(2);
+  EXPECT_THAT(ModelSubset::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no indicator constraint")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageEmptyOk) {
+  ModelStorage storage;
+  EXPECT_OK(ModelSubset().CheckModelStorage(&storage));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageSimpleOk) {
+  SimpleModel model;
+  EXPECT_OK(model.SimpleModelSubset().CheckModelStorage(model.model.storage()));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadVariable) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.variable_bounds[model.var] = ModelSubset::Bounds{};
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("variable_bounds")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadVariableIntegrality) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.variable_integrality.insert(model.var);
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("variable_integrality")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadLinearConstraint) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.linear_constraints[model.lin] = ModelSubset::Bounds{};
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("linear_constraints")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadQuadraticConstraint) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.quadratic_constraints[model.quad] = ModelSubset::Bounds{};
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("quadratic_constraints")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadSecondOrderConeConstraint) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.second_order_cone_constraints.insert(model.soc);
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("second_order_cone_constraints")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadSos1Constraint) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.sos1_constraints.insert(model.sos1);
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("sos1_constraints")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadSos2Constraint) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.sos2_constraints.insert(model.sos2);
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("sos2_constraints")));
+}
+
+TEST(ModelSubsetTest, CheckModelStorageBadIndicatorConstraint) {
+  const SimpleModel model;
+  ModelSubset subset;
+  subset.indicator_constraints.insert(model.indicator);
+  const ModelStorage other;
+  EXPECT_THAT(subset.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("indicator_constraints")));
+}
+
+TEST(ModelSubsetTest, EmptyEmptyOk) { EXPECT_TRUE(ModelSubset().empty()); }
+
+TEST(ModelSubsetTest, EmptyWithVariableBounds) {
+  ModelSubset subset;
+  subset.variable_bounds[SimpleModel().var] = ModelSubset::Bounds{};
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, EmptyWithVariableIntegrality) {
+  ModelSubset subset;
+  subset.variable_integrality.insert(SimpleModel().var);
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, EmptyWithLinearConstraint) {
+  ModelSubset subset;
+  subset.linear_constraints[SimpleModel().lin] = ModelSubset::Bounds{};
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, EmptyWithQuadraticConstraint) {
+  ModelSubset subset;
+  subset.quadratic_constraints[SimpleModel().quad] = ModelSubset::Bounds{};
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, EmptyWithSocConstraint) {
+  ModelSubset subset;
+  subset.second_order_cone_constraints.insert(SimpleModel().soc);
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, EmptyWithSos1Constraint) {
+  ModelSubset subset;
+  subset.sos1_constraints.insert(SimpleModel().sos1);
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, EmptyWithSos2Constraint) {
+  ModelSubset subset;
+  subset.sos2_constraints.insert(SimpleModel().sos2);
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, EmptyWithIndicatorConstraint) {
+  ModelSubset subset;
+  subset.indicator_constraints.insert(SimpleModel().indicator);
+  EXPECT_FALSE(subset.empty());
+}
+
+TEST(ModelSubsetTest, ToStringEmptySubset) {
+  EXPECT_EQ(ModelSubset().ToString(),
+            R"subset(Model Subset:
+ Variable bounds:
+ Variable integrality:
+ Linear constraints:
+)subset");
+}
+
+TEST(ModelSubsetTest, ToStringSimpleSubset) {
+  EXPECT_EQ(SimpleModel().SimpleModelSubset().ToString(),
+            R"subset(Model Subset:
+ Variable bounds:
+  var: var ≤ inf
+ Variable integrality:
+  var
+ Linear constraints:
+  lin: 0 ≤ inf
+ Quadratic constraints:
+  quad: 0 ≥ 0
+ Second-order cone constraints:
+  soc: ||{}||₂ ≤ 0
+ SOS1 constraints:
+  sos1: {} is SOS1
+ SOS2 constraints:
+  sos2: {} is SOS2
+ Indicator constraints:
+  indicator: var = 1 ⇒ 0 = 0
+)subset");
+}
+
+TEST(ModelSubsetTest, ToStringBoundedConstraintWithEmptyBounds) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const ModelSubset subset{.variable_bounds = {{x, ModelSubset::Bounds{}}}};
+  EXPECT_EQ(subset.ToString(),
+            R"subset(Model Subset:
+ Variable bounds:
+ Variable integrality:
+ Linear constraints:
+)subset");
+}
+
+TEST(ModelSubsetTest, ToStringBoundedConstraintWithNonzeroExpressionOffset) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c =
+      model.AddLinearConstraint(BoundedLinearExpression(x + 1, 2, 3), "c");
+  const LinearConstraint d =
+      model.AddLinearConstraint(BoundedLinearExpression(x + 4, 5, 6), "d");
+  const ModelSubset subset{
+      .linear_constraints = {
+          {c, ModelSubset::Bounds{.lower = true, .upper = false}},
+          {d, ModelSubset::Bounds{.lower = false, .upper = true}}}};
+  EXPECT_EQ(subset.ToString(),
+            R"subset(Model Subset:
+ Variable bounds:
+ Variable integrality:
+ Linear constraints:
+  c: x ≥ 1
+  d: x ≤ 2
+)subset");
+}
+
+TEST(ModelSubsetTest, Streaming) {
+  EXPECT_EQ(StreamToString(ModelSubset()),
+            "{variable_bounds: {}, variable_integrality: {}, "
+            "linear_constraints: {}, quadratic_constraints: {}, "
+            "second_order_cone_constraints: {}, sos1_constraints: {}, "
+            "sos2_constraints: {}, indicator_constraints: {}}");
+  EXPECT_EQ(
+      StreamToString(SimpleModel().SimpleModelSubset()),
+      "{variable_bounds: {{var, {lower: true, upper: false}}}, "
+      "variable_integrality: {var}, linear_constraints: {{lin, {lower: true, "
+      "upper: false}}}, quadratic_constraints: {{quad, {lower: true, upper: "
+      "false}}}, second_order_cone_constraints: {soc}, sos1_constraints: "
+      "{sos1}, sos2_constraints: {sos2}, indicator_constraints: {indicator}}");
+  // We test only one "map-of-bounds" field (all use the same helper).
+  {
+    SimpleModel model;
+    ModelSubset subset = model.SimpleModelSubset();
+    const Variable x = model.model.AddVariable("x");
+    subset.variable_bounds.insert({x, {false, true}});
+    EXPECT_THAT(StreamToString(subset),
+                HasSubstr("{variable_bounds: {{var, {lower: true, upper: "
+                          "false}}, {x, {lower: false, upper: true}}}"));
+  }
+  // We test only one "set-of-repeated-IDs" field (all use the same helper).
+  {
+    SimpleModel model;
+    ModelSubset subset = model.SimpleModelSubset();
+    const Sos1Constraint c = model.model.AddSos1Constraint({}, {}, "c");
+    subset.sos1_constraints.insert(c);
+    EXPECT_THAT(StreamToString(subset),
+                HasSubstr("sos1_constraints: {sos1, c}"));
+  }
+}
+
+TEST(ComputeInfeasibleSubsystemResultTest, ProtoEmptyOk) {
+  ComputeInfeasibleSubsystemResultProto expected;
+  expected.set_feasibility(FEASIBILITY_STATUS_UNDETERMINED);
+  EXPECT_THAT(ComputeInfeasibleSubsystemResult{}.Proto(),
+              EqualsProto(expected));
+}
+
+TEST(ComputeInfeasibleSubsystemResultTest, ProtoSimpleOk) {
+  const SimpleModel model;
+  ComputeInfeasibleSubsystemResult result{
+      .feasibility = FeasibilityStatus::kInfeasible,
+      .infeasible_subsystem = model.SimpleModelSubset(),
+      .is_minimal = true};
+  ComputeInfeasibleSubsystemResultProto expected;
+  expected.set_feasibility(FEASIBILITY_STATUS_INFEASIBLE);
+  expected.set_is_minimal(true);
+  *expected.mutable_infeasible_subsystem() = model.SimpleModelSubsetProto();
+  EXPECT_THAT(result.Proto(), EqualsProto(expected));
+}
+
+TEST(ComputeInfeasibleSubsystemResultTest, FromProtoTrivialOk) {
+  ModelStorage storage;
+  ComputeInfeasibleSubsystemResultProto result_proto;
+  result_proto.set_feasibility(FEASIBILITY_STATUS_UNDETERMINED);
+  EXPECT_THAT(
+      ComputeInfeasibleSubsystemResult::FromProto(&storage, result_proto),
+      IsOkAndHolds(IsUndetermined()));
+}
+
+TEST(ComputeInfeasibleSubsystemResultTest, FromProtoSimpleOk) {
+  const SimpleModel model;
+  ComputeInfeasibleSubsystemResultProto result_proto;
+  result_proto.set_feasibility(FEASIBILITY_STATUS_INFEASIBLE);
+  result_proto.set_is_minimal(true);
+  *result_proto.mutable_infeasible_subsystem() = model.SimpleModelSubsetProto();
+  ASSERT_THAT(ComputeInfeasibleSubsystemResult::FromProto(model.model.storage(),
+                                                          result_proto),
+              IsOkAndHolds(IsInfeasible(/*expected_is_minimal=*/true,
+                                        model.SimpleModelSubset())));
+}
+
+// Integration test for ValidateInfeasibleSubsystemResultNoModel().
+TEST(ComputeInfeasibleSubsystemResultTest, FromProtoInvalidNoModel) {
+  ModelStorage storage;
+  EXPECT_THAT(ComputeInfeasibleSubsystemResult::FromProto(
+                  &storage, ComputeInfeasibleSubsystemResultProto{}),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("feasibility must be specified")));
+}
+
+TEST(ComputeInfeasibleSubsystemResultTest,
+     FromProtoInvalidInfeasibleSubsystem) {
+  ModelStorage storage;
+  ComputeInfeasibleSubsystemResultProto result_proto;
+  result_proto.set_feasibility(FEASIBILITY_STATUS_INFEASIBLE);
+  (*result_proto.mutable_infeasible_subsystem()->mutable_variable_bounds())[0];
+  EXPECT_THAT(
+      ComputeInfeasibleSubsystemResult::FromProto(&storage, result_proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("no variable")));
+}
+
+TEST(ComputeInfeasibleSubsystemResultTest, Streaming) {
+  EXPECT_EQ(
+      StreamToString(ComputeInfeasibleSubsystemResult()),
+      "{feasibility: undetermined, infeasible_subsystem: {variable_bounds: {}, "
+      "variable_integrality: {}, linear_constraints: {}, "
+      "quadratic_constraints: {}, "
+      "second_order_cone_constraints: {}, sos1_constraints: {}, "
+      "sos2_constraints: {}, indicator_constraints: {}}, is_minimal: false}");
+}
+
+TEST(ComputeInfeasibleSubsystemResultTest, CheckModelStorage) {
+  const SimpleModel model;
+  ComputeInfeasibleSubsystemResult result;
+  result.infeasible_subsystem.variable_bounds[model.var] =
+      ModelSubset::Bounds{};
+  const ModelStorage other;
+  EXPECT_THAT(result.CheckModelStorage(&other),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("variable_bounds")));
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/enums_test.cc b/ortools/math_opt/cpp/enums_test.cc
new file mode 100644
index 0000000000..bdc3b9688a
--- /dev/null
+++ b/ortools/math_opt/cpp/enums_test.cc
@@ -0,0 +1,132 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/enums.h"
+
+#include <optional>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/logging.h"
+#include "ortools/math_opt/cpp/enums_test.pb.h"
+#include "ortools/math_opt/cpp/enums_testing.h"
+#include "ortools/math_opt/testing/stream.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+enum class TestEnum {
+  kFirstValue = TEST_ENUM_FIRST_VALUE,
+  kSecondValue = TEST_ENUM_SECOND_VALUE
+};
+
+}  // namespace
+
+// Template specialization must be in the same namespace. It can't be in the
+// anonymous namespace.
+MATH_OPT_DEFINE_ENUM(TestEnum, TEST_ENUM_UNSPECIFIED);
+
+std::optional<absl::string_view> Enum<TestEnum>::ToOptString(TestEnum value) {
+  switch (value) {
+    case TestEnum::kFirstValue:
+      return "first_value";
+    case TestEnum::kSecondValue:
+      return "second_value";
+  }
+  return std::nullopt;
+}
+
+absl::Span<const TestEnum> Enum<TestEnum>::AllValues() {
+  static constexpr TestEnum kTestEnumValues[] = {TestEnum::kFirstValue,
+                                                 TestEnum::kSecondValue};
+
+  return absl::MakeConstSpan(kTestEnumValues);
+}
+
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::Optional;
+
+TEST(EnumsTest, EnumToProtoWithOptional) {
+  std::optional<TestEnum> opt_value = TestEnum::kFirstValue;
+  EXPECT_EQ(EnumToProto(opt_value), TEST_ENUM_FIRST_VALUE);
+  EXPECT_EQ(EnumToProto<TestEnum>(std::nullopt), TEST_ENUM_UNSPECIFIED);
+}
+
+TEST(EnumsTest, EnumToProtoWithValue) {
+  EXPECT_EQ(EnumToProto(TestEnum::kFirstValue), TEST_ENUM_FIRST_VALUE);
+  EXPECT_EQ(EnumToProto(TestEnum::kSecondValue), TEST_ENUM_SECOND_VALUE);
+}
+
+TEST(EnumsTest, FromProto) {
+  EXPECT_THAT(EnumFromProto(TEST_ENUM_FIRST_VALUE),
+              Optional(TestEnum::kFirstValue));
+  EXPECT_THAT(EnumFromProto(TEST_ENUM_SECOND_VALUE),
+              Optional(TestEnum::kSecondValue));
+  EXPECT_EQ(EnumFromProto(TEST_ENUM_UNSPECIFIED), std::nullopt);
+}
+
+TEST(EnumsTest, EnumToOptString) {
+  EXPECT_THAT(EnumToOptString(TestEnum::kFirstValue),
+              Optional(absl::string_view("first_value")));
+  EXPECT_THAT(EnumToOptString(TestEnum::kSecondValue),
+              Optional(absl::string_view("second_value")));
+  EXPECT_EQ(EnumToOptString(static_cast<TestEnum>(-15)), std::nullopt);
+}
+
+TEST(EnumsTest, EnumToString) {
+  EXPECT_THAT(EnumToString(TestEnum::kFirstValue), "first_value");
+  EXPECT_THAT(EnumToString(TestEnum::kSecondValue), "second_value");
+}
+
+TEST(EnumsDeathTest, EnumToString) {
+  EXPECT_DEATH_IF_SUPPORTED(EnumToString(static_cast<TestEnum>(-15)),
+                            "invalid value: -15");
+}
+
+TEST(EnumsTest, EnumFromString) {
+  EXPECT_THAT(EnumFromString<TestEnum>("first_value"),
+              Optional(TestEnum::kFirstValue));
+  EXPECT_THAT(EnumFromString<TestEnum>("second_value"),
+              Optional(TestEnum::kSecondValue));
+  EXPECT_EQ(EnumFromString<TestEnum>("unknown"), std::nullopt);
+}
+
+TEST(EnumsTest, AllValues) {
+  EXPECT_THAT(Enum<TestEnum>::AllValues(),
+              ElementsAre(TestEnum::kFirstValue, TestEnum::kSecondValue));
+}
+
+TEST(EnumsTest, Stream) {
+  EXPECT_EQ(StreamToString(TestEnum::kFirstValue), "first_value");
+  EXPECT_EQ(StreamToString(static_cast<TestEnum>(-15)), "<invalid enum (-15)>");
+}
+
+TEST(EnumsTest, OptStream) {
+  EXPECT_EQ(StreamToString(std::make_optional(TestEnum::kFirstValue)),
+            "first_value");
+  EXPECT_EQ(StreamToString(std::make_optional(static_cast<TestEnum>(-15))),
+            "<invalid enum (-15)>");
+  EXPECT_EQ(StreamToString(std::optional<TestEnum>()), "<unspecified>");
+}
+
+INSTANTIATE_TYPED_TEST_SUITE_P(TestEnum, EnumTest, TestEnum);
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/base/ptr_util.h b/ortools/math_opt/cpp/enums_test.proto
similarity index 66%
rename from ortools/base/ptr_util.h
rename to ortools/math_opt/cpp/enums_test.proto
index e77bac435d..d8c60cf4a7 100644
--- a/ortools/base/ptr_util.h
+++ b/ortools/math_opt/cpp/enums_test.proto
@@ -11,9 +11,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef OR_TOOLS_BASE_PTR_UTIL_H_
-#define OR_TOOLS_BASE_PTR_UTIL_H_
+syntax = "proto3";
 
-#include <limits.h>
+package operations_research.math_opt;
 
-#endif  // OR_TOOLS_BASE_PTR_UTIL_H_
+// Proto enum used in the unit tests of enums.h.
+enum TestEnumProto {
+  TEST_ENUM_UNSPECIFIED = 0;
+
+  TEST_ENUM_FIRST_VALUE = 1;
+
+  // We intentionally have a gap in values to test this case.
+  reserved 2;
+
+  TEST_ENUM_SECOND_VALUE = 3;
+}
diff --git a/ortools/math_opt/cpp/formatters_test.cc b/ortools/math_opt/cpp/formatters_test.cc
new file mode 100644
index 0000000000..c347f620cd
--- /dev/null
+++ b/ortools/math_opt/cpp/formatters_test.cc
@@ -0,0 +1,137 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/formatters.h"
+
+#include <cmath>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "ortools/math_opt/testing/stream.h"
+#include "ortools/util/fp_roundtrip_conv_testing.h"
+#include "util/gtl/extend/debug_printing.h"
+#include "util/gtl/extend/equality.h"
+#include "util/gtl/extend/extend.h"
+
+namespace operations_research::math_opt {
+
+namespace {
+
+struct FormattersTestCase
+    : gtl::Extend<FormattersTestCase>::With<gtl::EqualityExtension,
+                                            gtl::DebugPrintingExtension> {
+  const std::string test_name;
+  const double x;
+  const bool is_first;
+  const std::string expected_leading_coefficient;
+  const std::string expected_constant_term;
+};
+
+using FormattersTest = testing::TestWithParam<FormattersTestCase>;
+
+TEST_P(FormattersTest, LeadingCoefficientFormatter) {
+  const FormattersTestCase& test_case = GetParam();
+  EXPECT_EQ(StreamToString(
+                LeadingCoefficientFormatter(test_case.x, test_case.is_first)),
+            test_case.expected_leading_coefficient);
+}
+
+TEST_P(FormattersTest, ConstantFormatter) {
+  const FormattersTestCase& test_case = GetParam();
+  EXPECT_EQ(StreamToString(ConstantFormatter(test_case.x, test_case.is_first)),
+            test_case.expected_constant_term);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    FormattersTests, FormattersTest,
+    testing::ValuesIn<FormattersTestCase>(
+        {{.test_name = "positive",
+          .x = 1.2,
+          .is_first = false,
+          .expected_leading_coefficient = " + 1.2*",
+          .expected_constant_term = " + 1.2"},
+         {.test_name = "positive_first",
+          .x = 1.2,
+          .is_first = true,
+          .expected_leading_coefficient = "1.2*",
+          .expected_constant_term = "1.2"},
+         {.test_name = "negative",
+          .x = -4,
+          .is_first = false,
+          .expected_leading_coefficient = " - 4*",
+          .expected_constant_term = " - 4"},
+         {.test_name = "negative_first",
+          .x = -4.35,
+          .is_first = true,
+          .expected_leading_coefficient = "-4.35*",
+          .expected_constant_term = "-4.35"},
+         {.test_name = "one",
+          .x = 1,
+          .is_first = false,
+          .expected_leading_coefficient = " + ",
+          .expected_constant_term = " + 1"},
+         {.test_name = "one_first",
+          .x = 1,
+          .is_first = true,
+          .expected_leading_coefficient = "",
+          .expected_constant_term = "1"},
+         {.test_name = "minus_one",
+          .x = -1,
+          .is_first = false,
+          .expected_leading_coefficient = " - ",
+          .expected_constant_term = " - 1"},
+         {.test_name = "minus_one_first",
+          .x = -1,
+          .is_first = true,
+          .expected_leading_coefficient = "-",
+          .expected_constant_term = "-1"},
+         {.test_name = "zero",
+          .x = 0,
+          .is_first = false,
+          .expected_leading_coefficient = " + 0*",
+          .expected_constant_term = ""},
+         {.test_name = "zero_first",
+          .x = 0,
+          .is_first = true,
+          .expected_leading_coefficient = "0*",
+          .expected_constant_term = "0"},
+         {.test_name = "nan",
+          .x = std::nan(""),
+          .is_first = false,
+          .expected_leading_coefficient = " + nan*",
+          .expected_constant_term = " + nan"},
+         {.test_name = "nan_first",
+          .x = std::nan(""),
+          .is_first = true,
+          .expected_leading_coefficient = "nan*",
+          .expected_constant_term = "nan"},
+         {.test_name = "fp_roundtrip",
+          .x = kRoundTripTestNumber,
+          .is_first = false,
+          .expected_leading_coefficient =
+              absl::StrCat(" + ", kRoundTripTestNumberStr, "*"),
+          .expected_constant_term = absl::StrCat(" + ",
+                                                 kRoundTripTestNumberStr)},
+         {.test_name = "fp_roundtrip_true",
+          .x = kRoundTripTestNumber,
+          .is_first = true,
+          .expected_leading_coefficient = absl::StrCat(kRoundTripTestNumberStr,
+                                                       "*"),
+          .expected_constant_term = std::string(kRoundTripTestNumberStr)}}),
+    [](const testing::TestParamInfo<FormattersTest::ParamType>& info) {
+      return info.param.test_name;
+    });
+
+}  // namespace
+
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/key_types.h b/ortools/math_opt/cpp/key_types.h
index df72faad6a..5ceec1dd80 100644
--- a/ortools/math_opt/cpp/key_types.h
+++ b/ortools/math_opt/cpp/key_types.h
@@ -149,17 +149,17 @@ std::vector<typename Map::mapped_type> Values(const Map& map,
 namespace internal {
 
 // The CHECK message to use when a KeyType::storage() is nullptr.
-inline constexpr const char kKeyHasNullModelStorage[] =
+inline constexpr absl::string_view kKeyHasNullModelStorage =
     "The input key has null .storage().";
 
 // The CHECK message to use when two KeyType with different storage() are used
 // in the same collection.
-inline constexpr const char kObjectsFromOtherModelStorage[] =
+inline constexpr absl::string_view kObjectsFromOtherModelStorage =
     "The input objects belongs to another model.";
 
 // The Status message to use when an input KeyType is from an unexpected
 // storage().
-inline constexpr const char kInputFromInvalidModelStorage[] =
+inline constexpr absl::string_view kInputFromInvalidModelStorage =
     "the input does not belong to the same model";
 
 // Returns a failure when the input pointer is not nullptr and points to a
diff --git a/ortools/math_opt/cpp/key_types_test.cc b/ortools/math_opt/cpp/key_types_test.cc
new file mode 100644
index 0000000000..7b79d247ed
--- /dev/null
+++ b/ortools/math_opt/cpp/key_types_test.cc
@@ -0,0 +1,165 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/key_types.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
+#include "benchmark/benchmark.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/storage/model_storage.h"
+
+namespace operations_research::math_opt::internal {
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::status::StatusIs;
+
+TEST(CheckModelStorageTest, NullExpected) {
+  ModelStorage model;
+  // The compiler will prevent us from passing nullptr to a function expecting
+  // a `ModelStorageCPtr`. So we launder the `nullptr` to test the behavior of
+  // `CheckModelStorage()` in that case.
+  ModelStorage* laundered_nullptr = nullptr;
+  benchmark::DoNotOptimize(laundered_nullptr);
+  EXPECT_THAT(
+      CheckModelStorage(/*storage=*/nullptr,
+                        /*expected_storage=*/laundered_nullptr),
+      StatusIs(absl::StatusCode::kInternal, HasSubstr("expected_storage")));
+  EXPECT_THAT(
+      CheckModelStorage(/*storage=*/&model,
+                        /*expected_storage=*/laundered_nullptr),
+      StatusIs(absl::StatusCode::kInternal, HasSubstr("expected_storage")));
+}
+
+TEST(CheckModelStorageTest, SingleModel) {
+  ModelStorage model;
+  EXPECT_OK(CheckModelStorage(/*storage=*/nullptr,
+                              /*expected_storage=*/&model));
+  EXPECT_OK(CheckModelStorage(/*storage=*/&model,
+                              /*expected_storage=*/&model));
+}
+
+TEST(CheckModelStorageTest, TwoModels) {
+  ModelStorage model_a;
+  ModelStorage model_b;
+  EXPECT_THAT(CheckModelStorage(/*storage=*/&model_a,
+                                /*expected_storage=*/&model_b),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       kInputFromInvalidModelStorage));
+}
+
+TEST(SortedKeysTest, EmptyFlatHashMap) {
+  const absl::flat_hash_map<Variable, double> vmap;
+  EXPECT_THAT(SortedKeys(vmap), IsEmpty());
+}
+
+TEST(SortedKeysTest, MultipleModelsFlatHashMap) {
+  // Here we use std::make_unique<> instead of using the stack as using the
+  // stack may for the order of the pointers on each model.
+  const auto model_1 = std::make_unique<ModelStorage>();
+  const Variable first1(model_1.get(), model_1->AddVariable("first1"));
+  const Variable second1(model_1.get(), model_1->AddVariable("second1"));
+  const Variable third1(model_1.get(), model_1->AddVariable("third1"));
+  const Variable fourth1(model_1.get(), model_1->AddVariable("fourth1"));
+
+  const auto model_2 = std::make_unique<ModelStorage>();
+  const Variable first2(model_2.get(), model_2->AddVariable("first2"));
+  const Variable second2(model_2.get(), model_2->AddVariable("second2"));
+  const Variable third2(model_2.get(), model_2->AddVariable("third2"));
+  const Variable fourth2(model_2.get(), model_2->AddVariable("fourth2"));
+
+  const absl::flat_hash_map<Variable, double> vmap = {
+      {second1, 3.0}, {third1, 5.0},  {second2, -3.5}, {fourth1, 0.0},
+      {third2, 8.0},  {first2, 1.25}, {fourth2, 12.0}, {first1, -5.0},
+  };
+
+  // The sort order between models depends on the pointer values.
+  if (model_1 < model_2) {
+    EXPECT_THAT(SortedKeys(vmap),
+                ElementsAre(first1, second1, third1, fourth1, first2, second2,
+                            third2, fourth2));
+  } else {
+    EXPECT_THAT(SortedKeys(vmap),
+                ElementsAre(first2, second2, third2, fourth2, first1, second1,
+                            third1, fourth1));
+  }
+}
+
+TEST(SortedElementsTest, EmptyFlatHashSet) {
+  const absl::flat_hash_set<Variable> vset;
+  EXPECT_THAT(SortedElements(vset), IsEmpty());
+}
+
+TEST(SortedElementsTest, MultipleModelsFlatHashSet) {
+  // Here we use std::make_unique<> instead of using the stack as using the
+  // stack may for the order of the pointers on each model.
+  const auto model_1 = std::make_unique<ModelStorage>();
+  const Variable first1(model_1.get(), model_1->AddVariable("first1"));
+  const Variable second1(model_1.get(), model_1->AddVariable("second1"));
+  const Variable third1(model_1.get(), model_1->AddVariable("third1"));
+  const Variable fourth1(model_1.get(), model_1->AddVariable("fourth1"));
+
+  const auto model_2 = std::make_unique<ModelStorage>();
+  const Variable first2(model_2.get(), model_2->AddVariable("first2"));
+  const Variable second2(model_2.get(), model_2->AddVariable("second2"));
+  const Variable third2(model_2.get(), model_2->AddVariable("third2"));
+  const Variable fourth2(model_2.get(), model_2->AddVariable("fourth2"));
+
+  const absl::flat_hash_set<Variable> vset = {second1, third1, second2, fourth1,
+                                              third2,  first2, fourth2, first1};
+
+  // The sort order between models depends on the pointer values.
+  if (model_1 < model_2) {
+    EXPECT_THAT(SortedElements(vset),
+                ElementsAre(first1, second1, third1, fourth1, first2, second2,
+                            third2, fourth2));
+  } else {
+    EXPECT_THAT(SortedElements(vset),
+                ElementsAre(first2, second2, third2, fourth2, first1, second1,
+                            third1, fourth1));
+  }
+}
+
+TEST(ValuesTest, MultipleModelsFlatHashMap) {
+  ModelStorage model_1;
+  const Variable first1(&model_1, model_1.AddVariable("first1"));
+  const Variable second1(&model_1, model_1.AddVariable("second1"));
+  const Variable third1(&model_1, model_1.AddVariable("third1"));
+  const Variable fourth1(&model_1, model_1.AddVariable("fourth1"));
+
+  ModelStorage model_2;
+  const Variable first2(&model_2, model_2.AddVariable("first2"));
+  const Variable second2(&model_2, model_2.AddVariable("second2"));
+  const Variable third2(&model_2, model_2.AddVariable("third2"));
+  const Variable fourth2(&model_2, model_2.AddVariable("fourth2"));
+
+  const absl::flat_hash_map<Variable, double> vmap = {
+      {second1, 3.0}, {third1, 5.0},  {second2, -3.5}, {fourth1, 0.0},
+      {third2, 8.0},  {first2, 1.25}, {fourth2, 12.0}, {first1, -5.0},
+  };
+
+  const std::vector<Variable> vars = {second2, first1, fourth2};
+  EXPECT_THAT(Values(vmap, vars), ElementsAre(-3.5, -5.0, 12.0));
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt::internal
diff --git a/ortools/math_opt/cpp/linear_constraint_test.cc b/ortools/math_opt/cpp/linear_constraint_test.cc
new file mode 100644
index 0000000000..df493fd476
--- /dev/null
+++ b/ortools/math_opt/cpp/linear_constraint_test.cc
@@ -0,0 +1,205 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/linear_constraint.h"
+
+#include <limits>
+#include <sstream>
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/strong_int.h"
+#include "ortools/math_opt/constraints/util/model_util.h"
+#include "ortools/math_opt/cpp/matchers.h"
+#include "ortools/math_opt/cpp/model.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/storage/model_storage.h"
+#include "ortools/math_opt/storage/model_storage_types.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+using ::testing::Pair;
+using ::testing::UnorderedElementsAre;
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+TEST(LinearConstraintTest, OutputStreaming) {
+  ModelStorage storage;
+  const LinearConstraint c(&storage, storage.AddLinearConstraint("c"));
+  const LinearConstraint anonymous(&storage, storage.AddLinearConstraint());
+
+  auto to_string = [](LinearConstraint c) {
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(c), "c");
+  EXPECT_EQ(to_string(anonymous),
+            absl::StrCat("__lin_con#", anonymous.id(), "__"));
+}
+
+TEST(LinearConstraintTest, Accessors) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Variable y(&storage, storage.AddVariable("y"));
+  {
+    const LinearConstraintId c_id = storage.AddLinearConstraint(
+        /*lower_bound=*/-kInf, /*upper_bound=*/1.5, "upper_bounded");
+    const LinearConstraint c(&storage, c_id);
+    storage.set_linear_constraint_coefficient(c_id, x.typed_id(), 1.0);
+    storage.set_linear_constraint_coefficient(c_id, y.typed_id(), 1.0);
+
+    EXPECT_EQ(c.name(), "upper_bounded");
+    EXPECT_EQ(c.id(), c_id.value());
+    EXPECT_EQ(c.typed_id(), c_id);
+    EXPECT_EQ(c.lower_bound(), -kInf);
+    EXPECT_EQ(c.upper_bound(), 1.5);
+
+    EXPECT_DOUBLE_EQ(c.coefficient(x), 1.0);
+    EXPECT_DOUBLE_EQ(c.coefficient(y), 1.0);
+
+    EXPECT_TRUE(c.is_coefficient_nonzero(x));
+    EXPECT_TRUE(c.is_coefficient_nonzero(y));
+  }
+  {
+    const LinearConstraintId c_id = storage.AddLinearConstraint(
+        /*lower_bound=*/0.5, /*upper_bound=*/kInf, "lower_bounded");
+    const LinearConstraint c(&storage, c_id);
+    storage.set_linear_constraint_coefficient(c_id, y.typed_id(), 2.0);
+
+    EXPECT_EQ(c.name(), "lower_bounded");
+    EXPECT_EQ(c.id(), 1);
+    EXPECT_EQ(c.lower_bound(), 0.5);
+    EXPECT_EQ(c.upper_bound(), kInf);
+
+    EXPECT_DOUBLE_EQ(c.coefficient(x), 0.0);
+    EXPECT_DOUBLE_EQ(c.coefficient(y), 2.0);
+
+    EXPECT_FALSE(c.is_coefficient_nonzero(x));
+    EXPECT_TRUE(c.is_coefficient_nonzero(y));
+  }
+}
+
+TEST(LinearConstraintTest, AsBoundedExpression) {
+  // We don't use the IsNearlyEquivalent(BoundedLinearExpression) matcher in
+  // tests as we want to test that the offset of
+  // BoundedLinearExpression.expression is indeed 0 in returned values.
+
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  {
+    const LinearConstraint c = model.AddLinearConstraint(
+        /*lower_bound=*/-kInf, /*upper_bound=*/1.5, "upper_bounded");
+    model.set_coefficient(c, x, 1.0);
+    model.set_coefficient(c, y, 2.0);
+
+    const BoundedLinearExpression c_bounded_expr =
+        c.AsBoundedLinearExpression();
+    EXPECT_EQ(c_bounded_expr.lower_bound, -kInf);
+    EXPECT_EQ(c_bounded_expr.upper_bound, 1.5);
+    EXPECT_THAT(c_bounded_expr.expression, IsIdentical(x + 2.0 * y));
+  }
+  {
+    const LinearConstraint c = model.AddLinearConstraint(
+        /*lower_bound=*/0.5, /*upper_bound=*/kInf, "lower_bounded");
+    model.set_coefficient(c, y, 2.0);
+
+    const BoundedLinearExpression c_bounded_expr =
+        c.AsBoundedLinearExpression();
+    EXPECT_EQ(c_bounded_expr.lower_bound, 0.5);
+    EXPECT_EQ(c_bounded_expr.upper_bound, kInf);
+    // TODO(b/290378193): remove the `+ 0.0` when the IsIdentical() overload
+    // issue is fixed (see bug for details).
+    EXPECT_THAT(c_bounded_expr.expression, IsIdentical(2.0 * y + 0.0));
+  }
+  {
+    const LinearConstraint c =
+        model.AddLinearConstraint(3.5 <= 5.0 * x + 2.0 * y + 1.0 <= 4.25);
+    const BoundedLinearExpression c_bounded_expr =
+        c.AsBoundedLinearExpression();
+    EXPECT_EQ(c_bounded_expr.lower_bound, 3.5 - 1.0);
+    EXPECT_EQ(c_bounded_expr.upper_bound, 4.25 - 1.0);
+    EXPECT_THAT(c_bounded_expr.expression, IsIdentical(5.0 * x + 2.0 * y));
+  }
+}
+
+TEST(LinearConstraintTest, ToString) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+
+  const LinearConstraint c =
+      model.AddLinearConstraint(1.0 <= -2 * x + 3 * y + 4.0 <= 5.0);
+  EXPECT_EQ(c.ToString(), "-3 ≤ -2*x + 3*y ≤ 1");
+
+  model.DeleteVariable(x);
+  EXPECT_EQ(c.ToString(), "-3 ≤ 3*y ≤ 1");
+}
+
+TEST(LinearConstraintTest, Equality) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Variable y(&storage, storage.AddVariable("y"));
+
+  const LinearConstraint c(&storage, storage.AddLinearConstraint(
+                                         /*lower_bound=*/-kInf,
+                                         /*upper_bound=*/1.5, "upper_bounded"));
+  storage.set_linear_constraint_coefficient(c.typed_id(), x.typed_id(), 1.0);
+  storage.set_linear_constraint_coefficient(c.typed_id(), y.typed_id(), 1.0);
+
+  const LinearConstraint d(
+      &storage,
+      storage.AddLinearConstraint(/*lower_bound=*/0.5,
+                                  /*upper_bound=*/kInf, "lower_bounded"));
+  storage.set_linear_constraint_coefficient(d.typed_id(), y.typed_id(), 2.0);
+
+  // `d2` is another `LinearConstraint` that points the same constraint in the
+  // indexed storage. It should compares == to `d`.
+  const LinearConstraint d2(d.storage(), d.typed_id());
+
+  // `e` has identical data as `d`. It should not compares equal to `d` tough.
+  const LinearConstraint e(
+      &storage,
+      storage.AddLinearConstraint(/*lower_bound=*/0.5,
+                                  /*upper_bound=*/kInf, "lower_bounded"));
+  storage.set_linear_constraint_coefficient(d.typed_id(), y.typed_id(), 2.0);
+
+  EXPECT_TRUE(c == c);
+  EXPECT_FALSE(c == d);
+  EXPECT_TRUE(d == d2);
+  EXPECT_FALSE(d == e);
+  EXPECT_FALSE(c != c);
+  EXPECT_TRUE(c != d);
+  EXPECT_FALSE(d != d2);
+  EXPECT_TRUE(d != e);
+}
+
+TEST(LinearConstraintTest, NameAfterDeletion) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint(2 * x >= 1, "c");
+  ASSERT_EQ(c.name(), "c");
+
+  model.DeleteLinearConstraint(c);
+  EXPECT_EQ(c.name(), kDeletedConstraintDefaultDescription);
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/map_filter_test.cc b/ortools/math_opt/cpp/map_filter_test.cc
new file mode 100644
index 0000000000..1a8e1d7a3d
--- /dev/null
+++ b/ortools/math_opt/cpp/map_filter_test.cc
@@ -0,0 +1,331 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/map_filter.h"
+
+#include <optional>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/linear_constraint.h"
+#include "ortools/math_opt/cpp/model.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+#include "ortools/math_opt/storage/model_storage.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+using ::testing::EquivToProto;
+using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::Optional;
+using ::testing::UnorderedElementsAre;
+using ::testing::status::StatusIs;
+
+TEST(MapFilterTest, VariableDefault) {
+  const ModelStorage model;
+  const MapFilter<Variable> filter;
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_EQ(filter.filtered_keys, std::nullopt);
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  EXPECT_THAT(filter.Proto(), EquivToProto(""));
+}
+
+TEST(MapFilterTest, LinearConstraintDefault) {
+  const ModelStorage model;
+  const MapFilter<LinearConstraint> filter;
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_EQ(filter.filtered_keys, std::nullopt);
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  EXPECT_THAT(filter.Proto(), EquivToProto(""));
+}
+
+TEST(MapFilterTest, SkipZeros) {
+  const ModelStorage model;
+
+  // Setting skip_zero_values to true.
+  MapFilter<Variable> filter;
+  filter.skip_zero_values = true;
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  EXPECT_THAT(filter.Proto(), EquivToProto(R"pb(skip_zero_values: true)pb"));
+
+  // Setting skip_zero_values to false.
+  filter.skip_zero_values = false;
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  EXPECT_THAT(filter.Proto(), EquivToProto(R"pb(skip_zero_values: false)pb"));
+}
+
+TEST(MapFilterTest, SetEmptyFilteredKeys) {
+  const ModelStorage model;
+  MapFilter<Variable> filter;
+  filter.filtered_keys.emplace();
+
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  EXPECT_THAT(filter.Proto(), EquivToProto(R"pb(filter_by_ids: true)pb"));
+}
+
+TEST(MapFilterTest, SetFilteredKeysWithInitializerList) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+  const Variable b(&model, model.AddVariable("b"));
+  const Variable c(&model, model.AddVariable("c"));
+
+  MapFilter<Variable> filter;
+  filter.filtered_keys = {a, c};
+
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  SparseVectorFilterProto expected;
+  expected.set_filter_by_ids(true);
+  expected.add_filtered_ids(a.id());
+  expected.add_filtered_ids(c.id());
+  EXPECT_THAT(filter.Proto(), EquivToProto(expected));
+}
+
+TEST(MapFilterTest, SetFilteredKeysWithVector) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+  const Variable b(&model, model.AddVariable("b"));
+  const Variable c(&model, model.AddVariable("c"));
+
+  MapFilter<Variable> filter;
+  const std::vector<Variable> vars = {a, c};
+  filter.filtered_keys.emplace(vars.begin(), vars.end());
+
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  SparseVectorFilterProto expected;
+  expected.set_filter_by_ids(true);
+  expected.add_filtered_ids(a.id());
+  expected.add_filtered_ids(c.id());
+  EXPECT_THAT(filter.Proto(), EquivToProto(expected));
+}
+
+TEST(MapFilterTest, CheckModelStorageWithMixedModels) {
+  ModelStorage model_1;
+  const Variable a(&model_1, model_1.AddVariable("a"));
+  const Variable b(&model_1, model_1.AddVariable("b"));
+
+  ModelStorage model_2;
+  const Variable c(&model_2, model_2.AddVariable("c"));
+
+  MapFilter<Variable> filter;
+  const std::vector<Variable> vars = {a, c};
+  filter.filtered_keys = {a, c};
+
+  EXPECT_THAT(filter.CheckModelStorage(&model_1),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(MapFilterTest, UnsetNonEmptyFilteredKeys) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+  const Variable b(&model, model.AddVariable("b"));
+  const Variable c(&model, model.AddVariable("c"));
+
+  MapFilter<Variable> filter;
+  filter.filtered_keys = {a, b, c};
+  filter.filtered_keys.reset();
+
+  EXPECT_OK(filter.CheckModelStorage(&model));
+  EXPECT_THAT(filter.Proto(), EquivToProto(""));
+}
+
+TEST(MakeSkipAllFilterTest, Variables) {
+  const auto filter = MakeSkipAllFilter<Variable>();
+  EXPECT_THAT(filter.Proto(), EquivToProto(R"pb(filter_by_ids: true)pb"));
+}
+
+TEST(MakeSkipZerosFilterTest, Variables) {
+  const auto filter = MakeSkipZerosFilter<Variable>();
+  EXPECT_THAT(filter.Proto(), EquivToProto(R"pb(skip_zero_values: true)pb"));
+}
+
+TEST(MakeKeepKeysFilterTest, Vector) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+  const Variable b(&model, model.AddVariable("b"));
+  const Variable c(&model, model.AddVariable("c"));
+
+  const std::vector<Variable> vars = {a, c};
+  const auto filter = MakeKeepKeysFilter(vars);
+
+  SparseVectorFilterProto expected;
+  expected.set_filter_by_ids(true);
+  expected.add_filtered_ids(a.id());
+  expected.add_filtered_ids(c.id());
+
+  EXPECT_THAT(filter.Proto(), EquivToProto(expected));
+}
+
+TEST(MakeKeepKeysFilterTest, InitializerList) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+  const Variable b(&model, model.AddVariable("b"));
+  const Variable c(&model, model.AddVariable("c"));
+
+  const auto filter = MakeKeepKeysFilter({a, c});
+
+  SparseVectorFilterProto expected;
+  expected.set_filter_by_ids(true);
+  expected.add_filtered_ids(a.id());
+  expected.add_filtered_ids(c.id());
+
+  EXPECT_THAT(filter.Proto(), EquivToProto(expected));
+}
+
+TEST(VariableFilterFromProtoTest, EmptyFilter) {
+  Model model;
+  SparseVectorFilterProto proto;
+  ASSERT_OK_AND_ASSIGN(MapFilter<Variable> filter,
+                       VariableFilterFromProto(model, proto));
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_EQ(filter.filtered_keys, std::nullopt);
+}
+
+TEST(VariableFilterFromProtoTest, NonemptyFilter) {
+  Model model;
+  Variable x = model.AddBinaryVariable();
+  model.AddBinaryVariable();
+  Variable z = model.AddBinaryVariable();
+  SparseVectorFilterProto proto;
+  proto.set_skip_zero_values(true);
+  proto.set_filter_by_ids(true);
+  proto.add_filtered_ids(0);
+  proto.add_filtered_ids(2);
+  ASSERT_OK_AND_ASSIGN(MapFilter<Variable> filter,
+                       VariableFilterFromProto(model, proto));
+  EXPECT_TRUE(filter.skip_zero_values);
+  EXPECT_THAT(filter.filtered_keys, Optional(UnorderedElementsAre(x, z)));
+}
+
+TEST(VariableFilterFromProtoTest, FilterByIdsEmpty) {
+  Model model;
+  model.AddBinaryVariable();
+  SparseVectorFilterProto proto;
+  proto.set_filter_by_ids(true);
+  ASSERT_OK_AND_ASSIGN(MapFilter<Variable> filter,
+                       VariableFilterFromProto(model, proto));
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_THAT(filter.filtered_keys, Optional(IsEmpty()));
+}
+
+TEST(VariableFilterFromProtoTest, BadFilterIdFails) {
+  Model model;
+  model.AddBinaryVariable();
+  SparseVectorFilterProto proto;
+  proto.set_filter_by_ids(true);
+  proto.add_filtered_ids(3);
+  EXPECT_THAT(VariableFilterFromProto(model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("3")));
+}
+
+TEST(LinearConstraintFilterFromProtoTest, EmptyFilter) {
+  Model model;
+  SparseVectorFilterProto proto;
+  ASSERT_OK_AND_ASSIGN(MapFilter<LinearConstraint> filter,
+                       LinearConstraintFilterFromProto(model, proto));
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_EQ(filter.filtered_keys, std::nullopt);
+}
+
+TEST(LinearConstraintFilterFromProtoTest, NonemptyFilter) {
+  Model model;
+  LinearConstraint c = model.AddLinearConstraint();
+  model.AddLinearConstraint();
+  LinearConstraint e = model.AddLinearConstraint();
+  SparseVectorFilterProto proto;
+  proto.set_skip_zero_values(true);
+  proto.set_filter_by_ids(true);
+  proto.add_filtered_ids(0);
+  proto.add_filtered_ids(2);
+  ASSERT_OK_AND_ASSIGN(MapFilter<LinearConstraint> filter,
+                       LinearConstraintFilterFromProto(model, proto));
+  EXPECT_TRUE(filter.skip_zero_values);
+  EXPECT_THAT(filter.filtered_keys, Optional(UnorderedElementsAre(c, e)));
+}
+
+TEST(LinearConstraintFilterFromProtoTest, FilterByIdsEmpty) {
+  Model model;
+  model.AddLinearConstraint();
+  SparseVectorFilterProto proto;
+  proto.set_filter_by_ids(true);
+  ASSERT_OK_AND_ASSIGN(MapFilter<LinearConstraint> filter,
+                       LinearConstraintFilterFromProto(model, proto));
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_THAT(filter.filtered_keys, Optional(IsEmpty()));
+}
+
+TEST(LinearConstraintFilterFromProtoTest, BadFilterIdFails) {
+  Model model;
+  model.AddLinearConstraint();
+  SparseVectorFilterProto proto;
+  proto.set_filter_by_ids(true);
+  proto.add_filtered_ids(3);
+  EXPECT_THAT(LinearConstraintFilterFromProto(model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("3")));
+}
+
+TEST(QuadraticConstraintFilterFromProtoTest, EmptyFilter) {
+  Model model;
+  SparseVectorFilterProto proto;
+  ASSERT_OK_AND_ASSIGN(MapFilter<QuadraticConstraint> filter,
+                       QuadraticConstraintFilterFromProto(model, proto));
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_EQ(filter.filtered_keys, std::nullopt);
+}
+
+TEST(QuadraticConstraintFilterFromProtoTest, NonemptyFilter) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  QuadraticConstraint c = model.AddQuadraticConstraint(x * x <= 0.0);
+  model.AddQuadraticConstraint(x * x <= 0.0);
+  QuadraticConstraint e = model.AddQuadraticConstraint(x * x <= 0.0);
+  SparseVectorFilterProto proto;
+  proto.set_skip_zero_values(true);
+  proto.set_filter_by_ids(true);
+  proto.add_filtered_ids(0);
+  proto.add_filtered_ids(2);
+  ASSERT_OK_AND_ASSIGN(MapFilter<QuadraticConstraint> filter,
+                       QuadraticConstraintFilterFromProto(model, proto));
+  EXPECT_TRUE(filter.skip_zero_values);
+  EXPECT_THAT(filter.filtered_keys, Optional(UnorderedElementsAre(c, e)));
+}
+
+TEST(QuadraticConstraintFilterFromProtoTest, FilterByIdsEmpty) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  model.AddQuadraticConstraint(x * x <= 0.0);
+  SparseVectorFilterProto proto;
+  proto.set_filter_by_ids(true);
+  ASSERT_OK_AND_ASSIGN(MapFilter<QuadraticConstraint> filter,
+                       QuadraticConstraintFilterFromProto(model, proto));
+  EXPECT_FALSE(filter.skip_zero_values);
+  EXPECT_THAT(filter.filtered_keys, Optional(IsEmpty()));
+}
+
+TEST(QuadraticConstraintFilterFromProtoTest, BadFilterIdFails) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  model.AddQuadraticConstraint(x * x <= 0.0);
+  SparseVectorFilterProto proto;
+  proto.set_filter_by_ids(true);
+  proto.add_filtered_ids(3);
+  EXPECT_THAT(QuadraticConstraintFilterFromProto(model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("3")));
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/matchers_test.cc b/ortools/math_opt/cpp/matchers_test.cc
new file mode 100644
index 0000000000..cfef8a8e2d
--- /dev/null
+++ b/ortools/math_opt/cpp/matchers_test.cc
@@ -0,0 +1,2032 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/matchers.h"
+
+#include <cmath>
+#include <limits>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_replace.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/cpp/model.h"
+#include "ortools/math_opt/cpp/solution.h"
+#include "ortools/math_opt/cpp/solve_result.h"
+
+namespace operations_research::math_opt {
+namespace {
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+using ::testing::HasSubstr;
+using ::testing::Not;
+using ::testing::StrEq;
+constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
+
+TEST(ObjectiveBoundsNear, Is) {
+  const ObjectiveBounds bounds = {.primal_bound = 1.0, .dual_bound = 2.0};
+  EXPECT_THAT(bounds, ObjectiveBoundsNear(bounds));
+}
+
+TEST(ObjectiveBoundsNear, IsNotPrimalDifferent) {
+  const ObjectiveBounds expected = {.primal_bound = 1.0, .dual_bound = 2.0};
+  const ObjectiveBounds actual = {.primal_bound = 1.1, .dual_bound = 2.0};
+  EXPECT_THAT(actual, Not(ObjectiveBoundsNear(expected)));
+  EXPECT_THAT(actual, ObjectiveBoundsNear(expected, /*tolerance*/ 0.2));
+}
+
+TEST(ObjectiveBoundsNear, IsNotDualDifferent) {
+  const ObjectiveBounds expected = {.primal_bound = 1.0, .dual_bound = 2.0};
+  const ObjectiveBounds actual = {.primal_bound = 1.0, .dual_bound = 2.1};
+  EXPECT_THAT(actual, Not(ObjectiveBoundsNear(expected)));
+  EXPECT_THAT(actual, ObjectiveBoundsNear(expected, /*tolerance*/ 0.2));
+}
+
+TEST(ProblemStatusIs, IsEqual) {
+  const ProblemStatus status = {
+      .primal_status = FeasibilityStatus::kUndetermined,
+      .dual_status = FeasibilityStatus::kInfeasible,
+      .primal_or_dual_infeasible = false};
+  EXPECT_THAT(status, ProblemStatusIs(status));
+}
+
+TEST(ProblemStatusIs, IsNotPrimalDifferent) {
+  const ProblemStatus expected = {
+      .primal_status = FeasibilityStatus::kUndetermined,
+      .dual_status = FeasibilityStatus::kInfeasible,
+      .primal_or_dual_infeasible = false};
+  const ProblemStatus actual = {.primal_status = FeasibilityStatus::kFeasible,
+                                .dual_status = FeasibilityStatus::kInfeasible,
+                                .primal_or_dual_infeasible = false};
+  EXPECT_THAT(actual, Not(ProblemStatusIs(expected)));
+}
+
+TEST(ProblemStatusIs, IsNotDualDifferent) {
+  const ProblemStatus expected = {
+      .primal_status = FeasibilityStatus::kFeasible,
+      .dual_status = FeasibilityStatus::kUndetermined,
+      .primal_or_dual_infeasible = false};
+  const ProblemStatus actual = {.primal_status = FeasibilityStatus::kFeasible,
+                                .dual_status = FeasibilityStatus::kInfeasible,
+                                .primal_or_dual_infeasible = false};
+  EXPECT_THAT(actual, Not(ProblemStatusIs(expected)));
+}
+
+TEST(ProblemStatusIs, IsNotPrimalOrDualInfeasibleDifferent) {
+  const ProblemStatus expected = {
+      .primal_status = FeasibilityStatus::kUndetermined,
+      .dual_status = FeasibilityStatus::kUndetermined,
+      .primal_or_dual_infeasible = true};
+  const ProblemStatus actual = {
+      .primal_status = FeasibilityStatus::kUndetermined,
+      .dual_status = FeasibilityStatus::kUndetermined,
+      .primal_or_dual_infeasible = false};
+  EXPECT_THAT(actual, Not(ProblemStatusIs(expected)));
+}
+
+TEST(ApproximateMapMatcherTest, VariableIsNear) {
+  Model model;
+  const Variable w = model.AddBinaryVariable("w");
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const Variable z = model.AddBinaryVariable("z");
+  const VariableMap<double> actual = {{x, 2.0}, {y, 4.1}, {z, -2.5}};
+  EXPECT_THAT(actual, IsNear(actual));
+  EXPECT_THAT(actual, IsNear({{x, 2 + 1e-8}, {y, 4.1}, {z, -2.5}}));
+  EXPECT_THAT(actual, Not(IsNear({{x, 2 + 1e-3}, {y, 4.1}, {z, -2.5}})));
+  EXPECT_THAT(actual, Not(IsNear({{w, 1}, {z, -2.5}})));
+  EXPECT_THAT(actual, Not(IsNear({{z, -2.5}})));
+}
+
+TEST(ApproximateMapMatcherTest, VariableIsNearlySubsetOf) {
+  Model model;
+  const Variable w = model.AddBinaryVariable("w");
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const Variable z = model.AddBinaryVariable("z");
+  const VariableMap<double> actual = {{x, 2.0}, {y, 4.1}, {z, -2.5}};
+  EXPECT_THAT(actual, IsNearlySubsetOf(actual));
+  EXPECT_THAT(actual, IsNearlySubsetOf({{y, 4.1}, {z, -2.5}}));
+  EXPECT_THAT(actual, Not(IsNearlySubsetOf({{w, 1}, {y, 4.1}, {z, -2.5}})));
+  EXPECT_THAT(actual, Not(IsNearlySubsetOf({{y, 4.4}, {z, -2.5}})));
+}
+
+TEST(ApproximateMapMatcherTest, QuadraticConstraintIsNearAndIsNearlySubsetOf) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const QuadraticConstraint c = model.AddQuadraticConstraint(x * x <= 0, "c");
+  const QuadraticConstraint d = model.AddQuadraticConstraint(x * x <= 0, "d");
+  const QuadraticConstraint e = model.AddQuadraticConstraint(x * x <= 0, "e");
+
+  const absl::flat_hash_map<QuadraticConstraint, double> actual = {{c, 2},
+                                                                   {e, 5}};
+  EXPECT_THAT(actual, IsNearlySubsetOf(actual));
+  EXPECT_THAT(actual, IsNear(actual));
+  EXPECT_THAT(actual, IsNear({{c, 2 + 1e-8}, {e, 5}}));
+  EXPECT_THAT(actual, Not(IsNear({{e, 5}})));
+  EXPECT_THAT(actual, Not(IsNear({{c, 2 + 1e-2}, {e, 5}})));
+  EXPECT_THAT(actual, Not(IsNear({{d, 5}})));
+  EXPECT_THAT(actual, IsNearlySubsetOf({{e, 5}}));
+}
+
+TEST(ApproximateMapMatcherTest, LinearConstraintIsNearAndIsNearlySubsetOf) {
+  Model model;
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const LinearConstraint d = model.AddLinearConstraint("d");
+  const LinearConstraint e = model.AddLinearConstraint("e");
+
+  const LinearConstraintMap<double> actual = {{c, 2}, {e, 5}};
+  EXPECT_THAT(actual, IsNearlySubsetOf(actual));
+  EXPECT_THAT(actual, IsNear(actual));
+  EXPECT_THAT(actual, IsNear({{c, 2 + 1e-8}, {e, 5}}));
+  EXPECT_THAT(actual, Not(IsNear({{e, 5}})));
+  EXPECT_THAT(actual, Not(IsNear({{c, 2 + 1e-2}, {e, 5}})));
+  EXPECT_THAT(actual, Not(IsNear({{d, 5}})));
+  EXPECT_THAT(actual, IsNearlySubsetOf({{e, 5}}));
+}
+
+TEST(LinearExpressionMatcherTest, IsIdentical) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const Variable z = model.AddBinaryVariable("z");
+  const LinearExpression actual({{x, 1}, {y, 3}}, 4);
+  EXPECT_THAT(actual, IsIdentical(LinearExpression({{x, 1}, {y, 3}}, 4)));
+  EXPECT_THAT(actual, Not(IsIdentical(LinearExpression({{x, 1}}, 4))));
+  EXPECT_THAT(actual, Not(IsIdentical(LinearExpression({{x, 1}, {y, 3}}, 5))));
+  EXPECT_THAT(actual,
+              Not(IsIdentical(LinearExpression({{x, 1}, {y, 3}, {z, 1}}, 4))));
+  EXPECT_THAT(actual, Not(IsIdentical(LinearExpression(
+                          {{x, std::nextafter(1, 2)}, {y, 3}}, 4))));
+
+  Model other_model;
+  const Variable other_x = Variable(other_model.storage(), x.typed_id());
+  EXPECT_THAT(LinearExpression({{x, 1}}, 1),
+              Not(IsIdentical(LinearExpression({{other_x, 1}}, 1))));
+
+  // Same as actual, but with a structural zero term.
+  const LinearExpression other({{x, 1}, {y, 3}, {z, 0}}, 4);
+  EXPECT_THAT(other, Not(IsIdentical(actual)));
+  EXPECT_THAT(other,
+              IsIdentical(LinearExpression({{x, 1}, {y, 3}, {z, 0}}, 4)));
+}
+
+TEST(LinearExpressionMatcherDeathTest, IsIdenticalWithNaNs) {
+  Model model;
+  const Variable x = model.AddBinaryVariable();
+
+  EXPECT_DEATH(IsIdentical(LinearExpression({}, kNaN)), "Illegal NaN");
+  EXPECT_DEATH(IsIdentical(LinearExpression({{x, kNaN}}, 0)), "Illegal NaN");
+}
+
+TEST(LinearExpressionMatcherTest, IsIdenticalMatchedAgainstNaNs) {
+  Model model;
+  const Variable x = model.AddBinaryVariable();
+
+  EXPECT_THAT(LinearExpression(kNaN), Not(IsIdentical(LinearExpression(0))));
+  EXPECT_THAT(LinearExpression({{x, kNaN}}, 0),
+              Not(IsIdentical(LinearExpression({{x, 1}}, 0))));
+}
+
+TEST(LinearExpressionMatcherTest, LinearExpressionIsNear) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const LinearExpression actual({{x, 1.0}, {y, 3.0}}, 4.0);
+  EXPECT_THAT(actual, LinearExpressionIsNear(
+                          LinearExpression({{x, 1.0}, {y, 3.0}}, 4.0)));
+  EXPECT_THAT(actual, Not(LinearExpressionIsNear(
+                          LinearExpression({{x, 1.0}, {y, 3.0}}, 4.2),
+                          /*tolerance=*/0.1)));
+  EXPECT_THAT(actual, Not(LinearExpressionIsNear(
+                          LinearExpression({{x, 1.2}, {y, 3.0}}, 4.0),
+                          /*tolerance=*/0.1)));
+  EXPECT_THAT(actual, LinearExpressionIsNear(
+                          LinearExpression({{x, 1.0}, {y, 3.0}}, 4.2),
+                          /*tolerance=*/0.3));
+  EXPECT_THAT(actual, LinearExpressionIsNear(
+                          LinearExpression({{x, 1.2}, {y, 3.0}}, 4.0),
+                          /*tolerance=*/0.3));
+}
+
+TEST(BoundedLinearExpressionMatcherTest, ToleranceEachComponent) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const BoundedLinearExpression actual(x + 3.0 * y + 4.0, -2.0, 5.0);
+  constexpr double esp_error = 0.1;
+  const BoundedLinearExpression esp_lb_error(x + 3.0 * y + 4.0,
+                                             -2.0 + esp_error, 5.0);
+  const BoundedLinearExpression esp_ub_error(x + 3.0 * y + 4.0, -2.0,
+                                             5.0 + esp_error);
+  const BoundedLinearExpression esp_term_error(x + (3.0 + esp_error) * y + 4.0,
+                                               -2.0, 5.0);
+  const BoundedLinearExpression esp_offset_error(x + 3.0 * y + 4.0,
+                                                 -2.0 + esp_error, 5.0);
+  EXPECT_THAT(actual, Not(IsNearlyEquivalent(esp_lb_error, esp_error / 2)));
+  EXPECT_THAT(actual, Not(IsNearlyEquivalent(esp_lb_error, esp_error / 2)));
+  EXPECT_THAT(actual, Not(IsNearlyEquivalent(esp_lb_error, esp_error / 2)));
+  EXPECT_THAT(actual, Not(IsNearlyEquivalent(esp_lb_error, esp_error / 2)));
+
+  EXPECT_THAT(actual, IsNearlyEquivalent(esp_lb_error, esp_error * 2));
+  EXPECT_THAT(actual, IsNearlyEquivalent(esp_lb_error, esp_error * 2));
+  EXPECT_THAT(actual, IsNearlyEquivalent(esp_lb_error, esp_error * 2));
+  EXPECT_THAT(actual, IsNearlyEquivalent(esp_lb_error, esp_error * 2));
+}
+
+TEST(BoundedLinearExpressionMatcherTest, IsNearAddAndScale) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const BoundedLinearExpression actual(x + 3.0 * y + 4.0, -2.0, 5.0);
+  const BoundedLinearExpression negated(-x + -3.0 * y - 4.0, -5.0, 2.0);
+  const BoundedLinearExpression add_scale(x + 3.0 * y + 5.0, -1.0, 6.0);
+  const BoundedLinearExpression negated_add_scale(-x + -3.0 * y - 3.0, -4.0,
+                                                  3.0);
+
+  EXPECT_THAT(actual, IsNearlyEquivalent(actual, 0.0));
+  EXPECT_THAT(actual, IsNearlyEquivalent(negated, 1e-10));
+  EXPECT_THAT(actual, IsNearlyEquivalent(add_scale, 1e-10));
+  EXPECT_THAT(actual, IsNearlyEquivalent(negated_add_scale, 1e-10));
+}
+
+TEST(QuadraticExpressionMatcherTest, IsIdentical) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const Variable z = model.AddBinaryVariable("z");
+  const QuadraticExpression actual({{x, x, 1}, {x, y, 3}}, {{z, 4}}, 5);
+  EXPECT_THAT(actual, IsIdentical(QuadraticExpression({{x, x, 1}, {x, y, 3}},
+                                                      {{z, 4}}, 5)));
+  EXPECT_THAT(actual,
+              Not(IsIdentical(QuadraticExpression({{x, x, 1}}, {{z, 4}}, 5))));
+  EXPECT_THAT(
+      actual,
+      Not(IsIdentical(QuadraticExpression({{x, x, 1}, {x, y, 3}}, {}, 5))));
+  EXPECT_THAT(actual, Not(IsIdentical(QuadraticExpression(
+                          {{x, x, 1}, {x, y, 3}}, {{z, 4}}, 6))));
+  EXPECT_THAT(actual, Not(IsIdentical(QuadraticExpression(
+                          {{x, x, 1}, {x, y, 3}, {x, z, 6}}, {{z, 4}}, 5))));
+  EXPECT_THAT(actual, Not(IsIdentical(QuadraticExpression(
+                          {{x, x, 1}, {x, y, 3}}, {{z, 4}, {x, 6}}, 5))));
+  EXPECT_THAT(actual,
+              Not(IsIdentical(QuadraticExpression(
+                  {{x, x, std::nextafter(1, 2)}, {x, y, 3}}, {{z, 4}}, 5))));
+
+  Model other_model;
+  const Variable other_x = Variable(other_model.storage(), x.typed_id());
+  EXPECT_THAT(
+      QuadraticExpression({{x, x, 1}}, {}, 1),
+      Not(IsIdentical(QuadraticExpression({{other_x, other_x, 1}}, {}, 1))));
+
+  // Same as actual, but with structural zero terms.
+  const QuadraticExpression other({{x, x, 1}, {x, y, 3}, {x, z, 0}},
+                                  {{z, 4}, {y, 0}}, 5);
+  EXPECT_THAT(other, Not(IsIdentical(actual)));
+  EXPECT_THAT(other,
+              IsIdentical(QuadraticExpression({{x, x, 1}, {x, y, 3}, {x, z, 0}},
+                                              {{z, 4}, {y, 0}}, 5)));
+}
+
+TEST(QuadraticExpressionMatcherDeathTest, IsIdenticalWithNaNs) {
+  Model model;
+  const Variable x = model.AddBinaryVariable();
+
+  EXPECT_DEATH(IsIdentical(QuadraticExpression({}, {}, kNaN)), "Illegal NaN");
+  EXPECT_DEATH(IsIdentical(QuadraticExpression({}, {{x, kNaN}}, 0)),
+               "Illegal NaN");
+  EXPECT_DEATH(IsIdentical(QuadraticExpression({{x, x, kNaN}}, {}, 0)),
+               "Illegal NaN");
+}
+
+TEST(QuadraticExpressionMatcherTest, IsIdenticalMatchedAgainstNaNs) {
+  Model model;
+  const Variable x = model.AddBinaryVariable();
+
+  EXPECT_THAT(QuadraticExpression(kNaN),
+              Not(IsIdentical(QuadraticExpression(0))));
+  EXPECT_THAT(QuadraticExpression({}, {{x, kNaN}}, 0),
+              Not(IsIdentical(QuadraticExpression({}, {{x, 1}}, 0))));
+  EXPECT_THAT(QuadraticExpression({{x, x, kNaN}}, {}, 0),
+              Not(IsIdentical(QuadraticExpression({{x, x, 1}}, {}, 0))));
+}
+
+TEST(PrimalSolutionMatcherTest, IsNear) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const Variable z = model.AddBinaryVariable("z");
+  const PrimalSolution expected = {
+      .variable_values = {{x, 2.0}, {y, 4.1}, {z, -2.5}},
+      .objective_value = 2.0,
+      .feasibility_status = SolutionStatus::kFeasible};
+  PrimalSolution expected_no_status = expected;
+  expected_no_status.feasibility_status = SolutionStatus::kUndetermined;
+
+  {
+    const PrimalSolution actual = expected;
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+
+  {
+    PrimalSolution actual = expected;
+    actual.variable_values[x] += 1e-8;
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+
+  {
+    PrimalSolution actual = expected;
+    actual.variable_values[x] += 4;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    PrimalSolution actual = expected;
+    actual.variable_values.erase(x);
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    PrimalSolution actual = expected;
+    actual.objective_value += 5.0;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    PrimalSolution actual = expected;
+    actual.feasibility_status = SolutionStatus::kInfeasible;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+    EXPECT_THAT(actual, Not(IsNear(expected_no_status)));
+    actual.feasibility_status = SolutionStatus::kUndetermined;
+  }
+}
+
+TEST(DualSolutionMatcherTest, IsNear) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const LinearConstraint d = model.AddLinearConstraint("d");
+
+  const QuadraticConstraint e = model.AddQuadraticConstraint(x * x <= 0.0, "e");
+  const QuadraticConstraint f = model.AddQuadraticConstraint(x * x <= 0.0, "f");
+
+  const DualSolution expected = {
+      .dual_values = {{c, 1.0}, {d, 3.1}},
+      .quadratic_dual_values = {{e, 5.0}, {f, 6.1}},
+      .reduced_costs = {{x, 2.0}, {y, 4.1}},
+      .objective_value = 2.0,
+      .feasibility_status = SolutionStatus::kFeasible};
+  DualSolution expected_no_obj = expected;
+  expected_no_obj.objective_value = std::nullopt;
+  DualSolution expected_no_status = expected;
+  expected_no_status.feasibility_status = SolutionStatus::kUndetermined;
+
+  {
+    const DualSolution actual = expected;
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+
+  {
+    DualSolution actual = expected;
+    actual.reduced_costs[x] += 1e-8;
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+
+  {
+    DualSolution actual = expected;
+    actual.reduced_costs[x] += 4;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    DualSolution actual = expected;
+    actual.dual_values.erase(c);
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    DualSolution actual = expected;
+    actual.quadratic_dual_values.erase(e);
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    DualSolution actual = expected;
+    *actual.objective_value += 5.0;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+    EXPECT_THAT(actual, Not(IsNear(expected_no_obj)));
+  }
+
+  {
+    DualSolution actual = expected;
+    actual.feasibility_status = SolutionStatus::kInfeasible;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+    EXPECT_THAT(actual, Not(IsNear(expected_no_status)));
+  }
+}
+
+TEST(BasisTest, BasisIsOrCompatibleTest) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const LinearConstraint d = model.AddLinearConstraint("d");
+
+  Basis b1 = {.constraint_status = {{c, BasisStatus::kBasic},
+                                    {d, BasisStatus::kAtUpperBound}},
+              .variable_status = {{x, BasisStatus::kAtLowerBound},
+                                  {y, BasisStatus::kBasic}},
+              .basic_dual_feasibility = SolutionStatus::kFeasible};
+
+  EXPECT_THAT(b1, BasisIs(b1));
+
+  {
+    Basis b2 = b1;
+    b2.constraint_status[d] = BasisStatus::kAtLowerBound;
+    EXPECT_THAT(b1, Not(BasisIs(b2)));
+  }
+
+  {
+    Basis b3 = b1;
+    b3.variable_status[x] = BasisStatus::kBasic;
+    EXPECT_THAT(b1, Not(BasisIs(b3)));
+  }
+
+  {
+    Basis b4 = b1;
+    b4.variable_status.clear();
+    EXPECT_THAT(b1, Not(BasisIs(b4)));
+  }
+
+  {
+    Basis b5 = b1;
+    b5.basic_dual_feasibility = SolutionStatus::kUndetermined;
+    EXPECT_THAT(b1, Not(BasisIs(b5)));
+  }
+}
+
+TEST(SolutionTest, IsNear) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const LinearConstraint d = model.AddLinearConstraint("d");
+
+  const Solution expected = {
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 2.0}, {y, 4.1}},
+                         .objective_value = 2.0,
+                         .feasibility_status = SolutionStatus::kFeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 1.0}, {d, 3.1}},
+                       .reduced_costs = {{x, 2.0}, {y, 4.1}},
+                       .objective_value = 2.0,
+                       .feasibility_status = SolutionStatus::kFeasible},
+      .basis = Basis{.constraint_status = {{c, BasisStatus::kBasic},
+                                           {d, BasisStatus::kAtUpperBound}},
+                     .variable_status = {{x, BasisStatus::kAtLowerBound},
+                                         {y, BasisStatus::kBasic}},
+                     .basic_dual_feasibility = SolutionStatus::kFeasible}};
+
+  {
+    const Solution actual = expected;
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+
+  {
+    Solution actual = expected;
+    actual.primal_solution->objective_value += 5.0;
+    *actual.dual_solution->objective_value += 5.0;
+    actual.basis->variable_status[x] = BasisStatus::kBasic;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+
+    const SolutionMatcherOptions check_nothing{
+        .check_primal = false, .check_dual = false, .check_basis = false};
+    EXPECT_THAT(actual, IsNear(expected, check_nothing));
+  }
+
+  {
+    Solution actual = expected;
+    actual.primal_solution->feasibility_status = SolutionStatus::kUndetermined;
+    actual.dual_solution->feasibility_status = SolutionStatus::kUndetermined;
+    actual.basis->basic_dual_feasibility = SolutionStatus::kUndetermined;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    const SolutionMatcherOptions skip_primal{.check_primal = false};
+    Solution actual = expected;
+    actual.primal_solution->objective_value += 5.0;
+    EXPECT_THAT(actual, IsNear(expected, skip_primal));
+  }
+
+  {
+    const SolutionMatcherOptions skip_dual{.check_dual = false};
+    Solution actual = expected;
+    *actual.dual_solution->objective_value += 5.0;
+    EXPECT_THAT(actual, IsNear(expected, skip_dual));
+  }
+
+  {
+    const SolutionMatcherOptions skip_basis{.check_basis = false};
+    Solution actual = expected;
+    actual.basis->variable_status[x] = BasisStatus::kBasic;
+    EXPECT_THAT(actual, IsNear(expected, skip_basis));
+  }
+}
+
+TEST(PrimalRayMatcherTest, PrimalRayIsNear) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  const Variable z = model.AddBinaryVariable("z");
+  PrimalRay actual = {.variable_values = {{x, 2.0}, {y, 4.1}, {z, -2.5}}};
+  EXPECT_THAT(actual, IsNear(actual));
+  {
+    PrimalRay expected = {
+        .variable_values = {{x, 2.0 + 1e-8}, {y, 4.1}, {z, -2.5}}};
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+  {
+    PrimalRay expected = {.variable_values = {{x, 4.0}, {y, 8.2}, {z, -5.0}}};
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+  {
+    PrimalRay expected = {.variable_values = {{x, 1.0}, {y, 2.05}, {z, -1.25}}};
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+  {
+    PrimalRay expected = {
+        .variable_values = {{x, 4.0}, {y, 8.2 + 1e-8}, {z, -5.0}}};
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+
+  {
+    PrimalRay expected = {.variable_values = {{x, 2.1}, {y, 4.1}, {z, -2.5}}};
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+  {
+    PrimalRay expected = {.variable_values = {{x, 4.0}, {y, 8.5}, {z, -5.0}}};
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+  {
+    PrimalRay expected = {.variable_values = {{x, 0}, {y, 0}, {z, 0}}};
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+  {
+    PrimalRay expected;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+}
+
+TEST(DualRayMatcherTest, DualRayIsNear) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const LinearConstraint d = model.AddLinearConstraint("d");
+
+  DualRay actual = {.dual_values = {{c, 1.0}, {d, 3.1}},
+                    .reduced_costs = {{x, 2.0}, {y, 4.1}}};
+
+  {
+    DualRay expected = actual;
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+  {
+    DualRay expected = {.dual_values = {{c, 2.0}, {d, 6.2}},
+                        .reduced_costs = {{x, 4.0}, {y, 8.2}}};
+    EXPECT_THAT(actual, IsNear(expected));
+  }
+
+  {
+    DualRay expected = {.dual_values = {{c, 3.0}, {d, 9.3}},
+                        .reduced_costs = {{x, 4.0}, {y, 8.2}}};
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    DualRay expected = actual;
+    expected.reduced_costs[x] += 3.0;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+
+  {
+    DualRay expected = actual;
+    expected.dual_values.erase(c);
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+  {
+    DualRay expected;
+    EXPECT_THAT(actual, Not(IsNear(expected)));
+  }
+}
+
+TEST(LimitIs, Is) {
+  const Termination actual_feasible =
+      Termination::Feasible(/*is_maximize=*/false, Limit::kTime,
+                            /*finite_primal_objective=*/20.0,
+                            /*optional_dual_objective=*/10.0, "full string");
+  EXPECT_THAT(actual_feasible, LimitIs(Limit::kTime, HasSubstr("full")));
+  EXPECT_THAT(actual_feasible, LimitIs(Limit::kTime));
+  const Termination actual_no_solution = Termination::NoSolutionFound(
+      /*is_maximize=*/false, Limit::kTime,
+      /*optional_dual_objective=*/10.0, "full string");
+  EXPECT_THAT(actual_no_solution, LimitIs(Limit::kTime, HasSubstr("full")));
+  EXPECT_THAT(actual_no_solution, LimitIs(Limit::kTime));
+}
+
+TEST(LimitIs, IsNotLimit) {
+  const Termination actual_feasible =
+      Termination::Feasible(/*is_maximize=*/false, Limit::kIteration,
+                            /*finite_primal_objective=*/20.0);
+  EXPECT_THAT(actual_feasible, Not(LimitIs(Limit::kTime)));
+  const Termination actual_no_solution =
+      Termination::NoSolutionFound(/*is_maximize=*/false, Limit::kIteration);
+  EXPECT_THAT(actual_no_solution, Not(LimitIs(Limit::kTime)));
+}
+
+TEST(LimitIs, IsNotDetail) {
+  const Termination actual_feasible =
+      Termination::Feasible(/*is_maximize=*/false, Limit::kIteration,
+                            /*finite_primal_objective=*/20.0,
+                            /*optional_dual_objective=*/10.0, "string");
+  EXPECT_THAT(actual_feasible,
+              Not(LimitIs(Limit::kIteration, HasSubstr("full"))));
+}
+
+TEST(LimitIs, IsNotReason) {
+  const Termination actual = Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible);
+  EXPECT_THAT(actual, Not(LimitIs(Limit::kTime)));
+}
+
+TEST(TerminationIsIgnoreDetailTest, NoLimitEqual) {
+  const Termination actual = Termination::Optimal(/*objective_value=*/10.0);
+  EXPECT_THAT(actual, TerminationIsIgnoreDetail(actual));
+}
+
+TEST(TerminationIsIgnoreDetailTest, BadLimitNotEqual) {
+  const Termination actual = Termination::Optimal(/*objective_value=*/10.0);
+  Termination bad_expected = actual;
+  bad_expected.limit = Limit::kTime;
+  EXPECT_THAT(actual, Not(TerminationIsIgnoreDetail(bad_expected)));
+}
+
+TEST(TerminationIsIgnoreDetailTest, DetailIgnored) {
+  const Termination actual =
+      Termination::Optimal(/*objective_value=*/10.0, "cat");
+  const Termination expected =
+      Termination::Optimal(/*objective_value=*/10.0, "dog");
+  EXPECT_THAT(actual, TerminationIsIgnoreDetail(expected));
+}
+
+TEST(TerminationIsIgnoreDetailTest, ExpectedHasLimit) {
+  const Termination actual =
+      Termination::Feasible(/*is_maximize=*/false, Limit::kTime,
+                            /*finite_primal_objective=*/20.0,
+                            /*optional_dual_objective=*/10.0);
+  EXPECT_THAT(actual, TerminationIsIgnoreDetail(actual));
+}
+
+TEST(TerminationIsIgnoreDetailTest, ExpectedHasWrongLimit) {
+  const Termination actual =
+      Termination::Feasible(/*is_maximize=*/false, Limit::kTime,
+                            /*finite_primal_objective=*/20.0,
+                            /*optional_dual_objective=*/10.0);
+  EXPECT_THAT(actual, Not(TerminationIsIgnoreDetail(Termination::Feasible(
+                          /*is_maximize=*/false, Limit::kIteration,
+                          /*finite_primal_objective=*/20.0))));
+}
+
+TEST(TerminationIsIgnoreDetailTest, ExpectedHasLimitDetailIgnored) {
+  const Termination actual =
+      Termination::Feasible(/*is_maximize=*/false, Limit::kTime,
+                            /*finite_primal_objective=*/20.0);
+  EXPECT_THAT(actual, TerminationIsIgnoreDetail(Termination::Feasible(
+                          /*is_maximize=*/false, Limit::kTime,
+                          /*finite_primal_objective=*/20.0,
+                          /*optional_dual_objective=*/10.0, "mouse")));
+}
+
+TEST(ReasonIs, Is) {
+  Termination actual = Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible);
+  EXPECT_THAT(actual, ReasonIs(TerminationReason::kInfeasible));
+}
+
+TEST(ReasonIs, IsNot) {
+  Termination actual = Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible);
+  EXPECT_THAT(actual, Not(ReasonIs(TerminationReason::kUnbounded)));
+}
+
+TEST(ReasonIsOptimal, IsOptimal) {
+  Termination actual = Termination::Optimal(/*objective_value=*/10.0);
+  EXPECT_THAT(actual, ReasonIsOptimal());
+}
+
+TEST(ReasonIsOptimal, NotOptimal) {
+  Termination actual = Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible);
+  EXPECT_THAT(actual, Not(ReasonIsOptimal()));
+}
+
+TEST(TerminationIsOptimal, NotOptimalReason) {
+  const double primal_objective_value = 10.0;
+  const double dual_objective_value = 20.0;
+  Termination actual =
+      Termination::Optimal(primal_objective_value, dual_objective_value);
+  actual.reason = TerminationReason::kInfeasible;
+  EXPECT_THAT(actual, Not(TerminationIsOptimal(primal_objective_value,
+                                               dual_objective_value)));
+}
+
+TEST(TerminationIsOptimal, NotPrimalFeasible) {
+  const double primal_objective_value = 10.0;
+  const double dual_objective_value = 20.0;
+  Termination actual =
+      Termination::Optimal(primal_objective_value, dual_objective_value);
+  actual.problem_status.primal_status = FeasibilityStatus::kInfeasible;
+  EXPECT_THAT(actual, Not(TerminationIsOptimal(primal_objective_value,
+                                               dual_objective_value)));
+}
+
+TEST(TerminationIsOptimal, NotDualFeasible) {
+  const double primal_objective_value = 10.0;
+  const double dual_objective_value = 20.0;
+  Termination actual =
+      Termination::Optimal(primal_objective_value, dual_objective_value);
+  actual.problem_status.dual_status = FeasibilityStatus::kInfeasible;
+  EXPECT_THAT(actual, Not(TerminationIsOptimal(primal_objective_value,
+                                               dual_objective_value)));
+}
+
+TEST(TerminationIsOptimal, NotFalsePrimalOrDualInfeasible) {
+  const double primal_objective_value = 10.0;
+  const double dual_objective_value = 20.0;
+  Termination actual =
+      Termination::Optimal(primal_objective_value, dual_objective_value);
+  actual.problem_status.primal_or_dual_infeasible = true;
+  EXPECT_THAT(actual, Not(TerminationIsOptimal(primal_objective_value,
+                                               dual_objective_value)));
+}
+
+TEST(TerminationIsOptimal, WrongPrimalBound) {
+  const double primal_objective_value = 10.0;
+  const double dual_objective_value = 20.0;
+  const Termination actual = Termination::Optimal(
+      /*primal_objective_value=*/10.1, dual_objective_value);
+  EXPECT_THAT(actual, Not(TerminationIsOptimal(primal_objective_value,
+                                               dual_objective_value)));
+  EXPECT_THAT(actual,
+              TerminationIsOptimal(primal_objective_value, dual_objective_value,
+                                   /*tolerance=*/0.2));
+}
+
+TEST(TerminationIsOptimal, WrongDualBound) {
+  const double primal_objective_value = 10.0;
+  const double dual_objective_value = 20.0;
+  const Termination actual = Termination::Optimal(
+      primal_objective_value, /*dual_objective_value=*/20.1);
+  EXPECT_THAT(actual, Not(TerminationIsOptimal(primal_objective_value,
+                                               dual_objective_value)));
+  EXPECT_THAT(actual,
+              TerminationIsOptimal(primal_objective_value, dual_objective_value,
+                                   /*tolerance=*/0.2));
+}
+
+TEST(TerminationIsOptimal, Optimal) {
+  const double primal_objective_value = 10.0;
+  const Termination actual =
+      Termination::Optimal(primal_objective_value,
+                           /*dual_objective_value=*/primal_objective_value +
+                               kMatcherDefaultTolerance / 2.0);
+  EXPECT_THAT(actual, TerminationIsOptimal(primal_objective_value));
+}
+
+TEST(IsOptimalTest, IsOptimal) {
+  // Assuming maximization.
+  // TODO(b/309658404): consider changing to finite dual bound.
+  SolveResult actual{Termination::Optimal(/*primal_objective_value=*/20.0,
+                                          /*dual_objective_value=*/kInf)};
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .objective_value = 10.0,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, IsOptimal());
+}
+
+TEST(IsOptimalTest, NotOptimal) {
+  SolveResult actual{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+  EXPECT_THAT(actual, Not(IsOptimal()));
+}
+
+TEST(IsOptimalTest, CheckObjective) {
+  // Assuming maximization.
+  // TODO(b/309658404): consider changing to finite dual bound.
+  SolveResult actual{Termination::Optimal(/*primal_objective_value=*/50.0,
+                                          /*dual_objective_value=*/kInf)};
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .objective_value = 42.0,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, IsOptimal(42.0));
+  EXPECT_THAT(actual, Not(IsOptimal(35)));
+}
+
+TEST(IsOptimalTest, CheckObjectiveMissingSolution) {
+  // Assuming maximization.
+  // TODO(b/309658404): consider changing to finite dual bound.
+  SolveResult actual{Termination::Optimal(/*primal_objective_value=*/50.0,
+                                          /*dual_objective_value=*/kInf)};
+  EXPECT_THAT(actual, Not(IsOptimal(42.0)));
+}
+
+TEST(IsOptimalTest, CheckObjectiveWrongObjectiveForSolution) {
+  // Assuming maximization.
+  // TODO(b/309658404): consider changing to finite dual bound.
+  SolveResult actual{Termination::Optimal(/*primal_objective_value=*/42.0,
+                                          /*dual_objective_value=*/kInf)};
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .objective_value = 35.0,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, Not(IsOptimal(42.0)));
+}
+
+TEST(TerminatesWithTest, Expected) {
+  SolveResult actual{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+  EXPECT_THAT(actual, TerminatesWith(TerminationReason::kInfeasible));
+}
+
+TEST(TerminatesWithTest, WrongReason) {
+  SolveResult actual{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+  EXPECT_THAT(actual, Not(TerminatesWith(TerminationReason::kUnbounded)));
+}
+
+TEST(TerminatesWithOneOfTest, ExpectedInList) {
+  SolveResult actual{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+  EXPECT_THAT(actual, TerminatesWithOneOf({TerminationReason::kUnbounded,
+                                           TerminationReason::kInfeasible}));
+}
+
+TEST(TerminatesWithOneOfTest, ExpectedNotInList) {
+  SolveResult actual{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+  EXPECT_THAT(actual, Not(TerminatesWithOneOf({TerminationReason::kUnbounded,
+                                               TerminationReason::kOptimal})));
+}
+
+TEST(TerminatesWithLimitTest, Expected) {
+  SolveResult feasible{Termination::Feasible(/*is_maximize=*/false,
+                                             Limit::kTime,
+                                             /*finite_primal_objective=*/20.0)};
+  EXPECT_THAT(feasible, TerminatesWithLimit(Limit::kTime));
+  EXPECT_THAT(feasible, Not(TerminatesWithLimit(Limit::kIteration)));
+
+  SolveResult no_solution_found{
+      Termination::NoSolutionFound(/*is_maximize=*/false, Limit::kTime)};
+  EXPECT_THAT(no_solution_found, TerminatesWithLimit(Limit::kTime));
+  EXPECT_THAT(no_solution_found, Not(TerminatesWithLimit(Limit::kIteration)));
+}
+
+TEST(TerminatesWithLimitTest, AllowUndetermined) {
+  SolveResult feasible{Termination::Feasible(/*is_maximize=*/false,
+                                             Limit::kUndetermined,
+                                             /*finite_primal_objective=*/20.0)};
+  EXPECT_THAT(feasible, TerminatesWithLimit(Limit::kTime,
+                                            /*allow_limit_undetermined=*/true));
+  EXPECT_THAT(feasible, Not(TerminatesWithLimit(Limit::kTime)));
+
+  SolveResult no_solution_found{Termination::NoSolutionFound(
+      /*is_maximize=*/false, Limit::kUndetermined)};
+  EXPECT_THAT(no_solution_found,
+              TerminatesWithLimit(Limit::kTime,
+                                  /*allow_limit_undetermined=*/true));
+  EXPECT_THAT(no_solution_found, Not(TerminatesWithLimit(Limit::kTime)));
+}
+
+TEST(TerminatesWithReasonFeasibleTest, Expected) {
+  SolveResult feasible{Termination::Feasible(/*is_maximize=*/false,
+                                             Limit::kTime,
+                                             /*finite_primal_objective=*/20.0)};
+  EXPECT_THAT(feasible, TerminatesWithReasonFeasible(Limit::kTime));
+  EXPECT_THAT(feasible, Not(TerminatesWithReasonFeasible(Limit::kIteration)));
+
+  SolveResult no_solution_found{
+      Termination::NoSolutionFound(/*is_maximize=*/false, Limit::kTime)};
+  EXPECT_THAT(no_solution_found,
+              Not(TerminatesWithReasonFeasible(Limit::kTime)));
+}
+
+TEST(TerminatesWithReasonFeasibleTest, AllowUndetermined) {
+  SolveResult feasible{Termination::Feasible(/*is_maximize=*/false,
+                                             Limit::kUndetermined,
+                                             /*finite_primal_objective=*/20.0)};
+  EXPECT_THAT(feasible,
+              TerminatesWithReasonFeasible(Limit::kTime,
+                                           /*allow_limit_undetermined=*/true));
+  EXPECT_THAT(feasible, Not(TerminatesWithReasonFeasible(Limit::kTime)));
+
+  SolveResult no_solution_found{Termination::NoSolutionFound(
+      /*is_maximize=*/false, Limit::kUndetermined)};
+  EXPECT_THAT(no_solution_found, Not(TerminatesWithReasonFeasible(
+                                     Limit::kTime,
+                                     /*allow_limit_undetermined=*/true)));
+}
+
+TEST(TerminatesWithReasonNoSolutionFoundTest, Expected) {
+  SolveResult feasible{Termination::Feasible(/*is_maximize=*/false,
+                                             Limit::kTime,
+                                             /*finite_primal_objective=*/20.0)};
+  EXPECT_THAT(feasible, Not(TerminatesWithReasonNoSolutionFound(Limit::kTime)));
+
+  SolveResult no_solution_found{
+      Termination::NoSolutionFound(/*is_maximize=*/false, Limit::kTime)};
+  EXPECT_THAT(no_solution_found,
+              TerminatesWithReasonNoSolutionFound(Limit::kTime));
+  EXPECT_THAT(no_solution_found,
+              Not(TerminatesWithReasonNoSolutionFound(Limit::kIteration)));
+}
+
+TEST(TTerminatesWithReasonNoSolutionFoundTest, AllowUndetermined) {
+  SolveResult feasible{Termination::Feasible(/*is_maximize=*/false,
+                                             Limit::kUndetermined,
+                                             /*finite_primal_objective=*/20.0)};
+  EXPECT_THAT(feasible, Not(TerminatesWithReasonNoSolutionFound(
+                            Limit::kTime,
+                            /*allow_limit_undetermined=*/true)));
+
+  SolveResult no_solution_found{Termination::NoSolutionFound(
+      /*is_maximize=*/false, Limit::kUndetermined)};
+  EXPECT_THAT(no_solution_found, TerminatesWithReasonNoSolutionFound(
+                                     Limit::kTime,
+                                     /*allow_limit_undetermined=*/true));
+  EXPECT_THAT(no_solution_found,
+              Not(TerminatesWithReasonNoSolutionFound(Limit::kTime)));
+}
+
+TEST(HasSolution, NoSolution) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  EXPECT_THAT(actual, Not(HasSolution(PrimalSolution{
+                          .variable_values = {{x, 1.0}},
+                          .objective_value = 42,
+                          .feasibility_status = SolutionStatus::kFeasible})));
+}
+
+TEST(HasSolution, HasSolution) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 1.0}},
+                   .objective_value = 42,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 2.0}},
+                   .objective_value = 42,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 0.0}},
+                   .objective_value = 10,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, -1.0}},
+                   .objective_value = 42,
+                   .feasibility_status = SolutionStatus::kInfeasible}});
+  EXPECT_THAT(actual, HasSolution(PrimalSolution{
+                          .variable_values = {{x, 1.0}},
+                          .objective_value = 42,
+                          .feasibility_status = SolutionStatus::kFeasible}));
+  EXPECT_THAT(actual, Not(HasSolution(PrimalSolution{
+                          .variable_values = {{x, 1.0}},
+                          .objective_value = 32,
+                          .feasibility_status = SolutionStatus::kFeasible})));
+}
+
+TEST(HasDualSolution, NoSolution) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  DualSolution expected;
+  expected.dual_values[c] = 1;
+  expected.reduced_costs[x] = 3;
+  expected.objective_value = 5;
+  EXPECT_THAT(actual, Not(HasDualSolution(DualSolution{
+                          .dual_values = {{c, 3.0}},
+                          .reduced_costs = {{x, 5}},
+                          .objective_value = 42,
+                          .feasibility_status = SolutionStatus::kFeasible})));
+}
+
+TEST(HasBestDualSolutionTest, HasSolution) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  actual.solutions.push_back(
+      Solution{.dual_solution = DualSolution{
+                   .dual_values = {{c, 3.0}},
+                   .reduced_costs = {{x, 5}},
+                   .objective_value = 42,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  actual.solutions.push_back(
+      Solution{.dual_solution = DualSolution{
+                   .dual_values = {{c, 2.0}},
+                   .reduced_costs = {{x, 1}},
+                   .objective_value = 12,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, HasDualSolution(*actual.solutions[0].dual_solution));
+  EXPECT_THAT(actual, HasDualSolution(*actual.solutions[1].dual_solution));
+  {
+    DualSolution expected = *actual.solutions[0].dual_solution;
+    expected.feasibility_status = SolutionStatus::kInfeasible;
+    EXPECT_THAT(actual, Not(HasDualSolution(expected)));
+  }
+
+  {
+    DualSolution expected = *actual.solutions[0].dual_solution;
+    expected.feasibility_status = SolutionStatus::kUndetermined;
+    EXPECT_THAT(actual, Not(HasDualSolution(expected)));
+  }
+}
+
+TEST(IsOptimalWithSolution, IsOptimalCorrectlyCalled) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/42.0)};
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 1.0}},
+                   .objective_value = 42,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, Not(IsOptimalWithSolution(43, {{x, 1.0}},
+                                                /*tolerance=*/0.1)));
+  EXPECT_THAT(actual, IsOptimalWithSolution(43, {{x, 1.0}},
+                                            /*tolerance=*/10));
+  EXPECT_THAT(actual, IsOptimalWithSolution(42, {{x, 1.0}}));
+}
+
+TEST(IsOptimalWithSolution, HasSolutionCorrectlyCalled) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/42.0)};
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 1.0}, {y, 0.0}},
+                   .objective_value = 42,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  actual.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 0.0}, {y, 1.0}},
+                   .objective_value = 42,
+                   .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, IsOptimalWithSolution(42, {{x, 1.0}, {y, 0.0}}));
+  EXPECT_THAT(actual, IsOptimalWithSolution(42, {{x, 0.0}, {y, 1.0}}));
+  EXPECT_THAT(actual, Not(IsOptimalWithSolution(42, {{x, 0.0}, {y, 2.0}},
+                                                /*tolerance=*/0.1)));
+  EXPECT_THAT(actual, IsOptimalWithSolution(42, {{x, 0.0}, {y, 2.0}},
+                                            /*tolerance=*/10));
+  actual.solutions[1].primal_solution->feasibility_status =
+      SolutionStatus::kInfeasible;
+  EXPECT_THAT(actual, Not(IsOptimalWithSolution(42, {{x, 0.0}, {y, 1.0}})));
+}
+
+TEST(IsOptimalWithDualSolution, IsOptimalCorrectlyCalled) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/42.0)};
+  actual.solutions.push_back(Solution{
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 1.0}},
+                         .objective_value = 42,
+                         .feasibility_status = SolutionStatus::kFeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 3.0}},
+                       .reduced_costs = {{x, 5}},
+                       .objective_value = 42,
+                       .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, Not(IsOptimalWithDualSolution(43, {{c, 3.0}}, {{x, 5}},
+
+                                                    /*tolerance=*/0.1)));
+  EXPECT_THAT(actual, IsOptimalWithDualSolution(43, {{c, 3.0}}, {{x, 5}},
+                                                /*tolerance=*/10));
+  EXPECT_THAT(actual, IsOptimalWithDualSolution(42, {{c, 3.0}}, {{x, 5}}));
+}
+
+TEST(IsOptimalWithDualSolution, HasDualSolutionCorrectlyCalled) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const LinearConstraint d = model.AddLinearConstraint("d");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/42.0)};
+  actual.solutions.push_back(Solution{
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 1.0}},
+                         .objective_value = 42,
+                         .feasibility_status = SolutionStatus::kFeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 1.0}, {d, 0.0}},
+                       .reduced_costs = {{x, 5}},
+                       .objective_value = 42,
+                       .feasibility_status = SolutionStatus::kFeasible}});
+  actual.solutions.push_back(Solution{
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 1.0}},
+                         .objective_value = 42,
+                         .feasibility_status = SolutionStatus::kFeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 0.0}, {d, 1.0}},
+                       .reduced_costs = {{x, 5}},
+                       .objective_value = 42,
+                       .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual,
+              IsOptimalWithDualSolution(42, {{c, 1.0}, {d, 0.0}}, {{x, 5}}));
+  EXPECT_THAT(actual,
+              IsOptimalWithDualSolution(42, {{c, 0.0}, {d, 1.0}}, {{x, 5}}));
+  EXPECT_THAT(actual,
+              Not(IsOptimalWithDualSolution(42, {{c, 1.0}, {d, 0.0}}, {{x, 6}},
+                                            /*tolerance=*/0.1)));
+  EXPECT_THAT(actual, IsOptimalWithDualSolution(42, {{c, 1.0}, {d, 0.0}},
+                                                {{x, 6}}, /*tolerance=*/10));
+}
+
+TEST(IsOptimalWithDualSolutionQc, IsOptimalCorrectlyCalled) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const QuadraticConstraint d = model.AddQuadraticConstraint(x * x <= 1, "c");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/42.0)};
+  actual.solutions.push_back(Solution{
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 1.0}},
+                         .objective_value = 42,
+                         .feasibility_status = SolutionStatus::kFeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 3.0}},
+                       .quadratic_dual_values = {{d, 3.0}},
+                       .reduced_costs = {{x, 5}},
+                       .objective_value = 42,
+                       .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, Not(IsOptimalWithDualSolution(43, {{c, 3.0}}, {{d, 3.0}},
+                                                    {{x, 5}},
+
+                                                    /*tolerance=*/0.1)));
+  EXPECT_THAT(actual,
+              IsOptimalWithDualSolution(43, {{c, 3.0}}, {{d, 3.0}}, {{x, 5}},
+                                        /*tolerance=*/10));
+  EXPECT_THAT(actual,
+              IsOptimalWithDualSolution(42, {{c, 3.0}}, {{d, 3.0}}, {{x, 5}}));
+}
+
+TEST(IsOptimalWithDualSolutionQc, HasDualSolutionCorrectlyCalled) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const LinearConstraint d = model.AddLinearConstraint("d");
+  const QuadraticConstraint e = model.AddQuadraticConstraint(x * x <= 1, "e");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/42.0)};
+  actual.solutions.push_back(Solution{
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 1.0}},
+                         .objective_value = 42,
+                         .feasibility_status = SolutionStatus::kFeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 1.0}, {d, 0.0}},
+                       .quadratic_dual_values = {{e, 3.0}},
+                       .reduced_costs = {{x, 5}},
+                       .objective_value = 42,
+                       .feasibility_status = SolutionStatus::kFeasible}});
+  actual.solutions.push_back(Solution{
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 1.0}},
+                         .objective_value = 42,
+                         .feasibility_status = SolutionStatus::kFeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 0.0}, {d, 1.0}},
+                       .quadratic_dual_values = {{e, 3.0}},
+                       .reduced_costs = {{x, 5}},
+                       .objective_value = 42,
+                       .feasibility_status = SolutionStatus::kFeasible}});
+  EXPECT_THAT(actual, IsOptimalWithDualSolution(42, {{c, 1.0}, {d, 0.0}},
+                                                {{e, 3.0}}, {{x, 5}}));
+  EXPECT_THAT(actual, IsOptimalWithDualSolution(42, {{c, 0.0}, {d, 1.0}},
+                                                {{e, 3.0}}, {{x, 5}}));
+  EXPECT_THAT(actual, Not(IsOptimalWithDualSolution(42, {{c, 1.0}, {d, 0.0}},
+                                                    {{e, 4.0}}, {{x, 5}},
+                                                    /*tolerance=*/0.1)));
+  EXPECT_THAT(actual,
+              IsOptimalWithDualSolution(42, {{c, 1.0}, {d, 0.0}}, {{e, 4.0}},
+                                        {{x, 5}}, /*tolerance=*/10));
+}
+
+TEST(HasPrimalRayTest, NoRay) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  EXPECT_THAT(actual, Not(HasPrimalRay({{x, 1.0}})));
+  PrimalRay expected = {.variable_values = {{x, 1.0}}};
+  EXPECT_THAT(actual, Not(HasPrimalRay(expected)));
+}
+
+TEST(HasPrimalRayTest, HasRay) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  PrimalRay& first_ray = actual.primal_rays.emplace_back();
+  first_ray.variable_values = {{x, 1}, {y, 0}};
+  PrimalRay& second_ray = actual.primal_rays.emplace_back();
+  second_ray.variable_values = {{x, 1}, {y, 2}};
+  EXPECT_THAT(actual, HasPrimalRay({{x, 1}, {y, 0}}));
+  EXPECT_THAT(actual, HasPrimalRay({{x, 2}, {y, 0}}));
+  EXPECT_THAT(actual, HasPrimalRay({{x, 1}, {y, 2}}));
+  EXPECT_THAT(actual, HasPrimalRay(actual.primal_rays[0]));
+  EXPECT_THAT(actual, HasPrimalRay(actual.primal_rays[1]));
+  EXPECT_THAT(actual, Not(HasPrimalRay({{x, 0}, {y, 1}})));
+  PrimalRay bad_ray;
+  bad_ray.variable_values = {{x, 0}, {y, 1}};
+  EXPECT_THAT(actual, Not(HasPrimalRay(bad_ray)));
+}
+
+TEST(HasDualRayTest, NoRay) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  DualRay expected = {.dual_values = {{c, 2}}, .reduced_costs = {{x, 1}}};
+  EXPECT_THAT(actual, Not(HasDualRay(expected)));
+}
+
+TEST(HasDualRayTest, HasRay) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  SolveResult actual{Termination::Optimal(/*objective_value=*/10.0)};
+  DualRay& first_ray = actual.dual_rays.emplace_back();
+  first_ray.dual_values[c] = 1;
+  first_ray.reduced_costs[x] = 2;
+
+  DualRay& second_ray = actual.dual_rays.emplace_back();
+  second_ray.dual_values[c] = 3;
+  second_ray.reduced_costs[x] = 1;
+
+  DualRay bad_ray;
+  second_ray.dual_values[c] = -3;
+  second_ray.reduced_costs[x] = -3;
+
+  EXPECT_THAT(actual, HasDualRay(actual.dual_rays[0]));
+  EXPECT_THAT(actual, HasDualRay(actual.dual_rays[1]));
+  EXPECT_THAT(actual, Not(HasDualRay(bad_ray)));
+}
+
+TEST(ResultsConsistentTest, SimpleOptimal) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+
+  SolveResult expected{Termination::Optimal(/*objective_value=*/10.0)};
+  expected.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 1}, {y, 0}}, .objective_value = 3}});
+
+  {
+    SolveResult actual = expected;
+    EXPECT_THAT(actual, IsConsistentWith(expected));
+  }
+
+  {
+    SolveResult small_error = expected;
+    small_error.solutions[0].primal_solution->variable_values[x] += 1e-7;
+    EXPECT_THAT(small_error, IsConsistentWith(expected, {.tolerance = 1e-6}));
+    EXPECT_THAT(small_error,
+                Not(IsConsistentWith(expected, {.tolerance = 1e-8})));
+  }
+
+  {
+    SolveResult extra_solution = expected;
+    PrimalSolution solution2;
+    solution2.variable_values = {{x, 0}, {y, 1}};
+    solution2.objective_value = 2;
+    extra_solution.solutions.push_back(Solution{.primal_solution = solution2});
+    EXPECT_THAT(extra_solution,
+                IsConsistentWith(expected, {.first_solution_only = true}));
+    EXPECT_THAT(extra_solution, Not(IsConsistentWith(
+                                    expected, {.first_solution_only = false})));
+  }
+}
+
+TEST(ResultsConsistentTest, MultipleSolutions) {
+  Model model;
+  const Variable x = model.AddBinaryVariable("x");
+  const Variable y = model.AddBinaryVariable("y");
+
+  SolveResult expected{Termination::Optimal(/*objective_value=*/10.0)};
+  expected.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 1}, {y, 0}}, .objective_value = 3}});
+  expected.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 0}, {y, 1}}, .objective_value = 2}});
+  expected.solutions.push_back(
+      Solution{.primal_solution = PrimalSolution{
+                   .variable_values = {{x, 0}, {y, 0}}, .objective_value = 0}});
+  {
+    SolveResult actual = expected;
+    EXPECT_THAT(actual,
+                IsConsistentWith(expected, {.first_solution_only = false}));
+    EXPECT_THAT(actual,
+                IsConsistentWith(expected, {.first_solution_only = true}));
+  }
+
+  {
+    SolveResult alternate{Termination::Optimal(/*objective_value=*/10.0)};
+    alternate.solutions.push_back(Solution{
+        .primal_solution = PrimalSolution{.variable_values = {{x, 1}, {y, 0}},
+                                          .objective_value = 3}});
+    alternate.solutions.push_back(Solution{
+        .primal_solution = PrimalSolution{.variable_values = {{x, 1}, {y, 1}},
+                                          .objective_value = -1}});
+    EXPECT_THAT(alternate, Not(IsConsistentWith(
+                               expected, {.first_solution_only = false})));
+    EXPECT_THAT(alternate,
+                IsConsistentWith(expected, {.first_solution_only = true}));
+  }
+}
+
+TEST(ResultsConsistentTest, DualSolutionAndBasis) {
+  Model model;
+  const Variable x = model.AddContinuousVariable(0, 1, "x");
+  const Variable y = model.AddContinuousVariable(0, 1, "y");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+
+  SolveResult expected{Termination::Optimal(/*objective_value=*/10.0)};
+  expected.solutions.push_back(Solution{
+      .primal_solution = PrimalSolution{.variable_values = {{x, 1}, {y, 0}},
+                                        .objective_value = 3},
+      .dual_solution = DualSolution{.dual_values = {{c, 1.0}},
+                                    .reduced_costs = {{x, 0.0}, {y, 1.0}},
+                                    .objective_value = 3},
+      .basis = Basis{.constraint_status = {{c, BasisStatus::kBasic}},
+                     .variable_status = {{x, BasisStatus::kAtUpperBound},
+                                         {y, BasisStatus::kAtLowerBound}}}});
+
+  {
+    SolveResult actual = expected;
+    EXPECT_THAT(actual, IsConsistentWith(expected));
+    EXPECT_THAT(actual, IsConsistentWith(expected, {.check_dual = false}));
+    EXPECT_THAT(actual, IsConsistentWith(expected, {.check_basis = true}));
+  }
+
+  {
+    SolveResult dual_missing = expected;
+    dual_missing.solutions[0].dual_solution.reset();
+    EXPECT_THAT(dual_missing, Not(IsConsistentWith(expected)));
+    EXPECT_THAT(dual_missing,
+                IsConsistentWith(expected, {.check_dual = false}));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, Not(IsConsistentWith(dual_missing)));
+    EXPECT_THAT(expected,
+                IsConsistentWith(dual_missing, {.check_dual = false}));
+  }
+
+  {
+    SolveResult basis_missing = expected;
+    basis_missing.solutions[0].basis.reset();
+    EXPECT_THAT(basis_missing,
+                Not(IsConsistentWith(expected, {.check_basis = true})));
+    EXPECT_THAT(basis_missing, IsConsistentWith(expected));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected,
+                Not(IsConsistentWith(basis_missing, {.check_basis = true})));
+    EXPECT_THAT(expected, IsConsistentWith(basis_missing));
+  }
+
+  {
+    SolveResult extra_solution = expected;
+    extra_solution.solutions.push_back(Solution{
+        .dual_solution = DualSolution{.dual_values = {{c, 1.0}},
+                                      .reduced_costs = {{x, 1.0}, {y, 0.0}},
+                                      .objective_value = 4}});
+    EXPECT_THAT(extra_solution, IsConsistentWith(expected));
+    EXPECT_THAT(extra_solution, Not(IsConsistentWith(
+                                    expected, {.first_solution_only = false})));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, IsConsistentWith(extra_solution));
+    EXPECT_THAT(expected, Not(IsConsistentWith(
+                              extra_solution, {.first_solution_only = false})));
+  }
+}
+
+TEST(ResultsConsistentTest, Unbounded) {
+  Model model;
+  const Variable x = model.AddContinuousVariable(0, 1, "x");
+  const Variable y = model.AddContinuousVariable(0, 1, "y");
+
+  SolveResult expected{Termination::Unbounded(/*is_maximize=*/false)};
+  expected.primal_rays.push_back({.variable_values = {{x, 1}, {y, 0}}});
+
+  {
+    SolveResult actual = expected;
+    EXPECT_THAT(actual, IsConsistentWith(expected));
+    EXPECT_THAT(actual, IsConsistentWith(expected, {.check_rays = false}));
+    EXPECT_THAT(actual,
+                IsConsistentWith(expected, {.inf_or_unb_soft_match = false}));
+  }
+
+  {
+    SolveResult dual_infeasible = expected;
+    dual_infeasible.termination.reason =
+        TerminationReason::kInfeasibleOrUnbounded;
+    EXPECT_THAT(dual_infeasible, IsConsistentWith(expected));
+    EXPECT_THAT(
+        dual_infeasible,
+        Not(IsConsistentWith(expected, {.inf_or_unb_soft_match = false})));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, IsConsistentWith(dual_infeasible));
+    EXPECT_THAT(expected,
+                Not(IsConsistentWith(dual_infeasible,
+                                     {.inf_or_unb_soft_match = false})));
+  }
+
+  {
+    SolveResult with_primal = expected;
+    with_primal.solutions.push_back(Solution{
+        .primal_solution = PrimalSolution{.variable_values = {{x, 1}, {y, 0}},
+                                          .objective_value = 3.0}});
+    EXPECT_THAT(with_primal,
+                Not(IsConsistentWith(
+                    expected, {.check_solutions_if_inf_or_unbounded = true})));
+    EXPECT_THAT(with_primal, IsConsistentWith(expected));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, Not(IsConsistentWith(
+                              with_primal,
+                              {.check_solutions_if_inf_or_unbounded = true})));
+    EXPECT_THAT(expected, IsConsistentWith(with_primal));
+  }
+
+  {
+    SolveResult ray_missing = expected;
+    ray_missing.primal_rays.clear();
+    EXPECT_THAT(ray_missing, Not(IsConsistentWith(expected)));
+    EXPECT_THAT(ray_missing, IsConsistentWith(expected, {.check_rays = false}));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, Not(IsConsistentWith(ray_missing)));
+    EXPECT_THAT(expected, IsConsistentWith(ray_missing, {.check_rays = false}));
+  }
+
+  {
+    SolveResult wrong_ray = expected;
+    wrong_ray.primal_rays[0].variable_values[y] = 1;
+    EXPECT_THAT(wrong_ray, Not(IsConsistentWith(expected)));
+    EXPECT_THAT(wrong_ray, IsConsistentWith(expected, {.check_rays = false}));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, Not(IsConsistentWith(wrong_ray)));
+    EXPECT_THAT(expected, IsConsistentWith(wrong_ray, {.check_rays = false}));
+  }
+}
+
+TEST(ResultsConsistentTest, UnboundedMultipleRays) {
+  Model model;
+  std::vector<Variable> xs;
+  for (int i = 0; i < 4; ++i) {
+    xs.push_back(model.AddContinuousVariable(0, 1, absl::StrCat("x_", i)));
+  }
+
+  SolveResult first{Termination::Unbounded(/*is_maximize=*/false)};
+  SolveResult second{Termination::Unbounded(/*is_maximize=*/false)};
+
+  for (int i = 0; i < 4; ++i) {
+    PrimalRay ray;
+    for (int j = 0; j < 4; ++j) {
+      ray.variable_values[xs[j]] = j == i ? 1 : 0;
+    }
+    if (i < 3) {
+      first.primal_rays.push_back(ray);
+    }
+    if (i > 0) {
+      second.primal_rays.push_back(ray);
+    }
+  }
+
+  EXPECT_THAT(first, IsConsistentWith(second));
+  EXPECT_THAT(first,
+              Not(IsConsistentWith(second, {.first_solution_only = false})));
+  // Reverse first and second, the result should match
+  EXPECT_THAT(second, IsConsistentWith(first));
+  EXPECT_THAT(second,
+              Not(IsConsistentWith(first, {.first_solution_only = false})));
+
+  EXPECT_THAT(first, IsConsistentWith(first, {.first_solution_only = false}));
+  EXPECT_THAT(second, IsConsistentWith(second, {.first_solution_only = false}));
+}
+
+TEST(ResultsConsistentTest, Infeasible) {
+  Model model;
+  const Variable x = model.AddContinuousVariable(0, 1, "x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+
+  SolveResult expected{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+  expected.dual_rays.push_back(
+      {.dual_values = {{c, 1}}, .reduced_costs = {{x, 0}}});
+
+  {
+    SolveResult actual = expected;
+    EXPECT_THAT(actual, IsConsistentWith(expected));
+    EXPECT_THAT(actual, IsConsistentWith(expected, {.check_rays = false}));
+    EXPECT_THAT(actual,
+                IsConsistentWith(expected, {.inf_or_unb_soft_match = false}));
+  }
+
+  {
+    SolveResult dual_infeasible = expected;
+    dual_infeasible.termination.reason =
+        TerminationReason::kInfeasibleOrUnbounded;
+    EXPECT_THAT(dual_infeasible, IsConsistentWith(expected));
+    EXPECT_THAT(
+        dual_infeasible,
+        Not(IsConsistentWith(expected, {.inf_or_unb_soft_match = false})));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, IsConsistentWith(dual_infeasible));
+    EXPECT_THAT(expected,
+                Not(IsConsistentWith(dual_infeasible,
+                                     {.inf_or_unb_soft_match = false})));
+  }
+
+  {
+    SolveResult with_dual = expected;
+    with_dual.solutions.push_back(
+        Solution{.dual_solution = DualSolution{.dual_values = {{c, 1}},
+                                               .reduced_costs = {{x, 1}},
+                                               .objective_value = 3.0}});
+    EXPECT_THAT(with_dual,
+                Not(IsConsistentWith(
+                    expected, {.check_solutions_if_inf_or_unbounded = true})));
+    EXPECT_THAT(with_dual, IsConsistentWith(expected));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected,
+                Not(IsConsistentWith(
+                    with_dual, {.check_solutions_if_inf_or_unbounded = true})));
+    EXPECT_THAT(expected, IsConsistentWith(with_dual));
+  }
+
+  {
+    SolveResult ray_missing = expected;
+    ray_missing.dual_rays.clear();
+    EXPECT_THAT(ray_missing, Not(IsConsistentWith(expected)));
+    EXPECT_THAT(ray_missing, IsConsistentWith(expected, {.check_rays = false}));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, Not(IsConsistentWith(ray_missing)));
+    EXPECT_THAT(expected, IsConsistentWith(ray_missing, {.check_rays = false}));
+  }
+
+  {
+    SolveResult wrong_ray = expected;
+    wrong_ray.dual_rays[0].reduced_costs[x] = 1;
+    EXPECT_THAT(wrong_ray, Not(IsConsistentWith(expected)));
+    EXPECT_THAT(wrong_ray, IsConsistentWith(expected, {.check_rays = false}));
+    // Flip the roles of actual and expected, should still hold.
+    EXPECT_THAT(expected, Not(IsConsistentWith(wrong_ray)));
+    EXPECT_THAT(expected, IsConsistentWith(wrong_ray, {.check_rays = false}));
+  }
+}
+
+TEST(ResultsConsistentTest, InfeasibleMultipleRays) {
+  Model model;
+  std::vector<Variable> xs;
+  for (int i = 0; i < 4; ++i) {
+    xs.push_back(model.AddContinuousVariable(0, 1, absl::StrCat("x_", i)));
+  }
+
+  SolveResult first{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+  SolveResult second{Termination::Infeasible(
+      /*is_maximize=*/false,
+      /*dual_feasibility_status=*/FeasibilityStatus::kFeasible)};
+
+  for (int i = 0; i < 4; ++i) {
+    DualRay ray;
+    for (int j = 0; j < 4; ++j) {
+      ray.reduced_costs[xs[j]] = j == i ? 1 : 0;
+    }
+    if (i < 3) {
+      first.dual_rays.push_back(ray);
+    }
+    if (i > 0) {
+      second.dual_rays.push_back(ray);
+    }
+  }
+
+  EXPECT_THAT(first, IsConsistentWith(second));
+  EXPECT_THAT(first,
+              Not(IsConsistentWith(second, {.first_solution_only = false})));
+  // Reverse first and second, the result should match
+  EXPECT_THAT(second, IsConsistentWith(first));
+  EXPECT_THAT(second,
+              Not(IsConsistentWith(first, {.first_solution_only = false})));
+
+  EXPECT_THAT(first, IsConsistentWith(first, {.first_solution_only = false}));
+  EXPECT_THAT(second, IsConsistentWith(second, {.first_solution_only = false}));
+}
+
+TEST(PrintToTest, SmallIdMap) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  VariableMap<double> vars = {{x, 1.0}, {y, 0.0}};
+  std::ostringstream oss;
+  PrintTo(vars, &oss);
+  EXPECT_EQ(oss.str(), "{{x, 1}, {y, 0}}");
+}
+
+TEST(PrintToTest, LargeIdMap) {
+  Model model;
+  std::vector<Variable> xs;
+  VariableMap<double> vars;
+  for (int i = 0; i < 100; ++i) {
+    xs.push_back(model.AddVariable(absl::StrCat("x", i)));
+    vars[xs.back()] = i;
+  }
+  std::ostringstream oss;
+  PrintTo(vars, &oss);
+  EXPECT_EQ(oss.str(),
+            "{{x0, 0}, {x1, 1}, {x2, 2}, {x3, 3}, {x4, 4}, {x5, 5}, {x6, 6}, "
+            "{x7, 7}, {x8, 8}, {x9, 9}, ...(size=100)}");
+}
+
+TEST(PrintToTest, BasisIdMap) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  VariableMap<BasisStatus> vars = {{x, BasisStatus::kAtLowerBound},
+                                   {y, BasisStatus::kAtUpperBound}};
+  std::ostringstream oss;
+  PrintTo(vars, &oss);
+  EXPECT_EQ(oss.str(), "{{x, at_lower_bound}, {y, at_upper_bound}}");
+}
+
+TEST(PrintToTest, PrimalSolution) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  PrimalSolution solution;
+  solution.variable_values = {{x, 1.0}, {y, 0.0}};
+  solution.objective_value = 12;
+  solution.feasibility_status = SolutionStatus::kFeasible;
+  std::ostringstream oss;
+  PrintTo(solution, &oss);
+  EXPECT_EQ(oss.str(),
+            "{variable_values: {{x, 1}, {y, 0}}, objective_value: 12, "
+            "feasibility_status: feasible}");
+}
+
+TEST(PrintToTest, PrimalRay) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  PrimalRay ray;
+  ray.variable_values = {{x, 1.0}, {y, 0.0}};
+  std::ostringstream oss;
+  PrintTo(ray, &oss);
+  EXPECT_EQ(oss.str(), "{variable_values: {{x, 1}, {y, 0}}}");
+}
+
+TEST(PrintToTest, DualSolution) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  const QuadraticConstraint d = model.AddQuadraticConstraint(x * x <= 0.0, "d");
+  DualSolution solution;
+  solution.reduced_costs = {{x, 1.0}, {y, 0.0}};
+  solution.dual_values = {{c, 2.0}};
+  solution.quadratic_dual_values = {{d, 3.0}};
+  solution.feasibility_status = SolutionStatus::kInfeasible;
+  std::ostringstream oss;
+  PrintTo(solution, &oss);
+  EXPECT_EQ(oss.str(),
+            "{dual_values: {{c, 2}}, quadratic_dual_values: {{d, 3}}, "
+            "reduced_costs: {{x, 1}, {y, 0}}, objective_value: (nullopt), "
+            "feasibility_status: infeasible}");
+}
+
+TEST(PrintToTest, DualRay) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  DualRay ray;
+  ray.reduced_costs = {{x, 1.0}, {y, 0.0}};
+  ray.dual_values = {{c, 2.0}};
+  std::ostringstream oss;
+  PrintTo(ray, &oss);
+  EXPECT_EQ(oss.str(),
+            "{dual_values: {{c, 2}}, reduced_costs: {{x, 1}, {y, 0}}}");
+}
+
+TEST(PrintToTest, Basis) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const Variable y = model.AddVariable("y");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  Basis basis;
+  basis.variable_status = {{x, BasisStatus::kAtUpperBound},
+                           {y, BasisStatus::kAtLowerBound}};
+  basis.constraint_status = {{c, BasisStatus::kAtLowerBound}};
+  basis.basic_dual_feasibility = SolutionStatus::kUndetermined;
+  std::ostringstream oss;
+  PrintTo(basis, &oss);
+  EXPECT_EQ(oss.str(),
+            "{variable_status: {{x, at_upper_bound}, {y, "
+            "at_lower_bound}}, "
+            "constraint_status: {{c, at_lower_bound}}, "
+            "basic_dual_feasibility: (undetermined)}");
+}
+
+TEST(PrintToTest, SolveResult) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  SolveResult result{Termination::Feasible(
+      /*is_maximize=*/false, Limit::kTime, /*finite_primal_objective=*/20.0,
+      /*optional_dual_objective=*/10.0, "hit \"3\" seconds")};
+  result.solve_stats.node_count = 2;
+  result.solve_stats.simplex_iterations = 0;
+  result.solve_stats.barrier_iterations = 0;
+  result.solve_stats.first_order_iterations = 0;
+
+  PrimalSolution primal;
+  primal.objective_value = 20.0;
+  primal.variable_values = {{x, 1}};
+  primal.feasibility_status = SolutionStatus::kFeasible;
+  DualSolution dual;
+  dual.reduced_costs = {{x, 1.0}};
+  dual.dual_values = {{c, 2.0}};
+  dual.objective_value = 10.0;
+  dual.feasibility_status = SolutionStatus::kFeasible;
+  Basis basis;
+  basis.variable_status = {{x, BasisStatus::kAtUpperBound}};
+  basis.constraint_status = {{c, BasisStatus::kAtLowerBound}};
+  basis.basic_dual_feasibility = SolutionStatus::kFeasible;
+  result.solutions.push_back(Solution{.primal_solution = std::move(primal),
+                                      .dual_solution = std::move(dual),
+                                      .basis = std::move(basis)});
+
+  PrimalRay primal_ray;
+  primal_ray.variable_values = {{x, 2}};
+  result.primal_rays.push_back(std::move(primal_ray));
+
+  DualRay dual_ray;
+  dual_ray.reduced_costs = {{x, 4.0}};
+  dual_ray.dual_values = {{c, 5.0}};
+  result.dual_rays.push_back(std::move(dual_ray));
+
+  std::ostringstream oss;
+  PrintTo(result, &oss);
+}
+
+TEST(IsFeasibleTest, Feasible) {
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kFeasible,
+                  .is_minimal = false,
+              }),
+              IsFeasible());
+
+  // True .is_minimal should not match.
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kFeasible,
+                  .is_minimal = true,
+              }),
+              Not(IsFeasible()));
+
+  // A non-empty .infeasible_subsystem should not match.
+  Model model;
+  const Variable x = model.AddIntegerVariable(
+      /*lower_bound=*/0.0, /*upper_bound=*/5.0, "x");
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kFeasible,
+                  .infeasible_subsystem =
+                      {
+                          .variable_integrality = {x},
+                      },
+                  .is_minimal = true,
+              }),
+              Not(IsFeasible()));
+}
+
+TEST(IsFeasibleTest, Undetermined) {
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kUndetermined,
+                  .is_minimal = false,
+              }),
+              Not(IsFeasible()));
+}
+
+TEST(IsFeasibleTest, Infeasible) {
+  Model model;
+  const Variable x = model.AddIntegerVariable(
+      /*lower_bound=*/0.0, /*upper_bound=*/5.0, "x");
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem =
+                      {
+                          .variable_integrality = {x},
+                      },
+                  .is_minimal = true,
+              }),
+              Not(IsFeasible()));
+}
+
+TEST(IsUndeterminedTest, Undetermined) {
+  // The value of .is_minimal should be ignored.
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kUndetermined,
+                  .is_minimal = false,
+              }),
+              IsUndetermined());
+
+  // True .is_minimal should not match.
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kUndetermined,
+                  .is_minimal = true,
+              }),
+              Not(IsUndetermined()));
+
+  // A non-empty .infeasible_subsystem should not match.
+  Model model;
+  const Variable x = model.AddIntegerVariable(
+      /*lower_bound=*/0.0, /*upper_bound=*/5.0, "x");
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kUndetermined,
+                  .infeasible_subsystem =
+                      {
+                          .variable_integrality = {x},
+                      },
+                  .is_minimal = true,
+              }),
+              Not(IsUndetermined()));
+}
+
+TEST(IsUndeterminedTest, Feasible) {
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kFeasible,
+                  .is_minimal = false,
+              }),
+              Not(IsUndetermined()));
+}
+
+TEST(IsUndeterminedTest, Infeasible) {
+  Model model;
+  const Variable x = model.AddIntegerVariable(
+      /*lower_bound=*/0.0, /*upper_bound=*/5.0, "x");
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem =
+                      {
+                          .variable_integrality = {x},
+                      },
+                  .is_minimal = true,
+              }),
+              Not(IsUndetermined()));
+}
+
+TEST(IsInfeasibleTest, Infeasible) {
+  Model model;
+  const Variable x = model.AddIntegerVariable(
+      /*lower_bound=*/0.0, /*upper_bound=*/5.0, "x");
+
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem =
+                      {
+                          .variable_integrality = {x},
+                      },
+                  .is_minimal = true,
+              }),
+              IsInfeasible());
+
+  // Same with .is_minimal = false.
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem =
+                      {
+                          .variable_integrality = {x},
+                      },
+                  .is_minimal = false,
+              }),
+              IsInfeasible());
+
+  // Empty .infeasible_subsystem should not match.
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .is_minimal = true,
+              }),
+              Not(IsInfeasible()));
+
+  // Testing .expected_is_minimal.
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem = {.variable_integrality = {x}},
+                  .is_minimal = false,
+              }),
+              IsInfeasible(/*expected_is_minimal=*/false));
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem = {.variable_integrality = {x}},
+                  .is_minimal = false,
+              }),
+              Not(IsInfeasible(/*expected_is_minimal=*/true)));
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem = {.variable_integrality = {x}},
+                  .is_minimal = true,
+              }),
+              Not(IsInfeasible(/*expected_is_minimal=*/false)));
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem = {.variable_integrality = {x}},
+                  .is_minimal = true,
+              }),
+              IsInfeasible(/*expected_is_minimal=*/true));
+
+  // Testing .expected_infeasible_subsystem.
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kInfeasible,
+                  .infeasible_subsystem =
+                      {
+                          .variable_integrality = {x},
+                      },
+                  .is_minimal = false,
+              }),
+              IsInfeasible(/*expected_is_minimal=*/std::nullopt,
+                           /*expected_infeasible_subsystem=*/ModelSubset{
+                               .variable_integrality = {x},
+                           }));
+}
+
+TEST(IsInfeasibleTest, Feasible) {
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kFeasible,
+                  .is_minimal = false,
+              }),
+              Not(IsInfeasible()));
+}
+
+TEST(IsInfeasibleTest, Undetermined) {
+  EXPECT_THAT((ComputeInfeasibleSubsystemResult{
+                  .feasibility = FeasibilityStatus::kUndetermined,
+                  .is_minimal = false,
+              }),
+              Not(IsInfeasible()));
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/message_callback.cc b/ortools/math_opt/cpp/message_callback.cc
index 7c33a6aa62..b9d6959691 100644
--- a/ortools/math_opt/cpp/message_callback.cc
+++ b/ortools/math_opt/cpp/message_callback.cc
@@ -38,7 +38,7 @@ class PrinterMessageCallbackImpl {
       : output_stream_(output_stream), prefix_(prefix) {}
 
   void Call(absl::Span<const std::string> messages) {
-    const absl::MutexLock lock(&mutex_);
+    const absl::MutexLock lock(mutex_);
     for (const std::string& message : messages) {
       output_stream_ << prefix_ << message << '\n';
     }
@@ -69,7 +69,7 @@ class VectorLikeMessageCallbackImpl {
       : sink_(ABSL_DIE_IF_NULL(sink)) {}
 
   void Call(absl::Span<const std::string> messages) {
-    const absl::MutexLock lock(&mutex_);
+    const absl::MutexLock lock(mutex_);
     PushBack(messages, sink_);
   }
 
@@ -92,7 +92,7 @@ MessageCallback PrinterMessageCallback(std::ostream& output_stream,
 
 MessageCallback InfoLoggerMessageCallback(const absl::string_view prefix,
                                           const absl::SourceLocation loc) {
-  return [=](const std::vector<std::string>& messages) {
+  return [=](absl::Span<const std::string> messages) {
     for (const std::string& message : messages) {
       LOG(INFO).AtLocation(loc.file_name(), loc.line()) << prefix << message;
     }
@@ -127,8 +127,7 @@ MessageCallback RepeatedPtrFieldMessageCallback(
   // it uses an absl::Mutex that is not.
   const auto impl = std::make_shared<VectorLikeMessageCallbackImpl<
       google::protobuf::RepeatedPtrField<std::string>>>(sink);
-  return
-      [=](const std::vector<std::string>& messages) { impl->Call(messages); };
+  return [=](absl::Span<const std::string> messages) { impl->Call(messages); };
 }
 
 }  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/message_callback_test.cc b/ortools/math_opt/cpp/message_callback_test.cc
new file mode 100644
index 0000000000..cf5b240b15
--- /dev/null
+++ b/ortools/math_opt/cpp/message_callback_test.cc
@@ -0,0 +1,415 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/message_callback.h"
+
+#include <limits>
+#include <memory>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/flags/flag.h"
+#include "absl/log/log.h"
+#include "absl/status/statusor.h"
+#include "google/protobuf/repeated_ptr_field.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/logging.h"
+#include "ortools/math_opt/callback.pb.h"
+#include "ortools/math_opt/core/solver_interface.h"
+#include "ortools/math_opt/core/solver_interface_mock.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/model_parameters.pb.h"
+#include "ortools/math_opt/solution.pb.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+#include "testing/base/public/mock-log.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+using ::base_logging::INFO;
+using ::testing::_;
+using ::testing::ByMove;
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using ::testing::EquivToProto;
+using ::testing::InSequence;
+using ::testing::kDoNotCaptureLogsYet;
+using ::testing::Ne;
+using ::testing::Return;
+using ::testing::ScopedMockLog;
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+// Basic LP model:
+//
+//   a and b are continuous variable
+//
+//   minimize a - b
+//       s.t. 0 <= a
+//            0 <= b <= 3
+struct BasicLp {
+  BasicLp();
+
+  // Returns the expected optimal result for this model. Only put the given set
+  // of variables in the result (to test filters).
+  SolveResultProto OptimalResult(
+      const absl::flat_hash_set<Variable>& vars) const;
+
+  Model model;
+  const Variable a;
+  const Variable b;
+};
+
+BasicLp::BasicLp()
+    : a(model.AddVariable(0.0, kInf, false, "a")),
+      b(model.AddVariable(0.0, 3.0, false, "b")) {}
+
+SolveResultProto BasicLp::OptimalResult(
+    const absl::flat_hash_set<Variable>& vars) const {
+  SolveResultProto result;
+  result.mutable_termination()->set_reason(TERMINATION_REASON_OPTIMAL);
+  result.mutable_solve_stats()->mutable_problem_status()->set_primal_status(
+      FEASIBILITY_STATUS_FEASIBLE);
+  result.mutable_solve_stats()->mutable_problem_status()->set_dual_status(
+      FEASIBILITY_STATUS_FEASIBLE);
+  PrimalSolutionProto* const solution =
+      result.add_solutions()->mutable_primal_solution();
+  solution->set_objective_value(0.0);
+  solution->set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  if (vars.contains(a)) {
+    solution->mutable_variable_values()->add_ids(a.id());
+    solution->mutable_variable_values()->add_values(0.0);
+  }
+  if (vars.contains(b)) {
+    solution->mutable_variable_values()->add_ids(b.id());
+    solution->mutable_variable_values()->add_values(3.0);
+  }
+  return result;
+}
+
+TEST(PrinterMessageCallbackTest, StringStream) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  std::ostringstream oss;
+  const SolveArguments args = {.message_callback =
+                                   PrinterMessageCallback(oss, "logs| ")};
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback,
+          const SolveInterrupter*) -> absl::StatusOr<SolveResultProto> {
+    message_cb({"line 1", "line 2"});
+    message_cb({"line 3"});
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Ne(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_EQ(oss.str(), "logs| line 1\nlogs| line 2\nlogs| line 3\n");
+}
+
+TEST(InfoLoggerMessageCallbackTest, Logging) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  std::ostringstream oss;
+  const SolveArguments args = {.message_callback =
+                                   InfoLoggerMessageCallback("logs| ")};
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback,
+          const SolveInterrupter*) -> absl::StatusOr<SolveResultProto> {
+    message_cb({"line 1", "line 2"});
+    message_cb({"line 3"});
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  ScopedMockLog log(kDoNotCaptureLogsYet);
+
+  // Expected file path for testing logs.
+  const std::string test_path = "ortools/math_opt/cpp/message_callback_test.cc";
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Ne(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+    EXPECT_CALL(log, Log(INFO, test_path, "logs| line 1"));
+    EXPECT_CALL(log, Log(INFO, test_path, "logs| line 2"));
+    EXPECT_CALL(log, Log(INFO, test_path, "logs| line 3"));
+  }
+
+  log.StartCapturingLogs();
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+}
+
+// In this test we set the `-v` flag to enable verbose logging.
+TEST(VLoggerMessageCallbackTest, VisibleLog) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  std::ostringstream oss;
+  const SolveArguments args = {.message_callback =
+                                   VLoggerMessageCallback(1, "logs| ")};
+
+  // Flags local to each test, see go/gunitprimer#invoking-the-tests.
+  absl::SetFlag(&FLAGS_v, true);
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback,
+          const SolveInterrupter*) -> absl::StatusOr<SolveResultProto> {
+    message_cb({"line 1", "line 2"});
+    message_cb({"line 3"});
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  ScopedMockLog log(kDoNotCaptureLogsYet);
+
+  // Expected file path for testing logs.
+  const std::string test_path = "ortools/math_opt/cpp/message_callback_test.cc";
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Ne(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+    EXPECT_CALL(log, Log(INFO, test_path, "logs| line 1"));
+    EXPECT_CALL(log, Log(INFO, test_path, "logs| line 2"));
+    EXPECT_CALL(log, Log(INFO, test_path, "logs| line 3"));
+  }
+
+  log.StartCapturingLogs();
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+}
+
+// In this test we set the `-v` flag to false to disable verbose logging.
+TEST(VLoggerMessageCallbackTest, InvisibleLog) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  std::ostringstream oss;
+  const SolveArguments args = {.message_callback =
+                                   VLoggerMessageCallback(1, "logs| ")};
+
+  // Flags local to each test, see go/gunitprimer#invoking-the-tests.
+  absl::SetFlag(&FLAGS_v, false);
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback,
+          const SolveInterrupter*) -> absl::StatusOr<SolveResultProto> {
+    message_cb({"line 1", "line 2"});
+    message_cb({"line 3"});
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  ScopedMockLog log(kDoNotCaptureLogsYet);
+
+  // Expected file path for testing logs.
+  const std::string test_path = "ortools/math_opt/cpp/message_callback_test.cc";
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Ne(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+  }
+
+  log.StartCapturingLogs();
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+}
+
+TEST(VectorMessageCallbackTest, Basic) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  std::vector<std::string> messages = {"initial content 1",
+                                       "initial content 2"};
+  const SolveArguments args = {.message_callback =
+                                   VectorMessageCallback(&messages)};
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback,
+          const SolveInterrupter*) -> absl::StatusOr<SolveResultProto> {
+    message_cb({"line 1", "line 2"});
+    message_cb({"line 3"});
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Ne(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(messages, ElementsAre("initial content 1", "initial content 2",
+                                    "line 1", "line 2", "line 3"));
+}
+
+TEST(RepeatedPtrFieldMessageCallbackTest, Basic) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  google::protobuf::RepeatedPtrField<std::string> messages;
+  messages.Add("initial content 1");
+  messages.Add("initial content 2");
+  const SolveArguments args = {.message_callback =
+                                   RepeatedPtrFieldMessageCallback(&messages)};
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback,
+          const SolveInterrupter*) -> absl::StatusOr<SolveResultProto> {
+    message_cb({"line 1", "line 2"});
+    message_cb({"line 3"});
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Ne(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(messages, ElementsAre("initial content 1", "initial content 2",
+                                    "line 1", "line 2", "line 3"));
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/model_solve_parameters_test.cc b/ortools/math_opt/cpp/model_solve_parameters_test.cc
new file mode 100644
index 0000000000..dfca7165b5
--- /dev/null
+++ b/ortools/math_opt/cpp/model_solve_parameters_test.cc
@@ -0,0 +1,742 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/model_solve_parameters.h"
+
+#include <array>
+#include <optional>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/time/time.h"
+#include "google/protobuf/duration.pb.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/map_util.h"
+#include "ortools/math_opt/cpp/linear_constraint.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/cpp/model.h"
+#include "ortools/math_opt/cpp/solution.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/model_parameters.pb.h"
+#include "ortools/math_opt/solution.pb.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+#include "ortools/math_opt/storage/model_storage.h"
+#include "util/tuple/struct.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+using ::testing::EquivToProto;
+using ::testing::HasSubstr;
+using ::testing::Pair;
+using ::testing::UnorderedElementsAre;
+using ::testing::status::IsOkAndHolds;
+using ::testing::status::StatusIs;
+
+// Define the value of MapFilter.storage() we want in the test for a filter.
+//
+// In below tests, we cover all possible combinations of filters with same or
+// different value for storage() (either for death testing of regular testing).
+// To have total coverage, we only need to test with three models max since we
+// have three filters.
+//
+// The cases to test are the one in the set {null, 1, 2, 3}^3. The cases with
+// different non null models are the one expected to crash, the others (using
+// one or more times the same model) are expected to pass.
+enum FilterModel {
+  // The filter has no model (no referencing any variable or constraint).
+  kNullModel,
+  // The filter points the first test model.
+  kModel1,
+  // The filter points the second test model.
+  kModel2,
+  // The filter points the third test model.
+  kModel3,
+};
+
+const std::array<FilterModel, 4> kAllFilterModels = {kNullModel, kModel1,
+                                                     kModel2, kModel3};
+
+// A combination of filter models to test, one model for each filter in
+// ModelSolveParameters.
+struct FilterModelsCombination {
+  TUPLE_DEFINE_STRUCT(FilterModelsCombination, (ostream, ctor),
+                      (FilterModel, variable_values_filter_model),
+                      (FilterModel, dual_values_filter_model),
+                      (FilterModel, reduced_costs_filter_model));
+
+  // Returns a non nullopt value if and only if all filters have either the same
+  // model or a null model. If all filter have a null model, kNullModel is
+  // returned.
+  std::optional<FilterModel> common_storage() const;
+
+  // Returns true if the combination is expected to pass (i.e. it has a common
+  // model), false if it is expected to die (i.e. it references at least two
+  // different models).
+  bool ok() const;
+};
+
+std::optional<FilterModel> FilterModelsCombination::common_storage() const {
+  const std::vector<FilterModel> models = {variable_values_filter_model,
+                                           dual_values_filter_model,
+                                           reduced_costs_filter_model};
+  FilterModel ret = kNullModel;
+  for (const auto model : models) {
+    if (model != kNullModel) {
+      if (ret == kNullModel) {
+        ret = model;
+      } else if (model != ret) {
+        return std::nullopt;
+      }
+    }
+  }
+  return ret;
+}
+
+bool FilterModelsCombination::ok() const {
+  return common_storage().has_value();
+}
+
+// Returns all possible model combinations.
+std::vector<FilterModelsCombination> AllCombinations() {
+  std::vector<FilterModelsCombination> ret;
+  for (const FilterModel primal_vars_model : kAllFilterModels) {
+    for (const FilterModel dual_cstrs_model : kAllFilterModels) {
+      for (const FilterModel dual_vars_model : kAllFilterModels) {
+        ret.emplace_back(primal_vars_model, dual_cstrs_model, dual_vars_model);
+      }
+    }
+  }
+  return ret;
+}
+
+// Test fixture for testing filter models combinations.
+class FilterModelsCombinationTest : public ::testing::Test {
+ public:
+  FilterModelsCombinationTest()
+      : a_1_(&model_1_, model_1_.AddVariable("a_1")),
+        cstr_1_(&model_1_, model_1_.AddLinearConstraint("cstr_1")),
+        a_2_(&model_2_, model_2_.AddVariable("a_2")),
+        cstr_2_(&model_2_, model_2_.AddLinearConstraint("cstr_2")),
+        a_3_(&model_3_, model_3_.AddVariable("a_3")),
+        cstr_3_(&model_3_, model_3_.AddLinearConstraint("cstr_3")) {}
+
+ protected:
+  // Returns a filter for the given model. The input model_to_key is expected to
+  // contain a value for each FilterModel but kNullModel.
+  template <typename K>
+  MapFilter<K> MakeMapFilter(
+      const FilterModel model,
+      const absl::flat_hash_map<FilterModel, K>& model_to_key) {
+    MapFilter<K> ret;
+
+    if (model == kNullModel) {
+      return ret;
+    }
+
+    ret.filtered_keys = {gtl::FindOrDie(model_to_key, model)};
+    return ret;
+  }
+
+  ModelSolveParameters MakeParameters(
+      const FilterModelsCombination& combination) {
+    const absl::flat_hash_map<FilterModel, Variable> vars = {
+        {kModel1, a_1_},
+        {kModel2, a_2_},
+        {kModel3, a_3_},
+    };
+    const absl::flat_hash_map<FilterModel, LinearConstraint> cstrs = {
+        {kModel1, cstr_1_},
+        {kModel2, cstr_2_},
+        {kModel3, cstr_3_},
+    };
+    ModelSolveParameters params;
+    params.variable_values_filter =
+        MakeMapFilter(combination.variable_values_filter_model, vars);
+    params.dual_values_filter =
+        MakeMapFilter(combination.dual_values_filter_model, cstrs);
+    params.reduced_costs_filter =
+        MakeMapFilter(combination.reduced_costs_filter_model, vars);
+    return params;
+  }
+
+  ModelStorage model_1_;
+  const Variable a_1_;
+  const LinearConstraint cstr_1_;
+  ModelStorage model_2_;
+  const Variable a_2_;
+  const LinearConstraint cstr_2_;
+  ModelStorage model_3_;
+  const Variable a_3_;
+  const LinearConstraint cstr_3_;
+};
+
+using FilterModelsCombinationDeathTest = FilterModelsCombinationTest;
+
+TEST(ModelSolveParametersTest, Default) {
+  ModelStorage model;
+  const ModelSolveParameters params;
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto("")));
+  EXPECT_OK(params.CheckModelStorage(&model));
+}
+
+TEST(ModelSolveParametersTest, SetFiltersSameModel) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+  const Variable b(&model, model.AddVariable("b"));
+  const LinearConstraint cstr(&model, model.AddLinearConstraint("cstr"));
+
+  ModelSolveParameters params;
+  params.variable_values_filter = MakeKeepKeysFilter({a});
+  params.dual_values_filter = MakeKeepKeysFilter({cstr});
+  params.reduced_costs_filter = MakeKeepKeysFilter({b});
+
+  ModelSolveParametersProto expected;
+  expected.mutable_variable_values_filter()->set_filter_by_ids(true);
+  expected.mutable_variable_values_filter()->add_filtered_ids(a.id());
+  expected.mutable_dual_values_filter()->set_filter_by_ids(true);
+  expected.mutable_dual_values_filter()->add_filtered_ids(cstr.id());
+  expected.mutable_reduced_costs_filter()->set_filter_by_ids(true);
+  expected.mutable_reduced_costs_filter()->add_filtered_ids(b.id());
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+  EXPECT_OK(params.CheckModelStorage(&model));
+}
+
+TEST_F(FilterModelsCombinationTest, ValidCombinations) {
+  const absl::flat_hash_map<FilterModel, NullableModelStorageCPtr> models = {
+      {kNullModel, nullptr},
+      {kModel1, &model_1_},
+      {kModel2, &model_2_},
+      {kModel3, &model_3_},
+  };
+  for (const FilterModelsCombination& combination : AllCombinations()) {
+    if (!combination.ok()) {
+      continue;
+    }
+
+    SCOPED_TRACE(combination);
+    const ModelSolveParameters params = MakeParameters(combination);
+
+    const std::optional<FilterModel> model = combination.common_storage();
+    ASSERT_TRUE(model.has_value());
+    const NullableModelStorageCPtr expected_model =
+        gtl::FindOrDie(models, *model);
+    if (expected_model != nullptr) {
+      EXPECT_OK(params.CheckModelStorage(expected_model));
+    } else {
+      EXPECT_OK(params.CheckModelStorage(&model_1_));
+      EXPECT_OK(params.CheckModelStorage(&model_2_));
+      EXPECT_OK(params.CheckModelStorage(&model_3_));
+    }
+  }
+}
+
+TEST_F(FilterModelsCombinationTest, InvalidCombinations) {
+  for (const FilterModelsCombination& combination : AllCombinations()) {
+    if (combination.ok()) {
+      continue;
+    }
+
+    SCOPED_TRACE(combination);
+    const ModelSolveParameters params = MakeParameters(combination);
+    EXPECT_THAT(params.CheckModelStorage(&model_1_),
+                StatusIs(absl::StatusCode::kInvalidArgument,
+                         HasSubstr(internal::kInputFromInvalidModelStorage)));
+    EXPECT_THAT(params.CheckModelStorage(&model_2_),
+                StatusIs(absl::StatusCode::kInvalidArgument,
+                         HasSubstr(internal::kInputFromInvalidModelStorage)));
+    EXPECT_THAT(params.CheckModelStorage(&model_3_),
+                StatusIs(absl::StatusCode::kInvalidArgument,
+                         HasSubstr(internal::kInputFromInvalidModelStorage)));
+  }
+}
+
+TEST(ModelSolveParametersTest, OnlyPrimalVariables) {
+  ModelStorage model;
+  const ModelSolveParameters params =
+      ModelSolveParameters::OnlyPrimalVariables();
+
+  EXPECT_THAT(params.Proto(),
+              IsOkAndHolds(EquivToProto(
+                  R"pb(dual_values_filter { filter_by_ids: true }
+                       quadratic_dual_values_filter { filter_by_ids: true }
+                       reduced_costs_filter { filter_by_ids: true })pb")));
+  EXPECT_OK(params.CheckModelStorage(&model));
+}
+
+TEST(ModelSolveParametersTest, OnlySomePrimalVariablesInitializerList) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+
+  const ModelSolveParameters params =
+      ModelSolveParameters::OnlySomePrimalVariables({a});
+
+  ModelSolveParametersProto expected;
+  expected.mutable_variable_values_filter()->set_filter_by_ids(true);
+  expected.mutable_variable_values_filter()->add_filtered_ids(a.id());
+  expected.mutable_dual_values_filter()->set_filter_by_ids(true);
+  expected.mutable_quadratic_dual_values_filter()->set_filter_by_ids(true);
+  expected.mutable_reduced_costs_filter()->set_filter_by_ids(true);
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+  EXPECT_OK(params.CheckModelStorage(&model));
+}
+
+TEST(ModelSolveParametersTest, OnlySomePrimalVariablesVector) {
+  ModelStorage model;
+  const Variable a(&model, model.AddVariable("a"));
+
+  const std::vector<Variable> vars = {a};
+  const ModelSolveParameters params =
+      ModelSolveParameters::OnlySomePrimalVariables(vars);
+
+  ModelSolveParametersProto expected;
+  expected.mutable_variable_values_filter()->set_filter_by_ids(true);
+  expected.mutable_variable_values_filter()->add_filtered_ids(a.id());
+  expected.mutable_dual_values_filter()->set_filter_by_ids(true);
+  expected.mutable_quadratic_dual_values_filter()->set_filter_by_ids(true);
+  expected.mutable_reduced_costs_filter()->set_filter_by_ids(true);
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+  EXPECT_OK(params.CheckModelStorage(&model));
+}
+
+TEST(ModelSolveParametersTest, BasisStart) {
+  ModelStorage model;
+  const Variable x1(&model, model.AddVariable("x1"));
+  const Variable x2(&model, model.AddVariable("x2"));
+  const LinearConstraint c1(&model, model.AddLinearConstraint("c1"));
+  const LinearConstraint c2(&model, model.AddLinearConstraint("c2"));
+  ModelSolveParameters params;
+  auto& initial_basis = params.initial_basis.emplace();
+  initial_basis.variable_status.insert(
+      {{x1, BasisStatus::kAtUpperBound}, {x2, BasisStatus::kBasic}});
+  initial_basis.constraint_status.insert(
+      {{c1, BasisStatus::kAtLowerBound}, {c2, BasisStatus::kBasic}});
+
+  EXPECT_OK(params.CheckModelStorage(&model));
+
+  ModelSolveParametersProto expected;
+  expected.mutable_initial_basis()->mutable_constraint_status()->add_ids(
+      c1.id());
+  expected.mutable_initial_basis()->mutable_constraint_status()->add_ids(
+      c2.id());
+  expected.mutable_initial_basis()->mutable_constraint_status()->add_values(
+      BASIS_STATUS_AT_LOWER_BOUND);
+  expected.mutable_initial_basis()->mutable_constraint_status()->add_values(
+      BASIS_STATUS_BASIC);
+  expected.mutable_initial_basis()->mutable_variable_status()->add_ids(x1.id());
+  expected.mutable_initial_basis()->mutable_variable_status()->add_ids(x2.id());
+  expected.mutable_initial_basis()->mutable_variable_status()->add_values(
+      BASIS_STATUS_AT_UPPER_BOUND);
+  expected.mutable_initial_basis()->mutable_variable_status()->add_values(
+      BASIS_STATUS_BASIC);
+  expected.mutable_initial_basis()->set_basic_dual_feasibility(
+      SolutionStatusProto::SOLUTION_STATUS_UNSPECIFIED);
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+}
+
+TEST(ModelSolveParametersTest, FilterAndBasisDifferentModels) {
+  ModelStorage model_a;
+  const Variable a_x(&model_a, model_a.AddVariable("x"));
+  ModelStorage model_b;
+  const Variable b_x(&model_b, model_b.AddVariable("x"));
+
+  const ModelSolveParameters params = {
+      .variable_values_filter = {.filtered_keys = {{a_x}}},
+      .initial_basis = Basis{.variable_status = {{b_x, BasisStatus::kFree}}},
+  };
+
+  EXPECT_THAT(params.CheckModelStorage(&model_a),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+  EXPECT_THAT(params.CheckModelStorage(&model_b),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(ModelSolveParametersTest, SolutionHint) {
+  ModelStorage model;
+  const Variable x1(&model, model.AddVariable("x1"));
+  const Variable x2(&model, model.AddVariable("x2"));
+  const Variable x3(&model, model.AddVariable("x3"));
+  const LinearConstraint c1(&model, model.AddLinearConstraint("c1"));
+  ModelSolveParameters params;
+
+  ModelSolveParameters::SolutionHint first_hint;
+  first_hint.variable_values.emplace(x1, 1.0);
+  first_hint.variable_values.emplace(x3, 0.0);
+  first_hint.dual_values.emplace(c1, 5.25);
+  params.solution_hints.emplace_back(first_hint);
+  ModelSolveParameters::SolutionHint second_hint;
+  second_hint.variable_values.emplace(x1, 1.0);
+  second_hint.variable_values.emplace(x2, 0.0);
+  params.solution_hints.emplace_back(second_hint);
+
+  EXPECT_OK(params.CheckModelStorage(&model));
+  EXPECT_OK(first_hint.CheckModelStorage(&model));
+  EXPECT_OK(second_hint.CheckModelStorage(&model));
+
+  ModelSolveParametersProto expected;
+  SolutionHintProto& first_expected_hint = *expected.add_solution_hints();
+  first_expected_hint.mutable_variable_values()->add_ids(x1.id());
+  first_expected_hint.mutable_variable_values()->add_values(1.0);
+  first_expected_hint.mutable_variable_values()->add_ids(x3.id());
+  first_expected_hint.mutable_variable_values()->add_values(0.0);
+  first_expected_hint.mutable_dual_values()->add_ids(c1.id());
+  first_expected_hint.mutable_dual_values()->add_values(5.25);
+  SolutionHintProto& second_expected_hint = *expected.add_solution_hints();
+  second_expected_hint.mutable_variable_values()->add_ids(x1.id());
+  second_expected_hint.mutable_variable_values()->add_values(1.0);
+  second_expected_hint.mutable_variable_values()->add_ids(x2.id());
+  second_expected_hint.mutable_variable_values()->add_values(0.0);
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+  EXPECT_THAT(first_hint.Proto(), EquivToProto(first_expected_hint));
+  EXPECT_THAT(second_hint.Proto(), EquivToProto(second_expected_hint));
+}
+
+TEST(ModelSolveParametersTest, FilterAndHintDifferentModels) {
+  ModelStorage model_a;
+  const Variable a_x(&model_a, model_a.AddVariable("x"));
+  ModelStorage model_b;
+  const Variable b_x(&model_b, model_b.AddVariable("x"));
+
+  const ModelSolveParameters params = {
+      .variable_values_filter = {.filtered_keys = {{a_x}}},
+      .solution_hints = {{.variable_values = {{b_x, 1.0}}}},
+  };
+
+  EXPECT_THAT(params.CheckModelStorage(&model_a),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+  EXPECT_THAT(params.CheckModelStorage(&model_b),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(ModelSolveParametersTest, BranchingPriority) {
+  ModelStorage model;
+  const Variable x1(&model, model.AddVariable("x1"));
+  const Variable x2(&model, model.AddVariable("x2"));
+  const Variable x3(&model, model.AddVariable("x3"));
+  ModelSolveParameters params;
+
+  params.branching_priorities.emplace(x1, 2);
+  params.branching_priorities.emplace(x3, 1);
+
+  ModelSolveParametersProto expected;
+  expected.mutable_branching_priorities()->add_ids(x1.id());
+  expected.mutable_branching_priorities()->add_values(2);
+  expected.mutable_branching_priorities()->add_ids(x3.id());
+  expected.mutable_branching_priorities()->add_values(1);
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+}
+
+TEST(ModelSolveParametersTest, BranchingPriorityOtherModel) {
+  Model model;
+  Model other;
+  const Variable x = other.AddVariable("x");
+  const ModelSolveParameters params{.branching_priorities = {{x, 2}}};
+  EXPECT_THAT(params.CheckModelStorage(model.storage()),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(ModelSolveParametersTest, ObjectiveParameters) {
+  ModelStorage model;
+  const auto primary = Objective::Primary(&model);
+  const auto secondary = Objective::Auxiliary(&model, AuxiliaryObjectiveId(2));
+  ModelSolveParameters params;
+  params.objective_parameters[primary]
+      .objective_degradation_absolute_tolerance = 3.0;
+  params.objective_parameters[primary]
+      .objective_degradation_relative_tolerance = 4.0;
+  params.objective_parameters[primary].time_limit = absl::Seconds(10);
+  params.objective_parameters[secondary]
+      .objective_degradation_absolute_tolerance = 5.0;
+  params.objective_parameters[secondary]
+      .objective_degradation_relative_tolerance = 6.0;
+  params.objective_parameters[secondary].time_limit = absl::Seconds(20);
+
+  ModelSolveParametersProto expected;
+  expected.mutable_primary_objective_parameters()
+      ->set_objective_degradation_absolute_tolerance(3.0);
+  expected.mutable_primary_objective_parameters()
+      ->set_objective_degradation_relative_tolerance(4.0);
+  expected.mutable_primary_objective_parameters()
+      ->mutable_time_limit()
+      ->set_seconds(10);
+  (*expected.mutable_auxiliary_objective_parameters())[2]
+      .set_objective_degradation_absolute_tolerance(5.0);
+  (*expected.mutable_auxiliary_objective_parameters())[2]
+      .set_objective_degradation_relative_tolerance(6.0);
+  expected.mutable_auxiliary_objective_parameters()
+      ->at(2)
+      .mutable_time_limit()
+      ->set_seconds(20);
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+}
+
+TEST(ModelSolveParametersTest, ObjectiveParametersOtherModel) {
+  Model model;
+  Model other;
+  const auto o = other.primary_objective();
+  const ModelSolveParameters params{.objective_parameters = {{o, {}}}};
+  EXPECT_THAT(params.CheckModelStorage(model.storage()),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(ModelSolveParametersTest, LazyLinearConstraints) {
+  Model model;
+  const LinearConstraint c = model.AddLinearConstraint("c");
+  model.AddLinearConstraint("d");
+  const LinearConstraint e = model.AddLinearConstraint("e");
+  ModelSolveParameters params{.lazy_linear_constraints = {c, e}};
+
+  ModelSolveParametersProto expected;
+  expected.add_lazy_linear_constraint_ids(c.id());
+  expected.add_lazy_linear_constraint_ids(e.id());
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+}
+
+TEST(ModelSolveParametersTest, LazyLinearConstraintsOtherModel) {
+  Model model;
+  Model other;
+  const LinearConstraint c = other.AddLinearConstraint("c");
+  const ModelSolveParameters params{.lazy_linear_constraints = {c}};
+  EXPECT_THAT(params.CheckModelStorage(model.storage()),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(ModelSolveParametersTest, FromProtoEmptyRoundTrip) {
+  const Model model;
+  const ModelSolveParametersProto proto;
+
+  ASSERT_OK_AND_ASSIGN(const auto params,
+                       ModelSolveParameters::FromProto(model, proto));
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(proto)));
+}
+
+TEST(ModelSolveParametersTest, FromProtoFullRoundTrip) {
+  Model model;
+  const Variable x = model.AddVariable();
+  model.AddVariable();
+  model.AddLinearConstraint();
+  model.AddLinearConstraint();
+  model.AddQuadraticConstraint(x * x <= 0.0);
+  model.AddQuadraticConstraint(x * x <= 0.0);
+  model.AddAuxiliaryObjective(2);
+  model.AddAuxiliaryObjective(3);
+
+  ModelSolveParametersProto proto;
+  proto.mutable_variable_values_filter()->set_filter_by_ids(true);
+  proto.mutable_variable_values_filter()->add_filtered_ids(1);
+
+  proto.mutable_dual_values_filter()->set_filter_by_ids(true);
+  proto.mutable_dual_values_filter()->add_filtered_ids(0);
+
+  proto.mutable_quadratic_dual_values_filter()->set_filter_by_ids(true);
+  proto.mutable_quadratic_dual_values_filter()->add_filtered_ids(0);
+
+  proto.mutable_reduced_costs_filter()->set_skip_zero_values(true);
+
+  proto.mutable_initial_basis()->set_basic_dual_feasibility(
+      SolutionStatusProto::SOLUTION_STATUS_FEASIBLE);
+  auto& basis_vars = *proto.mutable_initial_basis()->mutable_variable_status();
+  basis_vars.add_ids(0);
+  basis_vars.add_ids(1);
+  basis_vars.add_values(BasisStatusProto::BASIS_STATUS_BASIC);
+  basis_vars.add_values(BasisStatusProto::BASIS_STATUS_BASIC);
+
+  auto& basis_cons =
+      *proto.mutable_initial_basis()->mutable_constraint_status();
+  basis_cons.add_ids(0);
+  basis_cons.add_ids(1);
+  basis_cons.add_values(BasisStatusProto::BASIS_STATUS_AT_LOWER_BOUND);
+  basis_cons.add_values(BasisStatusProto::BASIS_STATUS_AT_UPPER_BOUND);
+
+  SolutionHintProto& hint = *proto.add_solution_hints();
+  hint.mutable_variable_values()->add_ids(0);
+  hint.mutable_variable_values()->add_ids(1);
+  hint.mutable_variable_values()->add_values(10.0);
+  hint.mutable_variable_values()->add_values(20.0);
+
+  proto.mutable_branching_priorities()->add_ids(1);
+  proto.mutable_branching_priorities()->add_values(3);
+
+  proto.mutable_primary_objective_parameters()
+      ->set_objective_degradation_absolute_tolerance(0.5);
+  proto.mutable_primary_objective_parameters()
+      ->mutable_time_limit()
+      ->set_seconds(10);
+
+  (*proto.mutable_auxiliary_objective_parameters())[1]
+      .set_objective_degradation_relative_tolerance(0.2);
+  (*proto.mutable_auxiliary_objective_parameters())[1]
+      .mutable_time_limit()
+      ->set_seconds(20);
+
+  ASSERT_OK_AND_ASSIGN(const auto params,
+                       ModelSolveParameters::FromProto(model, proto));
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(proto)));
+}
+
+TEST(ModelSolveParametersTest, FromProtoInvalidAuxObj) {
+  const Model model;
+  ModelSolveParametersProto proto;
+  (*proto.mutable_auxiliary_objective_parameters())[1]
+      .set_objective_degradation_absolute_tolerance(0.5);
+
+  EXPECT_THAT(ModelSolveParameters::FromProto(model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("auxiliary_objective_parameters")));
+}
+
+TEST(ModelSolveParametersTest, FromProtoInvalidLazyConstraintIdsIsError) {
+  const Model model;
+  ModelSolveParametersProto proto;
+  proto.add_lazy_linear_constraint_ids(2);
+
+  EXPECT_THAT(ModelSolveParameters::FromProto(model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("lazy_linear_constraint")));
+}
+
+TEST(ObjectiveParametersTest, Proto) {
+  ModelSolveParameters::ObjectiveParameters params;
+  params.objective_degradation_absolute_tolerance = 3.0;
+  params.objective_degradation_relative_tolerance = 4.0;
+  params.time_limit = absl::Seconds(10);
+
+  ObjectiveParametersProto expected;
+  expected.set_objective_degradation_absolute_tolerance(3.0);
+  expected.set_objective_degradation_relative_tolerance(4.0);
+  expected.mutable_time_limit()->set_seconds(10);
+  EXPECT_THAT(params.Proto(), IsOkAndHolds(EquivToProto(expected)));
+}
+
+TEST(ObjectiveParametersTest, FromProtoFull) {
+  ObjectiveParametersProto proto;
+  proto.set_objective_degradation_absolute_tolerance(3.0);
+  proto.set_objective_degradation_relative_tolerance(4.0);
+  proto.mutable_time_limit()->set_seconds(10);
+
+  ASSERT_OK_AND_ASSIGN(
+      const auto params,
+      ModelSolveParameters::ObjectiveParameters::FromProto(proto));
+  EXPECT_THAT(params.objective_degradation_absolute_tolerance,
+              testing::Optional(3.0));
+  EXPECT_THAT(params.objective_degradation_relative_tolerance,
+              testing::Optional(4.0));
+  EXPECT_THAT(params.time_limit, absl::Seconds(10));
+}
+
+TEST(ObjectiveParametersTest, FromProtoEmpty) {
+  ObjectiveParametersProto proto;
+  ASSERT_OK_AND_ASSIGN(
+      const auto params,
+      ModelSolveParameters::ObjectiveParameters::FromProto(proto));
+  EXPECT_EQ(params.objective_degradation_absolute_tolerance, std::nullopt);
+  EXPECT_EQ(params.objective_degradation_relative_tolerance, std::nullopt);
+  EXPECT_EQ(params.time_limit, absl::InfiniteDuration());
+}
+
+TEST(SolutionHintTest, HintMixedModels) {
+  ModelStorage model_a;
+  const Variable a_x(&model_a, model_a.AddVariable("x"));
+  ModelStorage model_b;
+  const LinearConstraint b_c(&model_b, model_b.AddLinearConstraint("c"));
+
+  const ModelSolveParameters::SolutionHint hint = {
+      .variable_values = {{a_x, 1.0}},
+      .dual_values = {{b_c, 3.2}},
+  };
+
+  EXPECT_THAT(hint.CheckModelStorage(&model_a),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+  EXPECT_THAT(hint.CheckModelStorage(&model_b),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(SolutionHintTest, FromValidProto) {
+  Model model;
+  const Variable x1 = model.AddVariable("x1");
+  model.AddVariable("x2");
+  const Variable x3 = model.AddVariable("x3");
+  model.AddLinearConstraint("c1");
+  const LinearConstraint c2 = model.AddLinearConstraint("c2");
+
+  SolutionHintProto hint_proto;
+  hint_proto.mutable_variable_values()->add_ids(x1.id());
+  hint_proto.mutable_variable_values()->add_values(1.0);
+  hint_proto.mutable_variable_values()->add_ids(x3.id());
+  hint_proto.mutable_variable_values()->add_values(0.0);
+  hint_proto.mutable_dual_values()->add_ids(c2.id());
+  hint_proto.mutable_dual_values()->add_values(-1.0);
+
+  ASSERT_OK_AND_ASSIGN(
+      const ModelSolveParameters::SolutionHint hint,
+      ModelSolveParameters::SolutionHint::FromProto(model, hint_proto));
+  EXPECT_THAT(hint.variable_values,
+              UnorderedElementsAre(Pair(x1, 1.0), Pair(x3, 0.0)));
+  EXPECT_THAT(hint.dual_values, UnorderedElementsAre(Pair(c2, -1.0)));
+}
+
+TEST(SolutionHintTest, FromProtoInvalidVariableValues) {
+  // This test only tests one failing case. It relies on the fact that we use
+  // VariableValuesFromProto() which is already properly unit tested.
+  Model model;
+  const Variable x1 = model.AddVariable("x1");
+  model.AddVariable("x2");
+  model.AddVariable("x3");
+
+  SolutionHintProto hint_proto;
+  hint_proto.mutable_variable_values()->add_ids(x1.id());
+  hint_proto.mutable_variable_values()->add_values(1.0);
+  // We use an index that does not exist in the model.
+  hint_proto.mutable_variable_values()->add_ids(model.next_variable_id());
+  hint_proto.mutable_variable_values()->add_values(0.0);
+
+  EXPECT_THAT(ModelSolveParameters::SolutionHint::FromProto(model, hint_proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("variable_values")));
+}
+
+TEST(SolutionHintTest, FromProtoInvalidDualValues) {
+  // This test only tests one failing case. It relies on the fact that we use
+  // LinearConstraintValuesFromProto() which is already properly unit tested.
+  Model model;
+  const LinearConstraint c1 = model.AddLinearConstraint("c1");
+  model.AddLinearConstraint("c2");
+  model.AddLinearConstraint("c3");
+
+  SolutionHintProto hint_proto;
+  hint_proto.mutable_dual_values()->add_ids(c1.id());
+  hint_proto.mutable_dual_values()->add_values(1.0);
+  // We use an index that does not exist in the model.
+  hint_proto.mutable_dual_values()->add_ids(model.next_linear_constraint_id());
+  hint_proto.mutable_dual_values()->add_values(0.0);
+
+  EXPECT_THAT(
+      ModelSolveParameters::SolutionHint::FromProto(model, hint_proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("dual_values")));
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/objective_test.cc b/ortools/math_opt/cpp/objective_test.cc
new file mode 100644
index 0000000000..e850ce11c9
--- /dev/null
+++ b/ortools/math_opt/cpp/objective_test.cc
@@ -0,0 +1,233 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/objective.h"
+
+#include <optional>
+#include <sstream>
+
+#include "absl/strings/str_cat.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/storage/model_storage.h"
+#include "ortools/math_opt/storage/model_storage_types.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+using ::testing::Pair;
+using ::testing::UnorderedElementsAre;
+
+TEST(ObjectiveTest, Accessors) {
+  ModelStorage storage(/*model_name=*/"", /*primary_objective_name=*/"primary");
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Variable y(&storage, storage.AddVariable("y"));
+
+  const Objective primary = Objective::Primary(&storage);
+  storage.set_objective_priority(primary.typed_id(), 1);
+  storage.set_objective_offset(primary.typed_id(), 2.0);
+  storage.set_linear_objective_coefficient(primary.typed_id(), x.typed_id(),
+                                           3.0);
+  const Objective secondary = Objective::Auxiliary(
+      &storage, storage.AddAuxiliaryObjective(12, "secondary"));
+  storage.set_maximize(secondary.typed_id());
+  storage.set_quadratic_objective_coefficient(secondary.typed_id(),
+                                              x.typed_id(), y.typed_id(), 4.0);
+
+  EXPECT_EQ(primary.id(), std::nullopt);
+  EXPECT_EQ(secondary.id(), 0);
+
+  EXPECT_EQ(primary.typed_id(), kPrimaryObjectiveId);
+  EXPECT_EQ(secondary.typed_id(), AuxiliaryObjectiveId(0));
+
+  EXPECT_EQ(primary.storage(), &storage);
+  EXPECT_EQ(secondary.storage(), &storage);
+
+  EXPECT_TRUE(primary.is_primary());
+  EXPECT_FALSE(secondary.is_primary());
+
+  EXPECT_FALSE(primary.maximize());
+  EXPECT_TRUE(secondary.maximize());
+
+  EXPECT_EQ(primary.priority(), 1);
+  EXPECT_EQ(secondary.priority(), 12);
+
+  EXPECT_EQ(primary.name(), "primary");
+  EXPECT_EQ(secondary.name(), "secondary");
+
+  EXPECT_EQ(primary.offset(), 2.0);
+  EXPECT_EQ(secondary.offset(), 0.0);
+  EXPECT_EQ(primary.num_linear_terms(), 1);
+  EXPECT_EQ(secondary.num_linear_terms(), 0);
+  EXPECT_EQ(primary.num_quadratic_terms(), 0);
+  EXPECT_EQ(secondary.num_quadratic_terms(), 1);
+
+  EXPECT_EQ(primary.coefficient(x), 3.0);
+  EXPECT_EQ(secondary.coefficient(x), 0.0);
+
+  EXPECT_EQ(primary.coefficient(x, y), 0.0);
+  EXPECT_EQ(secondary.coefficient(x, y), 4.0);
+
+  EXPECT_TRUE(primary.is_coefficient_nonzero(x));
+  EXPECT_FALSE(secondary.is_coefficient_nonzero(x));
+
+  EXPECT_FALSE(primary.is_coefficient_nonzero(x, y));
+  EXPECT_TRUE(secondary.is_coefficient_nonzero(x, y));
+}
+
+TEST(ObjectiveTest, NameAfterDeletion) {
+  ModelStorage storage;
+  const Objective o = Objective::Auxiliary(
+      &storage, storage.AddAuxiliaryObjective(12, "secondary"));
+
+  ASSERT_EQ(o.name(), "secondary");
+
+  storage.DeleteAuxiliaryObjective(o.typed_id().value());
+  EXPECT_EQ(o.name(), kDeletedObjectiveDefaultDescription);
+}
+
+TEST(ObjectiveTest, Equality) {
+  ModelStorage storage(/*model_name=*/"", /*primary_objective_name=*/"primary");
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Variable y(&storage, storage.AddVariable("y"));
+
+  const Objective c = Objective::Primary(&storage);
+  const Objective d = Objective::Auxiliary(
+      &storage, storage.AddAuxiliaryObjective(12, "secondary"));
+
+  // `d2` is another `Objective` that points the same auxiliary objective in the
+  // indexed storage. It should compares == to `d`.
+  const Objective d2 = Objective::Auxiliary(d.storage(), d.typed_id().value());
+
+  // `e` has identical data as `d`. It should not compares equal to `d`, though.
+  const Objective e = Objective::Auxiliary(
+      &storage, storage.AddAuxiliaryObjective(12, "secondary"));
+
+  EXPECT_TRUE(c == c);
+  EXPECT_FALSE(c == d);
+  EXPECT_TRUE(d == d2);
+  EXPECT_FALSE(d == e);
+  EXPECT_FALSE(c != c);
+  EXPECT_TRUE(c != d);
+  EXPECT_FALSE(d != d2);
+  EXPECT_TRUE(d != e);
+}
+
+TEST(ObjectiveTest, AsLinearExpression) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Objective o = Objective::Primary(&storage);
+  storage.set_objective_offset(o.typed_id(), 1.0);
+  storage.set_linear_objective_coefficient(o.typed_id(), x.typed_id(), 2.0);
+
+  const LinearExpression o_expr = o.AsLinearExpression();
+  EXPECT_EQ(o_expr.offset(), 1.0);
+  EXPECT_THAT(o_expr.terms(), UnorderedElementsAre(Pair(x, 2.0)));
+}
+
+TEST(ObjectiveDeathTest, QuadraticObjectiveAsLinearExpression) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Objective o =
+      Objective::Auxiliary(&storage, storage.AddAuxiliaryObjective(12));
+  storage.set_quadratic_objective_coefficient(o.typed_id(), x.typed_id(),
+                                              x.typed_id(), 1.0);
+  EXPECT_DEATH(o.AsLinearExpression(), "quadratic");
+}
+
+TEST(ObjectiveTest, AsQuadraticExpression) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Objective o = Objective::Primary(&storage);
+  storage.set_objective_offset(o.typed_id(), 1.0);
+  storage.set_linear_objective_coefficient(o.typed_id(), x.typed_id(), 2.0);
+  storage.set_quadratic_objective_coefficient(o.typed_id(), x.typed_id(),
+                                              x.typed_id(), 3.0);
+
+  const QuadraticExpression o_expr = o.AsQuadraticExpression();
+  EXPECT_EQ(o_expr.offset(), 1.0);
+  EXPECT_THAT(o_expr.linear_terms(), UnorderedElementsAre(Pair(x, 2.0)));
+  EXPECT_THAT(o_expr.quadratic_terms(),
+              UnorderedElementsAre(Pair(QuadraticTermKey(x, x), 3.0)));
+}
+
+TEST(ObjectiveTest, ToString) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Objective o = Objective::Auxiliary(
+      &storage, storage.AddAuxiliaryObjective(12, "secondary"));
+  storage.set_objective_offset(o.typed_id(), 1.0);
+  storage.set_linear_objective_coefficient(o.typed_id(), x.typed_id(), 2.0);
+  storage.set_quadratic_objective_coefficient(o.typed_id(), x.typed_id(),
+                                              x.typed_id(), 3.0);
+
+  EXPECT_EQ(o.ToString(), "3*x² + 2*x + 1");
+
+  storage.DeleteAuxiliaryObjective(o.typed_id().value());
+  EXPECT_EQ(o.ToString(), kDeletedObjectiveDefaultDescription);
+}
+
+TEST(ObjectiveTest, OutputStreaming) {
+  ModelStorage storage(/*model_name=*/"", /*primary_objective_name=*/"primary");
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Objective primary = Objective::Primary(&storage);
+  const Objective secondary = Objective::Auxiliary(
+      &storage, storage.AddAuxiliaryObjective(12, "secondary"));
+
+  auto to_string = [](Objective c) {
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(primary), "primary");
+  EXPECT_EQ(to_string(secondary), "secondary");
+}
+
+TEST(ObjectiveTest, OutputStreamingEmptyName) {
+  ModelStorage storage;
+  const Variable x(&storage, storage.AddVariable("x"));
+  const Objective primary = Objective::Primary(&storage);
+  const Objective secondary =
+      Objective::Auxiliary(&storage, storage.AddAuxiliaryObjective(12));
+
+  auto to_string = [](Objective c) {
+    std::ostringstream oss;
+    oss << c;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(primary), "__primary_obj__");
+  EXPECT_EQ(to_string(secondary),
+            absl::StrCat("__aux_obj#", secondary.id().value(), "__"));
+}
+
+TEST(ObjectiveDeathTest, CoefficientDifferentModel) {
+  ModelStorage storage_a;
+  ModelStorage storage_b;
+
+  const Variable x_a = Variable(&storage_a, storage_a.AddVariable("x"));
+  const Variable y_b = Variable(&storage_b, storage_b.AddVariable("y"));
+  const Objective o_b = Objective::Primary(&storage_b);
+
+  EXPECT_DEATH(o_b.coefficient(x_a), "another model");
+  EXPECT_DEATH(o_b.coefficient(x_a, y_b), "another model");
+  EXPECT_DEATH(o_b.coefficient(y_b, x_a), "another model");
+  EXPECT_DEATH(o_b.is_coefficient_nonzero(x_a), "another model");
+  EXPECT_DEATH(o_b.is_coefficient_nonzero(x_a, y_b), "another model");
+  EXPECT_DEATH(o_b.is_coefficient_nonzero(y_b, x_a), "another model");
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/parameters_test.cc b/ortools/math_opt/cpp/parameters_test.cc
new file mode 100644
index 0000000000..bba022fb0f
--- /dev/null
+++ b/ortools/math_opt/cpp/parameters_test.cc
@@ -0,0 +1,249 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/parameters.h"
+
+#include <optional>
+#include <string>
+#include <type_traits>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/time/time.h"
+#include "google/protobuf/duration.pb.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/linked_hash_map.h"
+#include "ortools/base/status_macros.h"
+#include "ortools/math_opt/cpp/enums_testing.h"
+#include "ortools/math_opt/parameters.pb.h"
+#include "ortools/math_opt/solvers/glpk.pb.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::EqualsProto;
+using ::testing::EquivToProto;
+using ::testing::HasSubstr;
+using ::testing::Optional;
+using ::testing::Pair;
+using ::testing::status::StatusIs;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(SolverType, EnumTest, SolverType);
+INSTANTIATE_TYPED_TEST_SUITE_P(LPAlgorithm, EnumTest, LPAlgorithm);
+INSTANTIATE_TYPED_TEST_SUITE_P(Emphasis, EnumTest, Emphasis);
+
+TEST(SolverTypeTest, Flags) {
+  {
+    SolverType value = SolverType::kGlop;
+    std::string error;
+    EXPECT_TRUE(AbslParseFlag("glpk", &value, &error));
+    EXPECT_EQ(value, SolverType::kGlpk);
+    EXPECT_EQ(error, "");
+
+    EXPECT_EQ(AbslUnparseFlag(value), "glpk");
+  }
+  {
+    SolverType value = SolverType::kGlpk;
+    std::string error;
+    EXPECT_FALSE(AbslParseFlag("unknown", &value, &error));
+    EXPECT_NE(error, "");
+  }
+}
+
+TEST(LPAlgorithmTest, Flags) {
+  {
+    LPAlgorithm value = LPAlgorithm::kPrimalSimplex;
+    std::string error;
+    EXPECT_TRUE(AbslParseFlag("primal_simplex", &value, &error));
+    EXPECT_EQ(value, LPAlgorithm::kPrimalSimplex);
+    EXPECT_EQ(error, "");
+
+    EXPECT_EQ(AbslUnparseFlag(value), "primal_simplex");
+  }
+  {
+    LPAlgorithm value = LPAlgorithm::kPrimalSimplex;
+    std::string error;
+    EXPECT_FALSE(AbslParseFlag("unknown", &value, &error));
+    EXPECT_NE(error, "");
+  }
+}
+
+TEST(EmphasisTest, Flags) {
+  {
+    Emphasis value = Emphasis::kHigh;
+    std::string error;
+    EXPECT_TRUE(AbslParseFlag("high", &value, &error));
+    EXPECT_EQ(value, Emphasis::kHigh);
+    EXPECT_EQ(error, "");
+
+    EXPECT_EQ(AbslUnparseFlag(value), "high");
+  }
+  {
+    Emphasis value = Emphasis::kHigh;
+    std::string error;
+    EXPECT_FALSE(AbslParseFlag("unknown", &value, &error));
+    EXPECT_NE(error, "");
+  }
+}
+
+TEST(GurobiParameters, Empty) {
+  GurobiParameters gurobi;
+  EXPECT_TRUE(gurobi.empty());
+  gurobi.param_values["x"] = "dog";
+  EXPECT_FALSE(gurobi.empty());
+}
+
+TEST(GurobiParameters, ProtoRoundTrip) {
+  GurobiParameters gurobi;
+  gurobi.param_values["x"] = "dog";
+  gurobi.param_values["ab"] = "7";
+  const GurobiParametersProto proto = gurobi.Proto();
+  EXPECT_THAT(proto, EquivToProto(R"pb(parameters:
+                                       [ { name: "x" value: "dog" }
+                                         , { name: "ab" value: "7" }])pb"));
+  GurobiParameters end = GurobiParameters::FromProto(proto);
+  EXPECT_THAT(end.param_values, ElementsAre(Pair("x", "dog"), Pair("ab", "7")));
+}
+
+TEST(GurobiParameters, EmptyProtoRoundTrip) {
+  GurobiParameters gurobi;
+  const GurobiParametersProto proto = gurobi.Proto();
+  EXPECT_THAT(proto, EquivToProto(GurobiParametersProto()));
+  GurobiParameters end = GurobiParameters::FromProto(proto);
+  EXPECT_THAT(end.param_values, ::testing::IsEmpty());
+}
+
+TEST(GlpkParameters, ProtoRoundTrip) {
+  // Test with `optional bool` set to true.
+  {
+    GlpkParametersProto proto;
+    proto.set_compute_unbound_rays_if_possible(true);
+    EXPECT_THAT(GlpkParameters::FromProto(proto).Proto(), EqualsProto(proto));
+  }
+  // Test with `optional bool` set to false.
+  {
+    GlpkParametersProto proto;
+    proto.set_compute_unbound_rays_if_possible(false);
+    EXPECT_THAT(GlpkParameters::FromProto(proto).Proto(), EqualsProto(proto));
+  }
+}
+
+TEST(GlpkParameters, EmptyProtoRoundTrip) {
+  const GlpkParametersProto empty;
+  EXPECT_THAT(GlpkParameters::FromProto(empty).Proto(), EqualsProto(empty));
+}
+
+TEST(SolveParameters, EmptyProtoRoundTrip) {
+  const SolveParametersProto start;
+  ASSERT_OK_AND_ASSIGN(SolveParameters cpp_params,
+                       SolveParameters::FromProto(start));
+  const SolveParametersProto end = cpp_params.Proto();
+  EXPECT_THAT(end, EquivToProto(start));
+}
+
+TEST(SolveParameters, CommonParamsRoundTrip) {
+  SolveParameters start;
+  start.enable_output = true;
+  start.time_limit = absl::Seconds(1);
+  start.iteration_limit = 7;
+  start.node_limit = 3;
+  start.relative_gap_tolerance = 1.0;
+  start.absolute_gap_tolerance = 0.1;
+  start.cutoff_limit = 50.1;
+  start.objective_limit = 51.1;
+  start.best_bound_limit = 52.1;
+  start.solution_limit = 17;
+  start.threads = 3;
+  start.random_seed = 12;
+  start.solution_pool_size = 44;
+  start.lp_algorithm = LPAlgorithm::kDualSimplex;
+  start.presolve = Emphasis::kMedium;
+  start.cuts = Emphasis::kOff;
+  start.scaling = Emphasis::kLow;
+  start.heuristics = Emphasis::kVeryHigh;
+  const SolveParametersProto proto = start.Proto();
+  EXPECT_THAT(proto, EquivToProto(R"pb(
+                enable_output: true
+                time_limit: { seconds: 1 }
+                iteration_limit: 7
+                node_limit: 3
+                relative_gap_tolerance: 1.0
+                absolute_gap_tolerance: 0.1
+                cutoff_limit: 50.1
+                objective_limit: 51.1
+                best_bound_limit: 52.1
+                solution_limit: 17
+                threads: 3
+                random_seed: 12
+                solution_pool_size: 44
+                lp_algorithm: LP_ALGORITHM_DUAL_SIMPLEX
+                presolve: EMPHASIS_MEDIUM
+                cuts: EMPHASIS_OFF
+                scaling: EMPHASIS_LOW
+                heuristics: EMPHASIS_VERY_HIGH
+              )pb"));
+  ASSERT_OK_AND_ASSIGN(const SolveParameters end,
+                       SolveParameters::FromProto(proto));
+  EXPECT_TRUE(end.enable_output);
+  EXPECT_EQ(end.time_limit, absl::Seconds(1));
+  EXPECT_THAT(end.iteration_limit, Optional(7));
+  EXPECT_THAT(end.node_limit, Optional(3));
+  EXPECT_THAT(end.relative_gap_tolerance, Optional(1.0));
+  EXPECT_THAT(end.absolute_gap_tolerance, Optional(0.1));
+  EXPECT_THAT(end.cutoff_limit, Optional(50.1));
+  EXPECT_THAT(end.objective_limit, Optional(51.1));
+  EXPECT_THAT(end.best_bound_limit, Optional(52.1));
+  EXPECT_THAT(end.solution_limit, Optional(17));
+  EXPECT_THAT(end.threads, Optional(3));
+  EXPECT_THAT(end.random_seed, Optional(12));
+  EXPECT_THAT(end.solution_pool_size, Optional(44));
+  EXPECT_THAT(end.lp_algorithm, Optional(LPAlgorithm::kDualSimplex));
+  EXPECT_THAT(end.presolve, Optional(Emphasis::kMedium));
+  EXPECT_THAT(end.cuts, Optional(Emphasis::kOff));
+  EXPECT_THAT(end.scaling, Optional(Emphasis::kLow));
+  EXPECT_THAT(end.heuristics, Optional(Emphasis::kVeryHigh));
+}
+
+TEST(SolveParameters, SolverSpecificParamsRoundTrip) {
+  SolveParametersProto start;
+  start.set_random_seed(7);
+  start.mutable_gscip()->set_num_solutions(12);
+  auto* p = start.mutable_gurobi()->add_parameters();
+  p->set_name("x");
+  p->set_value("7");
+  start.mutable_glop()->set_random_seed(45);
+  start.mutable_cp_sat()->set_num_workers(50);
+  start.mutable_osqp()->set_alpha(1.2);
+  start.mutable_glpk()->set_compute_unbound_rays_if_possible(true);
+  (*start.mutable_highs()->mutable_int_options())["test_param"] = 3;
+  ASSERT_OK_AND_ASSIGN(SolveParameters cpp_params,
+                       SolveParameters::FromProto(start));
+  const SolveParametersProto end = cpp_params.Proto();
+  EXPECT_THAT(end, EquivToProto(start));
+}
+
+TEST(SolveParameters, FromProtoBadTimeLimit) {
+  SolveParametersProto proto;
+  proto.mutable_time_limit()->set_seconds(1);
+  proto.mutable_time_limit()->set_nanos(-1);
+  EXPECT_THAT(
+      SolveParameters::FromProto(proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("time_limit")));
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/solution_test.cc b/ortools/math_opt/cpp/solution_test.cc
new file mode 100644
index 0000000000..092eeca900
--- /dev/null
+++ b/ortools/math_opt/cpp/solution_test.cc
@@ -0,0 +1,504 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/solution.h"
+
+#include <optional>
+
+#include "absl/status/status.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/enums_testing.h"
+#include "ortools/math_opt/cpp/linear_constraint.h"
+#include "ortools/math_opt/cpp/matchers.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/cpp/objective.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/solution.pb.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+#include "ortools/math_opt/storage/model_storage.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::status::IsOkAndHolds;
+using ::testing::status::StatusIs;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(SolutionStatus, EnumTest, SolutionStatus);
+
+TEST(PrimalSolutionTest, ProtoRoundTripTest) {
+  ModelStorage model;
+  const Variable x(&model, model.AddVariable("x"));
+  const Variable y(&model, model.AddVariable("y"));
+  const Objective o =
+      Objective::Auxiliary(&model, model.AddAuxiliaryObjective(2));
+
+  PrimalSolutionProto proto;
+  proto.set_objective_value(9.0);
+  (*proto.mutable_auxiliary_objective_values())[o.id().value()] = 3.0;
+  proto.set_feasibility_status(SOLUTION_STATUS_INFEASIBLE);
+  for (int i : {0, 1}) {
+    proto.mutable_variable_values()->add_ids(i);
+  }
+  for (double v : {2.0, 1.0}) {
+    proto.mutable_variable_values()->add_values(v);
+  }
+
+  PrimalSolution expected = {.variable_values = {{x, 2.0}, {y, 1.0}},
+                             .objective_value = 9.0,
+                             .auxiliary_objective_values = {{o, 3.0}},
+                             .feasibility_status = SolutionStatus::kInfeasible};
+
+  // Test one way
+  EXPECT_THAT(PrimalSolution::FromProto(&model, proto),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+  // Test round trip
+  EXPECT_THAT(PrimalSolution::FromProto(&model, expected.Proto()),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+}
+
+TEST(PrimalSolutionTest, InvalidVariableValues) {
+  ModelStorage model;
+  model.AddVariable("x");
+
+  PrimalSolutionProto proto;
+  proto.set_objective_value(9.0);
+  proto.set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  proto.mutable_variable_values()->add_ids(0);
+
+  EXPECT_THAT(PrimalSolution::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid variable_values")));
+}
+
+TEST(PrimalSolutionTest, InvalidAuxiliaryObjectiveValues) {
+  ModelStorage model;
+
+  PrimalSolutionProto proto;
+  (*proto.mutable_auxiliary_objective_values())[0] = 3.0;
+
+  EXPECT_THAT(PrimalSolution::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid auxiliary_objective_values")));
+}
+
+TEST(PrimalSolutionTest, FeasibilityStatusUnspecified) {
+  ModelStorage model;
+  PrimalSolutionProto proto;
+  EXPECT_THAT(PrimalSolution::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("feasibility_status")));
+}
+
+TEST(PrimalSolutionTest, GetObjectiveValue) {
+  ModelStorage model;
+  const Objective p = Objective::Primary(&model);
+  const Objective o =
+      Objective::Auxiliary(&model, model.AddAuxiliaryObjective(1));
+  PrimalSolution solution{.objective_value = 1.0,
+                          .auxiliary_objective_values = {{o, 2.0}}};
+  EXPECT_EQ(solution.get_objective_value(p), 1.0);
+  EXPECT_EQ(solution.get_objective_value(o), 2.0);
+}
+
+TEST(PrimalSolutionDeathTest, GetObjectiveValueWrongModel) {
+  ModelStorage model_a;
+  const Variable v_a(&model_a, model_a.AddVariable("v"));
+  const Objective o_a =
+      Objective::Auxiliary(&model_a, model_a.AddAuxiliaryObjective(1));
+  PrimalSolution solution{.objective_value = 1.0,
+                          .auxiliary_objective_values = {{o_a, 2.0}}};
+
+  ModelStorage model_b;
+  const Objective p_b = Objective::Primary(&model_b);
+  const Objective o_b =
+      Objective::Auxiliary(&model_b, model_b.AddAuxiliaryObjective(1));
+  // This is a documented corner case where we don't CHECK the model.
+  EXPECT_EQ(solution.get_objective_value(p_b), 1.0);
+  EXPECT_DEATH(solution.get_objective_value(o_b), "");
+
+  solution.variable_values.insert({v_a, 3.0});
+  EXPECT_DEATH(solution.get_objective_value(p_b), "");
+  EXPECT_DEATH(solution.get_objective_value(o_b), "");
+}
+
+TEST(PrimalRayTest, ProtoRoundTripTest) {
+  ModelStorage model;
+  const Variable x(&model, model.AddVariable("x"));
+  const Variable y(&model, model.AddVariable("y"));
+
+  PrimalRayProto proto;
+  for (int i : {0, 1}) {
+    proto.mutable_variable_values()->add_ids(i);
+  }
+  for (double v : {2.0, 1.0}) {
+    proto.mutable_variable_values()->add_values(v);
+  }
+
+  const PrimalRay expected = {.variable_values = {{x, 2.0}, {y, 1.0}}};
+
+  // Test one way
+  EXPECT_THAT(PrimalRay::FromProto(&model, proto),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+  // Test round trip
+  EXPECT_THAT(PrimalRay::FromProto(&model, expected.Proto()),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+}
+
+TEST(PrimalRayTest, InvalidVariableValues) {
+  ModelStorage model;
+  model.AddVariable("x");
+
+  PrimalRayProto proto;
+  proto.mutable_variable_values()->add_ids(0);
+
+  EXPECT_THAT(PrimalRay::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid variable_values")));
+}
+
+TEST(DualSolutionTest, ProtoRoundTripTest) {
+  ModelStorage model;
+  const Variable x(&model, model.AddVariable("x"));
+  const Variable y(&model, model.AddVariable("y"));
+  const LinearConstraint c(&model, model.AddLinearConstraint("c"));
+  const LinearConstraint d(&model, model.AddLinearConstraint("d"));
+  const QuadraticConstraint e(
+      &model, model.AddAtomicConstraint(QuadraticConstraintData{.name = "e"}));
+  const QuadraticConstraint f(
+      &model, model.AddAtomicConstraint(QuadraticConstraintData{.name = "f"}));
+
+  DualSolutionProto proto;
+  proto.set_objective_value(9.0);
+  proto.set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  for (int i : {0, 1}) {
+    proto.mutable_reduced_costs()->add_ids(i);
+  }
+  for (double v : {2.0, 1.0}) {
+    proto.mutable_reduced_costs()->add_values(v);
+  }
+  for (int i : {0, 1}) {
+    proto.mutable_dual_values()->add_ids(i);
+  }
+  for (double v : {3.0, 4.0}) {
+    proto.mutable_dual_values()->add_values(v);
+  }
+  for (int i : {0, 1}) {
+    proto.mutable_quadratic_dual_values()->add_ids(i);
+  }
+  for (double v : {5.0, 6.0}) {
+    proto.mutable_quadratic_dual_values()->add_values(v);
+  }
+
+  const DualSolution expected = {
+      .dual_values = {{c, 3.0}, {d, 4.0}},
+      .quadratic_dual_values = {{e, 5.0}, {f, 6.0}},
+      .reduced_costs = {{x, 2.0}, {y, 1.0}},
+      .objective_value = 9.0,
+      .feasibility_status = SolutionStatus::kFeasible};
+
+  // Test one way
+  EXPECT_THAT(DualSolution::FromProto(&model, proto),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+  // Test round trip
+  EXPECT_THAT(DualSolution::FromProto(&model, expected.Proto()),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+}
+
+TEST(DualSolutionTest, InvalidDualValues) {
+  ModelStorage model;
+  model.AddLinearConstraint("c");
+
+  DualSolutionProto proto;
+  proto.set_objective_value(9.0);
+  proto.set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  proto.mutable_dual_values()->add_ids(0);
+
+  EXPECT_THAT(DualSolution::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid dual_values")));
+}
+
+TEST(DualSolutionTest, InvalidReducedCosts) {
+  ModelStorage model;
+  model.AddVariable("x");
+
+  DualSolutionProto proto;
+  proto.set_objective_value(9.0);
+  proto.set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  proto.mutable_reduced_costs()->add_ids(0);
+
+  EXPECT_THAT(DualSolution::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid reduced_costs")));
+}
+
+TEST(DualSolutionTest, InvalidQuadraticDualValues) {
+  ModelStorage model;
+  const QuadraticConstraint c(
+      &model, model.AddAtomicConstraint(QuadraticConstraintData{.name = "c"}));
+
+  DualSolutionProto proto;
+  proto.set_objective_value(9.0);
+  proto.set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  proto.mutable_quadratic_dual_values()->add_ids(0);
+
+  EXPECT_THAT(DualSolution::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid quadratic_dual_values")));
+}
+
+TEST(DualSolutionTest, FeasibilityStatusUnspecified) {
+  ModelStorage model;
+  DualSolutionProto proto;
+  EXPECT_THAT(DualSolution::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("feasibility_status")));
+}
+
+TEST(DualRayTest, ProtoRoundTripTest) {
+  ModelStorage model;
+  const Variable x(&model, model.AddVariable("x"));
+  const Variable y(&model, model.AddVariable("y"));
+  const LinearConstraint c(&model, model.AddLinearConstraint("c"));
+  const LinearConstraint d(&model, model.AddLinearConstraint("d"));
+
+  DualRayProto proto;
+  for (int i : {0, 1}) {
+    proto.mutable_reduced_costs()->add_ids(i);
+  }
+  for (double v : {2.0, 1.0}) {
+    proto.mutable_reduced_costs()->add_values(v);
+  }
+  for (int i : {0, 1}) {
+    proto.mutable_dual_values()->add_ids(i);
+  }
+  for (double v : {3.0, 4.0}) {
+    proto.mutable_dual_values()->add_values(v);
+  }
+
+  const DualRay expected = {.dual_values = {{c, 3.0}, {d, 4.0}},
+                            .reduced_costs = {{x, 2.0}, {y, 1.0}}};
+
+  // Test one way
+  EXPECT_THAT(DualRay::FromProto(&model, proto),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+  // Test round trip
+  EXPECT_THAT(DualRay::FromProto(&model, expected.Proto()),
+              IsOkAndHolds(IsNear(expected, /*tolerance=*/0)));
+}
+
+TEST(DualRayTest, InvalidDualValues) {
+  ModelStorage model;
+  model.AddLinearConstraint("c");
+
+  DualRayProto proto;
+  proto.mutable_dual_values()->add_ids(0);
+
+  EXPECT_THAT(DualRay::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid dual_values")));
+}
+
+TEST(DualRayTest, InvalidReducedCosts) {
+  ModelStorage model;
+  model.AddVariable("x");
+
+  DualRayProto proto;
+  proto.mutable_reduced_costs()->add_ids(0);
+
+  EXPECT_THAT(DualRay::FromProto(&model, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("invalid reduced_costs")));
+}
+
+TEST(BasisTest, ProtoRoundTripTest) {
+  ModelStorage model;
+  const Variable x(&model, model.AddVariable("x"));
+  const Variable y(&model, model.AddVariable("y"));
+  const LinearConstraint c(&model, model.AddLinearConstraint("c"));
+  const LinearConstraint d(&model, model.AddLinearConstraint("d"));
+
+  BasisProto proto;
+  for (int i : {0, 1}) {
+    proto.mutable_variable_status()->add_ids(i);
+  }
+  proto.mutable_variable_status()->add_values(BASIS_STATUS_AT_UPPER_BOUND);
+  proto.mutable_variable_status()->add_values(BASIS_STATUS_FREE);
+  for (int i : {0, 1}) {
+    proto.mutable_constraint_status()->add_ids(i);
+  }
+  proto.mutable_constraint_status()->add_values(BASIS_STATUS_AT_LOWER_BOUND);
+  proto.mutable_constraint_status()->add_values(BASIS_STATUS_BASIC);
+  proto.set_basic_dual_feasibility(SOLUTION_STATUS_FEASIBLE);
+
+  const Basis expected = {.constraint_status = {{c, BasisStatus::kAtLowerBound},
+                                                {d, BasisStatus::kBasic}},
+                          .variable_status = {{x, BasisStatus::kAtUpperBound},
+                                              {y, BasisStatus::kFree}},
+                          .basic_dual_feasibility = SolutionStatus::kFeasible};
+
+  EXPECT_OK(expected.CheckModelStorage(&model));
+
+  // Test one way
+  EXPECT_THAT(Basis::FromProto(&model, proto), IsOkAndHolds(BasisIs(expected)));
+  // Test round trip
+  EXPECT_THAT(Basis::FromProto(&model, expected.Proto()),
+              IsOkAndHolds(BasisIs(expected)));
+}
+
+TEST(BasisTest, VariablesAndConstraintsDifferentModels) {
+  ModelStorage model_a;
+  const Variable a_x(&model_a, model_a.AddVariable("x"));
+  ModelStorage model_b;
+  const LinearConstraint b_c(&model_b, model_b.AddLinearConstraint("c"));
+
+  const Basis basis = {.constraint_status = {{b_c, BasisStatus::kAtLowerBound}},
+                       .variable_status = {{a_x, BasisStatus::kAtUpperBound}}};
+
+  EXPECT_THAT(basis.CheckModelStorage(&model_a),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+  EXPECT_THAT(basis.CheckModelStorage(&model_b),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(BasisTest, FromProtoUnspecifiedBasicDualFeasibility) {
+  ModelStorage storage;
+  BasisProto proto;
+  ASSERT_OK_AND_ASSIGN(const Basis basis, Basis::FromProto(&storage, proto));
+  EXPECT_THAT(basis.variable_status, IsEmpty());
+  EXPECT_THAT(basis.constraint_status, IsEmpty());
+  EXPECT_EQ(basis.basic_dual_feasibility, std::nullopt);
+}
+
+TEST(SolutionTest, ProtoRoundTripTest) {
+  ModelStorage model;
+  const Variable x(&model, model.AddVariable("x"));
+  const Variable y(&model, model.AddVariable("y"));
+  const LinearConstraint c(&model, model.AddLinearConstraint("c"));
+  const LinearConstraint d(&model, model.AddLinearConstraint("d"));
+  const Objective o =
+      Objective::Auxiliary(&model, model.AddAuxiliaryObjective(2));
+
+  SolutionProto proto;
+
+  PrimalSolutionProto& primal_proto = *proto.mutable_primal_solution();
+  primal_proto.set_objective_value(9.0);
+  (*primal_proto.mutable_auxiliary_objective_values())[o.id().value()] = 2.0;
+  primal_proto.set_feasibility_status(SOLUTION_STATUS_INFEASIBLE);
+  for (int i : {0, 1}) {
+    primal_proto.mutable_variable_values()->add_ids(i);
+  }
+  for (double v : {2.0, 1.0}) {
+    primal_proto.mutable_variable_values()->add_values(v);
+  }
+
+  DualSolutionProto& dual_proto = *proto.mutable_dual_solution();
+  dual_proto.set_objective_value(9.0);
+  dual_proto.set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  for (int i : {0, 1}) {
+    dual_proto.mutable_reduced_costs()->add_ids(i);
+  }
+  for (double v : {2.0, 1.0}) {
+    dual_proto.mutable_reduced_costs()->add_values(v);
+  }
+  for (int i : {0, 1}) {
+    dual_proto.mutable_dual_values()->add_ids(i);
+  }
+  for (double v : {3.0, 4.0}) {
+    dual_proto.mutable_dual_values()->add_values(v);
+  }
+
+  BasisProto& basis_proto = *proto.mutable_basis();
+  for (int i : {0, 1}) {
+    basis_proto.mutable_variable_status()->add_ids(i);
+  }
+  basis_proto.mutable_variable_status()->add_values(
+      BASIS_STATUS_AT_UPPER_BOUND);
+  basis_proto.mutable_variable_status()->add_values(BASIS_STATUS_FREE);
+  for (int i : {0, 1}) {
+    basis_proto.mutable_constraint_status()->add_ids(i);
+  }
+  basis_proto.mutable_constraint_status()->add_values(
+      BASIS_STATUS_AT_LOWER_BOUND);
+  basis_proto.mutable_constraint_status()->add_values(BASIS_STATUS_BASIC);
+  basis_proto.set_basic_dual_feasibility(SOLUTION_STATUS_FEASIBLE);
+
+  const Solution expected{
+      .primal_solution =
+          PrimalSolution{.variable_values = {{x, 2.0}, {y, 1.0}},
+                         .objective_value = 9.0,
+                         .auxiliary_objective_values = {{o, 2.0}},
+                         .feasibility_status = SolutionStatus::kInfeasible},
+      .dual_solution =
+          DualSolution{.dual_values = {{c, 3.0}, {d, 4.0}},
+                       .reduced_costs = {{x, 2.0}, {y, 1.0}},
+                       .objective_value = 9.0,
+                       .feasibility_status = SolutionStatus::kFeasible},
+      .basis = Basis{.constraint_status = {{c, BasisStatus::kAtLowerBound},
+                                           {d, BasisStatus::kBasic}},
+                     .variable_status = {{x, BasisStatus::kAtUpperBound},
+                                         {y, BasisStatus::kFree}},
+                     .basic_dual_feasibility = SolutionStatus::kFeasible}};
+
+  // Test one way
+  EXPECT_THAT(
+      Solution::FromProto(&model, proto),
+      IsOkAndHolds(IsNear(expected, SolutionMatcherOptions{.tolerance = 0.0})));
+  // Test round trip
+  EXPECT_THAT(
+      Solution::FromProto(&model, expected.Proto()),
+      IsOkAndHolds(IsNear(expected, SolutionMatcherOptions{.tolerance = 0.0})));
+}
+
+TEST(SolutionTest, FromProtoInvalidPrimalSolution) {
+  ModelStorage storage;
+  storage.AddVariable("x");
+  SolutionProto proto;
+  proto.mutable_primal_solution()->mutable_variable_values()->add_ids(0);
+  proto.mutable_primal_solution()->set_feasibility_status(
+      SOLUTION_STATUS_FEASIBLE);
+  EXPECT_THAT(Solution::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("primal_solution")));
+}
+
+TEST(SolutionTest, FromProtoInvalidDualSolution) {
+  ModelStorage storage;
+  storage.AddLinearConstraint("c");
+  SolutionProto proto;
+  proto.mutable_dual_solution()->mutable_dual_values()->add_ids(0);
+  proto.mutable_dual_solution()->set_feasibility_status(
+      SOLUTION_STATUS_FEASIBLE);
+  EXPECT_THAT(
+      Solution::FromProto(&storage, proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("dual_solution")));
+}
+
+TEST(SolutionTest, FromProtoInvalidBasis) {
+  ModelStorage storage;
+  storage.AddVariable("c");
+  SolutionProto proto;
+  proto.mutable_basis()->mutable_variable_status()->add_ids(0);
+  EXPECT_THAT(Solution::FromProto(&storage, proto),
+              StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("basis")));
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/solve_arguments_test.cc b/ortools/math_opt/cpp/solve_arguments_test.cc
new file mode 100644
index 0000000000..0451cd3872
--- /dev/null
+++ b/ortools/math_opt/cpp/solve_arguments_test.cc
@@ -0,0 +1,97 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/solve_arguments.h"
+
+#include <string>
+#include <type_traits>
+
+#include "absl/status/status.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+using ::testing::HasSubstr;
+using ::testing::status::StatusIs;
+
+TEST(CheckModelStorageAndCallbackTest, CorrectModelAndCallback) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+
+  const SolveArguments args = {
+      .model_parameters = ModelSolveParameters::OnlySomePrimalVariables({x}),
+      .callback_registration =
+          {
+              .events = {CallbackEvent::kMipSolution},
+              .mip_solution_filter = MakeKeepKeysFilter({x}),
+          },
+      .callback = [](const CallbackData&) { return CallbackResult{}; },
+  };
+
+  EXPECT_OK(args.CheckModelStorageAndCallback(model.storage()));
+}
+
+TEST(CheckModelStorageAndCallbackTest, WrongModelInModelParameters) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+
+  const SolveArguments args = {
+      .model_parameters = ModelSolveParameters::OnlySomePrimalVariables({x}),
+  };
+
+  Model other_model;
+  EXPECT_THAT(args.CheckModelStorageAndCallback(other_model.storage()),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("model_parameters")));
+}
+
+TEST(CheckModelStorageAndCallbackTest, WrongModelInCallbackRegistration) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+
+  const SolveArguments args = {
+      .callback_registration =
+          {
+              .events = {CallbackEvent::kMipSolution},
+              .mip_solution_filter = MakeKeepKeysFilter({x}),
+          },
+      .callback = [](const CallbackData&) { return CallbackResult{}; },
+  };
+
+  Model other_model;
+  EXPECT_THAT(args.CheckModelStorageAndCallback(other_model.storage()),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       AllOf(HasSubstr("callback_registration"),
+                             HasSubstr("mip_solution_filter"))));
+}
+
+TEST(CheckModelStorageAndCallbackTest, NoCallbackWithRegisteredEvents) {
+  Model model;
+
+  const SolveArguments args = {
+      .callback_registration =
+          {
+              .events = {CallbackEvent::kMipSolution},
+          },
+  };
+
+  EXPECT_THAT(
+      args.CheckModelStorageAndCallback(model.storage()),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("no callback")));
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/solve_impl.cc b/ortools/math_opt/cpp/solve_impl.cc
index b77443820f..a9eb04724f 100644
--- a/ortools/math_opt/cpp/solve_impl.cc
+++ b/ortools/math_opt/cpp/solve_impl.cc
@@ -62,7 +62,7 @@ absl::StatusOr<SolveResult> CallSolve(BaseSolver& solver,
         builder << "invalid CallbackResult returned by user callback";
 
         {  // Limit `lock` scope.
-          const absl::MutexLock lock(&mutex);
+          const absl::MutexLock lock(mutex);
           cb_status.Update(builder);
         }
 
@@ -93,7 +93,7 @@ absl::StatusOr<SolveResult> CallSolve(BaseSolver& solver,
   // that case we want to ignore this error and return status generated in the
   // callback instead.
   {  // Limit `lock` scope.
-    const absl::MutexLock lock(&mutex);
+    const absl::MutexLock lock(mutex);
     RETURN_IF_ERROR(cb_status);
   }
 
diff --git a/ortools/math_opt/cpp/solve_impl_test.cc b/ortools/math_opt/cpp/solve_impl_test.cc
new file mode 100644
index 0000000000..12f264ddc7
--- /dev/null
+++ b/ortools/math_opt/cpp/solve_impl_test.cc
@@ -0,0 +1,1865 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/solve_impl.h"
+
+#include <limits>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/die_if_null.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/callback.pb.h"
+#include "ortools/math_opt/core/base_solver.h"
+#include "ortools/math_opt/core/math_opt_proto_utils.h"
+#include "ortools/math_opt/core/sparse_collection_matchers.h"
+#include "ortools/math_opt/cpp/callback.h"
+#include "ortools/math_opt/cpp/compute_infeasible_subsystem_arguments.h"
+#include "ortools/math_opt/cpp/compute_infeasible_subsystem_result.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/cpp/model.h"
+#include "ortools/math_opt/cpp/update_result.h"
+#include "ortools/math_opt/infeasible_subsystem.pb.h"
+#include "ortools/math_opt/model_parameters.pb.h"
+#include "ortools/math_opt/solution.pb.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+#include "ortools/util/solve_interrupter.h"
+
+namespace operations_research::math_opt::internal {
+namespace {
+
+using ::testing::_;
+using ::testing::ByMove;
+using ::testing::Eq;
+using ::testing::EquivToProto;
+using ::testing::Field;
+using ::testing::HasSubstr;
+using ::testing::InSequence;
+using ::testing::Mock;
+using ::testing::Ne;
+using ::testing::Optional;
+using ::testing::Pair;
+using ::testing::Return;
+using ::testing::UnorderedElementsAre;
+using ::testing::status::StatusIs;
+
+class BaseSolverMock : public BaseSolver {
+ public:
+  MOCK_METHOD(absl::StatusOr<SolveResultProto>, Solve,
+              (const SolveArgs& arguments), (override));
+
+  MOCK_METHOD(absl::StatusOr<ComputeInfeasibleSubsystemResultProto>,
+              ComputeInfeasibleSubsystem,
+              (const ComputeInfeasibleSubsystemArgs& arguments), (override));
+
+  MOCK_METHOD(absl::StatusOr<bool>, Update, (ModelUpdateProto model_update),
+              (override));
+};
+
+// Mock for BaseSolverFactory.
+using BaseSolverFactoryMock =
+    testing::MockFunction<absl::StatusOr<std::unique_ptr<BaseSolver>>(
+        SolverTypeProto solver_type, const ModelProto& model,
+        SolveInterrupter* local_canceller)>;
+
+// Delegate all calls to another instance of BaseSolver.
+//
+// This is used as a return value in BaseSolverFactoryMock as:
+// * this function needs to return a unique_ptr<BaseSolver>
+// * but we want to be able to use a BaseSolverMock from the stack.
+//
+// Thus we can simply mock BaseSolverFactoryMock with
+//   BaseSolverMock solver;
+//
+//   EXPECT_CALL(factory_mock,
+//               Call(EquivToProto(basic_lp.model.ExportModel()), _, _))
+//       .WillOnce(Return(ByMove(
+//         std::make_unique<DelegatingBaseSolver>(&solver))));
+//
+// and add other EXPECT_CALL(solver, ...) on the instance that exists on stack.
+class DelegatingBaseSolver : public BaseSolver {
+ public:
+  // Wraps the input solver interface, delegating calls to it. The optional
+  // destructor_cb callback will be called in ~DelegatingBaseSolver().
+  explicit DelegatingBaseSolver(
+      BaseSolver* const solver,
+      absl::AnyInvocable<void()> destructor_cb = nullptr)
+      : solver_(ABSL_DIE_IF_NULL(solver)),
+        destructor_cb_(std::move(destructor_cb)) {}
+
+  ~DelegatingBaseSolver() override {
+    if (destructor_cb_ != nullptr) {
+      destructor_cb_();
+    }
+  }
+
+  absl::StatusOr<SolveResultProto> Solve(const SolveArgs& arguments) override {
+    return solver_->Solve(arguments);
+  }
+
+  absl::StatusOr<ComputeInfeasibleSubsystemResultProto>
+  ComputeInfeasibleSubsystem(
+      const ComputeInfeasibleSubsystemArgs& arguments) override {
+    return solver_->ComputeInfeasibleSubsystem(arguments);
+  }
+
+  absl::StatusOr<bool> Update(ModelUpdateProto model_update) override {
+    return solver_->Update(std::move(model_update));
+  }
+
+ private:
+  BaseSolver* const solver_;
+  absl::AnyInvocable<void()> destructor_cb_;
+};
+
+// Returns a matcher that matches the fields of SolveArgs according to the
+// provided matchers.
+//
+// Note that we have to use template parameters for function/data pointers
+// fields as we can't use testing::Matcher<FuncType> or
+// testing::Matcher<DataType*>.
+template <typename MessageCallbackMatcher, typename CallbackMatcher,
+          typename SolveInterrupterPtrMatcher>
+testing::Matcher<const BaseSolver::SolveArgs&> SolveArgsAre(
+    testing::Matcher<SolveParametersProto> parameters,
+    testing::Matcher<ModelSolveParametersProto> model_parameters,
+    MessageCallbackMatcher message_callback,
+    testing::Matcher<CallbackRegistrationProto> callback_registration,
+    CallbackMatcher user_cb, SolveInterrupterPtrMatcher interrupter) {
+  return AllOf(
+      Field("parameters", &BaseSolver::SolveArgs::parameters, parameters),
+      Field("model_parameters", &BaseSolver::SolveArgs::model_parameters,
+            model_parameters),
+      Field("message_callback", &BaseSolver::SolveArgs::message_callback,
+            message_callback),
+      Field("callback_registration",
+            &BaseSolver::SolveArgs::callback_registration,
+            callback_registration),
+      Field("user_cb", &BaseSolver::SolveArgs::user_cb, user_cb),
+      Field("interrupter", &BaseSolver::SolveArgs::interrupter, interrupter));
+}
+
+// Returns a matcher that matches the fields of ComputeInfeasibleSubsystemArgs
+// according to the provided matchers.
+//
+// Note that we have to use template parameters for function/data pointers
+// fields as we can't use testing::Matcher<FuncType> or
+// testing::Matcher<DataType*>.
+template <typename MessageCallbackMatcher, typename SolveInterrupterPtrMatcher>
+testing::Matcher<const BaseSolver::ComputeInfeasibleSubsystemArgs&>
+ComputeInfeasibleSubsystemArgsAre(
+    testing::Matcher<SolveParametersProto> parameters,
+    MessageCallbackMatcher message_callback,
+    SolveInterrupterPtrMatcher interrupter) {
+  return AllOf(
+      Field("parameters",
+            &BaseSolver::ComputeInfeasibleSubsystemArgs::parameters,
+            parameters),
+      Field("message_callback",
+            &BaseSolver::ComputeInfeasibleSubsystemArgs::message_callback,
+            message_callback),
+      Field("interrupter",
+            &BaseSolver::ComputeInfeasibleSubsystemArgs::interrupter,
+            interrupter));
+}
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+// Basic LP model:
+//
+//   a and b are continuous variable
+//
+//   minimize a - b
+//       s.t. 0 <= a
+//            0 <= b <= 3
+struct BasicLp {
+  BasicLp();
+
+  // Sets the upper bound of variable b to 2.0 and returns the corresponding
+  // update.
+  std::optional<ModelUpdateProto> UpdateUpperBoundOfB();
+
+  // Returns the expected optimal result for this model. Only put the given set
+  // of variables in the result (to test filters). When `after_update` is true,
+  // returns the optimal result after UpdateUpperBoundOfB() has been called.
+  SolveResultProto OptimalResult(const absl::flat_hash_set<Variable>& vars,
+                                 bool after_update = false) const;
+
+  Model model;
+  const Variable a;
+  const Variable b;
+};
+
+BasicLp::BasicLp()
+    : a(model.AddVariable(0.0, kInf, false, "a")),
+      b(model.AddVariable(0.0, 3.0, false, "b")) {}
+
+std::optional<ModelUpdateProto> BasicLp::UpdateUpperBoundOfB() {
+  const std::unique_ptr<UpdateTracker> tracker = model.NewUpdateTracker();
+  model.set_upper_bound(b, 2.0);
+  return tracker->ExportModelUpdate().value();
+}
+
+SolveResultProto BasicLp::OptimalResult(
+    const absl::flat_hash_set<Variable>& vars, bool after_update) const {
+  SolveResultProto result;
+  result.mutable_termination()->set_reason(TERMINATION_REASON_OPTIMAL);
+  result.mutable_solve_stats()->mutable_problem_status()->set_primal_status(
+      FEASIBILITY_STATUS_FEASIBLE);
+  result.mutable_solve_stats()->mutable_problem_status()->set_dual_status(
+      FEASIBILITY_STATUS_FEASIBLE);
+  PrimalSolutionProto* const solution =
+      result.add_solutions()->mutable_primal_solution();
+  solution->set_objective_value(0.0);
+  solution->set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  if (vars.contains(a)) {
+    solution->mutable_variable_values()->add_ids(a.id());
+    solution->mutable_variable_values()->add_values(0.0);
+  }
+  if (vars.contains(b)) {
+    solution->mutable_variable_values()->add_ids(b.id());
+    solution->mutable_variable_values()->add_values(after_update ? 2.0 : 3.0);
+  }
+  return result;
+}
+
+// Basic infeasible LP model:
+//
+//   minimize 0
+//       s.t. x <= -1 (linear constraint)
+//            0 <= x <= 1 (bounds)
+struct BasicInfeasibleLp {
+  BasicInfeasibleLp()
+      : x(model.AddContinuousVariable(0.0, 1.0, "x")),
+        c(model.AddLinearConstraint(x <= -1.0, "c")) {}
+
+  ComputeInfeasibleSubsystemResultProto InfeasibleResult() const {
+    ComputeInfeasibleSubsystemResultProto result;
+    result.set_feasibility(FEASIBILITY_STATUS_INFEASIBLE);
+    (*result.mutable_infeasible_subsystem()->mutable_variable_bounds())[0]
+        .set_lower(true);
+    (*result.mutable_infeasible_subsystem()->mutable_variable_bounds())[0]
+        .set_upper(false);
+    (*result.mutable_infeasible_subsystem()->mutable_linear_constraints())[0]
+        .set_lower(false);
+    (*result.mutable_infeasible_subsystem()->mutable_linear_constraints())[0]
+        .set_upper(true);
+    result.set_is_minimal(true);
+    return result;
+  }
+
+  // Sets the upper bound of constraint c to -2.0 and returns the corresponding
+  // update.
+  std::optional<ModelUpdateProto> UpdateUpperBoundOfC() {
+    const std::unique_ptr<UpdateTracker> tracker = model.NewUpdateTracker();
+    model.set_upper_bound(c, -2.0);
+    return tracker->ExportModelUpdate().value();
+  }
+
+  Model model;
+  const Variable x;
+  const LinearConstraint c;
+};
+
+// Test calling Solve() without any callback.
+TEST(SolveImplTest, SuccessfulSolveNoCallback) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolveInterrupter interrupter;
+  args.interrupter = &interrupter;
+
+  args.message_callback = [](absl::Span<const std::string>) {};
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(SOLVER_TYPE_GLOP,
+                     EquivToProto(basic_lp.model.ExportModel()), Ne(nullptr)))
+        .WillOnce(
+            Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(SolveArgsAre(
+                            EquivToProto(args.parameters.Proto()),
+                            EquivToProto(model_parameters), Ne(nullptr),
+                            EquivToProto(args.callback_registration.Proto()),
+                            Eq(nullptr), Eq(&interrupter))))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      SolveImpl(factory_mock.AsStdFunction(), basic_lp.model, SolverType::kGlop,
+                args, /*user_canceller=*/nullptr,
+                /*remove_names=*/false));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+// Test calling Solve() with a callback.
+TEST(SolveImplTest, SuccessfulSolveWithCallback) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve = [&](const BaseSolver::SolveArgs& args)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    args.user_cb(cb_data);
+    return basic_lp.OptimalResult({basic_lp.a});
+  };
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(
+        factory_mock,
+        Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(
+            Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(SolveArgsAre(
+                            EquivToProto(args.parameters.Proto()),
+                            EquivToProto(model_parameters), Eq(nullptr),
+                            EquivToProto(args.callback_registration.Proto()),
+                            Ne(nullptr), Eq(nullptr))))
+        .WillOnce(fake_solve);
+  }
+
+  int callback_called_count = 0;
+  args.callback = [&](const CallbackData& callback_data) {
+    ++callback_called_count;
+    CallbackResult result;
+    result.AddLazyConstraint(basic_lp.a + basic_lp.b <= 3);
+    return result;
+  };
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      SolveImpl(factory_mock.AsStdFunction(), basic_lp.model, SolverType::kGlop,
+                args, /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  EXPECT_EQ(callback_called_count, 1);
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+TEST(SolveImplTest, RemoveNamesSendsNoNames) {
+  Model model;
+  model.AddBinaryVariable("x");
+
+  ModelProto expected_model;
+  expected_model.mutable_variables()->add_ids(0);
+  expected_model.mutable_variables()->add_lower_bounds(0.0);
+  expected_model.mutable_variables()->add_upper_bounds(1.0);
+  expected_model.mutable_variables()->add_integers(true);
+
+  SolveResultProto fake_result;
+  *fake_result.mutable_termination() =
+      NoSolutionFoundTerminationProto(/*is_maximize=*/false, LIMIT_TIME);
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(SOLVER_TYPE_GLOP, EquivToProto(expected_model), _))
+        .WillOnce(
+            Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+    EXPECT_CALL(solver, Solve(SolveArgsAre(_, _, _, _, _, _)))
+        .WillOnce(Return(fake_result));
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      SolveImpl(factory_mock.AsStdFunction(), model, SolverType::kGlop, {},
+                /*user_canceller=*/nullptr, /*remove_names=*/true));
+}
+
+// Test calling Solve() with a solver that fails to returns the SolverInterface
+// for a given model.
+TEST(SolveImplTest, FailingSolveInstantiation) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(absl::InternalError("instantiation failed"))));
+
+  ASSERT_THAT(SolveImpl(factory_mock.AsStdFunction(), basic_lp.model,
+                        SolverType::kGlop, args,
+                        /*user_canceller=*/nullptr, /*remove_names=*/false),
+              StatusIs(absl::StatusCode::kInternal, "instantiation failed"));
+}
+
+// Test calling Solve() with a solver that returns an error on
+// SolverInterface::Solve().
+TEST(SolveImplTest, FailingSolve) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(
+        factory_mock,
+        Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(
+            Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(SolveArgsAre(
+                            EquivToProto(args.parameters.Proto()),
+                            EquivToProto(model_parameters), Eq(nullptr),
+                            EquivToProto(args.callback_registration.Proto()),
+                            Eq(nullptr), Eq(nullptr))))
+        .WillOnce(Return(absl::InternalError("solve failed")));
+  }
+
+  ASSERT_THAT(
+      SolveImpl(factory_mock.AsStdFunction(), basic_lp.model, SolverType::kGlop,
+                args, /*user_canceller=*/nullptr, /*remove_names=*/false),
+      StatusIs(absl::StatusCode::kInternal, "solve failed"));
+}
+
+TEST(SolveImplTest, NullCallback) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(
+          Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+  EXPECT_THAT(
+      SolveImpl(factory_mock.AsStdFunction(), basic_lp.model, SolverType::kGlop,
+                args, /*user_canceller=*/nullptr, /*remove_names=*/false),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr("no callback was provided")));
+}
+
+TEST(SolveImplTest, WrongModelInModelParameters) {
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({other_basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(
+          Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+  EXPECT_THAT(
+      SolveImpl(factory_mock.AsStdFunction(), basic_lp.model, SolverType::kGlop,
+                args, /*user_canceller=*/nullptr, /*remove_names=*/false),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(SolveImplTest, WrongModelInCallbackRegistration) {
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.callback_registration.mip_solution_filter =
+      MakeKeepKeysFilter({other_basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(
+          Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+  EXPECT_THAT(
+      SolveImpl(factory_mock.AsStdFunction(), basic_lp.model, SolverType::kGlop,
+                args, /*user_canceller=*/nullptr, /*remove_names=*/false),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(SolveImplTest, WrongModelInCallbackResult) {
+  // We repeat the same test but either return a valid result or an error in
+  // fake_solve.
+  for (const bool return_an_error : {false, true}) {
+    SCOPED_TRACE(return_an_error ? "with fake_solve returning an error"
+                                 : "with fake_solve returning a result");
+    BasicLp basic_lp;
+    BasicLp other_basic_lp;
+
+    SolveArguments args;
+    args.parameters.enable_output = true;
+
+    args.callback_registration.add_lazy_constraints = true;
+    args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+    // Will be set to the provided local_canceller in the factory.
+    SolveInterrupter* provided_local_canceller = nullptr;
+
+    const auto fake_solve = [&](const BaseSolver::SolveArgs& args)
+        -> absl::StatusOr<SolveResultProto> {
+      CallbackDataProto cb_data;
+      cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+      *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+          {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+      CallbackResultProto result = args.user_cb(cb_data);
+      // Errors in callback should result in early termination.
+      EXPECT_TRUE(result.terminate());
+      // Errors in callback should trigger the cancellation.
+      EXPECT_TRUE(provided_local_canceller->IsInterrupted());
+      // The returned value should be ignored.
+      if (return_an_error) {
+        return absl::CancelledError("solver has been cancelled");
+      }
+      return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+    };
+
+    BaseSolverFactoryMock factory_mock;
+    BaseSolverMock solver;
+    {
+      InSequence s;
+
+      EXPECT_CALL(
+          factory_mock,
+          Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+          .WillOnce([&](const SolverTypeProto solver_type,
+                        const ModelProto& model,
+                        SolveInterrupter* const local_canceller) {
+            provided_local_canceller = local_canceller;
+            return std::make_unique<DelegatingBaseSolver>(&solver);
+          });
+
+      ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                           args.model_parameters.Proto());
+      EXPECT_CALL(solver, Solve(SolveArgsAre(
+                              EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Eq(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Ne(nullptr), Eq(nullptr))))
+          .WillOnce(fake_solve);
+    }
+
+    args.callback = [&](const CallbackData& callback_data) {
+      CallbackResult result;
+      // We use the wrong model here.
+      result.AddLazyConstraint(other_basic_lp.a + other_basic_lp.b <= 3);
+      return result;
+    };
+
+    EXPECT_THAT(SolveImpl(factory_mock.AsStdFunction(), basic_lp.model,
+                          SolverType::kGlop, args, /*user_canceller=*/nullptr,
+                          /*remove_names=*/false),
+                StatusIs(absl::StatusCode::kInvalidArgument,
+                         HasSubstr(internal::kInputFromInvalidModelStorage)));
+  }
+}
+
+TEST(SolveImplTest, UserCancellation) {
+  BasicLp basic_lp;
+
+  // Will be set to the provided local_canceller in the factory.
+  SolveInterrupter* provided_local_canceller = nullptr;
+
+  const auto fake_solve = [&](const BaseSolver::SolveArgs& args)
+      -> absl::StatusOr<SolveResultProto> {
+    // The solver should have been cancelled before its Solve() is called.
+    EXPECT_TRUE(provided_local_canceller->IsInterrupted());
+    return absl::CancelledError("solver has been cancelled");
+  };
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP, _, Ne(nullptr)))
+        .WillOnce([&](const SolverTypeProto solver_type,
+                      const ModelProto& model,
+                      SolveInterrupter* const local_canceller) {
+          provided_local_canceller = local_canceller;
+          return std::make_unique<DelegatingBaseSolver>(&solver);
+        });
+
+    EXPECT_CALL(solver, Solve(_)).WillOnce(fake_solve);
+  }
+
+  SolveInterrupter user_canceller;
+  user_canceller.Interrupt();
+
+  ASSERT_THAT(
+      SolveImpl(factory_mock.AsStdFunction(), basic_lp.model, SolverType::kGlop,
+                {}, /*user_canceller=*/&user_canceller,
+                /*remove_names=*/false),
+      StatusIs(absl::StatusCode::kCancelled));
+}
+
+TEST(ComputeInfeasibleSubsystemImplTest, SuccessfulCall) {
+  BasicInfeasibleLp lp;
+
+  ComputeInfeasibleSubsystemArguments args;
+  args.parameters.enable_output = true;
+
+  SolveInterrupter interrupter;
+  args.interrupter = &interrupter;
+
+  args.message_callback = [](absl::Span<const std::string>) {};
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(SOLVER_TYPE_GLOP, EquivToProto(lp.model.ExportModel()), _))
+        .WillOnce(
+            Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+    EXPECT_CALL(solver,
+                ComputeInfeasibleSubsystem(ComputeInfeasibleSubsystemArgsAre(
+                    EquivToProto(args.parameters.Proto()), Ne(nullptr),
+                    Eq(&interrupter))))
+        .WillOnce(Return(lp.InfeasibleResult()));
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const ComputeInfeasibleSubsystemResult result,
+      ComputeInfeasibleSubsystemImpl(
+          factory_mock.AsStdFunction(), lp.model, SolverType::kGlop, args,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  EXPECT_EQ(result.feasibility, FeasibilityStatus::kInfeasible);
+}
+
+TEST(ComputeInfeasibleSubsystemImplTest, FailingSolve) {
+  BasicInfeasibleLp lp;
+
+  ComputeInfeasibleSubsystemArguments args;
+  args.parameters.enable_output = true;
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(SOLVER_TYPE_GLOP, EquivToProto(lp.model.ExportModel()), _))
+        .WillOnce(
+            Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+    EXPECT_CALL(
+        solver,
+        ComputeInfeasibleSubsystem(ComputeInfeasibleSubsystemArgsAre(
+            EquivToProto(args.parameters.Proto()), Eq(nullptr), Eq(nullptr))))
+        .WillOnce(Return(absl::InternalError("infeasible subsystem failed")));
+  }
+
+  ASSERT_THAT(
+      ComputeInfeasibleSubsystemImpl(
+          factory_mock.AsStdFunction(), lp.model, SolverType::kGlop, args,
+          /*user_canceller=*/nullptr, /*remove_names=*/false),
+      StatusIs(absl::StatusCode::kInternal, "infeasible subsystem failed"));
+}
+
+TEST(ComputeInfeasibleSubsystemImplTest, UserCancellation) {
+  BasicLp basic_lp;
+
+  // Will be set to the provided local_canceller in the factory.
+  SolveInterrupter* provided_local_canceller = nullptr;
+
+  const auto fake_solve =
+      [&](const BaseSolver::ComputeInfeasibleSubsystemArgs& args)
+      -> absl::StatusOr<ComputeInfeasibleSubsystemResultProto> {
+    // The solver should have been cancelled before its
+    // ComputeInfeasibleSubsystem() is called.
+    EXPECT_TRUE(provided_local_canceller->IsInterrupted());
+    return absl::CancelledError("solver has been cancelled");
+  };
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(SOLVER_TYPE_GLOP,
+                     EquivToProto(basic_lp.model.ExportModel()), Ne(nullptr)))
+        .WillOnce([&](const SolverTypeProto solver_type,
+                      const ModelProto& model,
+                      SolveInterrupter* const local_canceller) {
+          provided_local_canceller = local_canceller;
+          return std::make_unique<DelegatingBaseSolver>(&solver);
+        });
+
+    EXPECT_CALL(solver, ComputeInfeasibleSubsystem(_)).WillOnce(fake_solve);
+  }
+
+  SolveInterrupter user_canceller;
+  user_canceller.Interrupt();
+
+  ASSERT_THAT(ComputeInfeasibleSubsystemImpl(
+                  factory_mock.AsStdFunction(), basic_lp.model,
+                  SolverType::kGlop, {}, /*user_canceller=*/&user_canceller,
+                  /*remove_names=*/false),
+              StatusIs(absl::StatusCode::kCancelled));
+}
+
+TEST(IncrementalSolverImplTest, NullModel) {
+  BaseSolverFactoryMock factory_mock;
+
+  EXPECT_THAT(IncrementalSolverImpl::New(
+                  factory_mock.AsStdFunction(), nullptr, SolverType::kGlop,
+                  /*user_canceller=*/nullptr, /*remove_names=*/false),
+              StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("model")));
+}
+
+TEST(IncrementalSolverImplTest, SolverType) {
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+  BasicLp basic_lp;
+
+  EXPECT_CALL(factory_mock,
+              Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()),
+                   Ne(nullptr)))
+      .WillOnce(
+          Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> incremental_solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+  EXPECT_EQ(incremental_solver->solver_type(), SolverType::kGlop);
+}
+
+// Test calling IncrementalSolver without any callback with a succeeding
+// non-empty update.
+TEST(IncrementalSolverImplTest, IncrementalSolveNoCallback) {
+  BasicLp basic_lp;
+
+  BaseSolverMock solver_interface;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolveInterrupter interrupter;
+  args_1.interrupter = &interrupter;
+
+  BaseSolverFactoryMock factory_mock;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                         args_1.model_parameters.Proto());
+    EXPECT_CALL(
+        solver_interface,
+        Solve(SolveArgsAre(EquivToProto(args_1.parameters.Proto()),
+                           EquivToProto(model_parameters_1), Eq(nullptr),
+                           EquivToProto(args_1.callback_registration.Proto()),
+                           Eq(nullptr), Eq(&interrupter))))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Second solve with update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+      .WillOnce(Return(true));
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_TRUE(update_result.did_update);
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_2,
+                         args_2.model_parameters.Proto());
+    EXPECT_CALL(
+        solver_interface,
+        Solve(SolveArgsAre(EquivToProto(args_2.parameters.Proto()),
+                           EquivToProto(model_parameters_2), Eq(nullptr),
+                           EquivToProto(args_2.callback_registration.Proto()),
+                           Eq(nullptr), Eq(nullptr))))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a, basic_lp.b},
+                                                /*after_update=*/true)));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_2,
+                       solver->SolveWithoutUpdate(args_2));
+
+  EXPECT_EQ(result_2.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(
+      result_2.variable_values(),
+      UnorderedElementsAre(Pair(basic_lp.a, 0.0), Pair(basic_lp.b, 2.0)));
+}
+
+TEST(IncrementalSolverImplTest, RemoveNamesSendsNoNamesOnModel) {
+  Model model;
+  model.AddBinaryVariable("x");
+
+  ModelProto expected_model;
+  expected_model.mutable_variables()->add_ids(0);
+  expected_model.mutable_variables()->add_lower_bounds(0.0);
+  expected_model.mutable_variables()->add_upper_bounds(1.0);
+  expected_model.mutable_variables()->add_integers(true);
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+  EXPECT_CALL(factory_mock,
+              Call(SOLVER_TYPE_GLOP, EquivToProto(expected_model), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  EXPECT_OK(IncrementalSolverImpl::New(
+      factory_mock.AsStdFunction(), &model, SolverType::kGlop,
+      /*user_canceller=*/nullptr, /*remove_names=*/true));
+}
+
+TEST(IncrementalSolverImplTest, RemoveNamesSendsNoNamesOnModelUpdate) {
+  Model model;
+
+  SolveArguments args;
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP, _, _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(std::unique_ptr<IncrementalSolver> solver,
+                       IncrementalSolverImpl::New(factory_mock.AsStdFunction(),
+                                                  &model, SolverType::kGlop,
+                                                  /*user_canceller=*/nullptr,
+                                                  /*remove_names=*/true));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  model.AddBinaryVariable("x");
+
+  ModelUpdateProto expected_update;
+  expected_update.mutable_new_variables()->add_ids(0);
+  expected_update.mutable_new_variables()->add_lower_bounds(0.0);
+  expected_update.mutable_new_variables()->add_upper_bounds(1.0);
+  expected_update.mutable_new_variables()->add_integers(true);
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(expected_update)))
+      .WillOnce(Return(true));
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_TRUE(update_result.did_update);
+}
+
+TEST(IncrementalSolverImplTest, RemoveNamesOnFullModelAfterUpdateFails) {
+  Model model;
+
+  SolveArguments args;
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP, _, _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(std::unique_ptr<IncrementalSolver> solver,
+                       IncrementalSolverImpl::New(factory_mock.AsStdFunction(),
+                                                  &model, SolverType::kGlop,
+                                                  /*user_canceller=*/nullptr,
+                                                  /*remove_names=*/true));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  model.AddBinaryVariable("x");
+
+  ModelProto expected_model;
+  expected_model.mutable_variables()->add_ids(0);
+  expected_model.mutable_variables()->add_lower_bounds(0.0);
+  expected_model.mutable_variables()->add_upper_bounds(1.0);
+  expected_model.mutable_variables()->add_integers(true);
+
+  EXPECT_CALL(solver_interface, Update(_)).WillOnce(Return(false));
+  BaseSolverMock solver_interface2;
+  EXPECT_CALL(factory_mock,
+              Call(SOLVER_TYPE_GLOP, EquivToProto(expected_model), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface2))));
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_FALSE(update_result.did_update);
+}
+
+// Test calling IncrementalSolver without any callback with an empty update.
+TEST(IncrementalSolverImplTest, IncrementalSolveWithEmptyUpdate) {
+  BasicLp basic_lp;
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                         args_1.model_parameters.Proto());
+    EXPECT_CALL(
+        solver_interface,
+        Solve(SolveArgsAre(EquivToProto(args_1.parameters.Proto()),
+                           EquivToProto(model_parameters_1), Eq(nullptr),
+                           EquivToProto(args_1.callback_registration.Proto()),
+                           Eq(nullptr), Eq(nullptr))))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Second solve with update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_2,
+                         args_2.model_parameters.Proto());
+    EXPECT_CALL(
+        solver_interface,
+        Solve(SolveArgsAre(EquivToProto(args_2.parameters.Proto()),
+                           EquivToProto(model_parameters_2), Eq(nullptr),
+                           EquivToProto(args_2.callback_registration.Proto()),
+                           Eq(nullptr), Eq(nullptr))))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a, basic_lp.b})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_TRUE(update_result.did_update);
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_2,
+                       solver->SolveWithoutUpdate(args_2));
+
+  EXPECT_EQ(result_2.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(
+      result_2.variable_values(),
+      UnorderedElementsAre(Pair(basic_lp.a, 0.0), Pair(basic_lp.b, 3.0)));
+}
+
+// Test calling IncrementalSolver without any callback and with a failing
+// update; thus resulting in the re-creation of the solver instead.
+TEST(IncrementalSolverImplTest, IncrementalSolveWithFailedUpdate) {
+  BasicLp basic_lp;
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_1;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(
+          Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver_1))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                       args_1.model_parameters.Proto());
+  EXPECT_CALL(solver_1, Solve(SolveArgsAre(
+                            EquivToProto(args_1.parameters.Proto()),
+                            EquivToProto(model_parameters_1), Eq(nullptr),
+                            EquivToProto(args_1.callback_registration.Proto()),
+                            Eq(nullptr), Eq(nullptr))))
+      .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Second solve with update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  BaseSolverMock solver_2;
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(solver_1, Update(EquivToProto(*update)))
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(
+        factory_mock,
+        Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(
+            Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver_2))));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_FALSE(update_result.did_update);
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+  Mock::VerifyAndClearExpectations(&solver_2);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_2,
+                       args_2.model_parameters.Proto());
+  EXPECT_CALL(solver_2, Solve(SolveArgsAre(
+                            EquivToProto(args_2.parameters.Proto()),
+                            EquivToProto(model_parameters_2), Eq(nullptr),
+                            EquivToProto(args_2.callback_registration.Proto()),
+                            Eq(nullptr), Eq(nullptr))))
+      .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a, basic_lp.b},
+                                              /*after_update=*/true)));
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_2,
+                       solver->SolveWithoutUpdate(args_2));
+
+  EXPECT_EQ(result_2.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(
+      result_2.variable_values(),
+      UnorderedElementsAre(Pair(basic_lp.a, 0.0), Pair(basic_lp.b, 2.0)));
+}
+
+// Test calling IncrementalSolver without any callback and with an impossible
+// update, i.e. an update that contains an unsupported feature.
+TEST(IncrementalSolverImplTest, IncrementalSolveWithImpossibleUpdate) {
+  BasicLp basic_lp;
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_1;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(
+          Return(ByMove(std::make_unique<DelegatingBaseSolver>(&solver_1))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                       args_1.model_parameters.Proto());
+  EXPECT_CALL(solver_1, Solve(SolveArgsAre(
+                            EquivToProto(args_1.parameters.Proto()),
+                            EquivToProto(model_parameters_1), Eq(nullptr),
+                            EquivToProto(args_1.callback_registration.Proto()),
+                            Eq(nullptr), Eq(nullptr))))
+      .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  {
+    InSequence s;
+
+    // The solver will refuse the update with the unsupported feature.
+    EXPECT_CALL(solver_1, Update(EquivToProto(*update)))
+        .WillOnce(Return(false));
+
+    // The solver factory will fail for the same reason.
+    EXPECT_CALL(
+        factory_mock,
+        Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(absl::InternalError("*unsupported model*"))));
+  }
+
+  ASSERT_THAT(solver->Update(),
+              StatusIs(absl::StatusCode::kInternal,
+                       AllOf(HasSubstr("*unsupported model*"),
+                             HasSubstr("solver re-creation failed"))));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  // Next calls should fail and not crash. Note that since we failed recreating
+  // a new solver we still will use solver_1; and this solver will return an
+  // error.
+
+  EXPECT_CALL(solver_1, Update(_))
+      .WillOnce(
+          Return(ByMove(absl::InvalidArgumentError("previous call failed"))));
+
+  basic_lp.model.set_lower_bound(basic_lp.a, -3.0);
+  EXPECT_THAT(solver->Update(), StatusIs(absl::StatusCode::kInvalidArgument,
+                                         HasSubstr("update failed")));
+}
+
+// Test calling IncrementalSolver with a callback. We don't test calling
+// Update() here since only the Solve() function takes a callback.
+TEST(IncrementalSolverImplTest, SuccessfulSolveWithCallback) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve = [&](const BaseSolver::SolveArgs& args)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    args.user_cb(cb_data);
+    return basic_lp.OptimalResult({basic_lp.a});
+  };
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(
+      factory_mock,
+
+      Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(
+      solver_interface,
+      Solve(SolveArgsAre(EquivToProto(args.parameters.Proto()),
+                         EquivToProto(model_parameters), Eq(nullptr),
+                         EquivToProto(args.callback_registration.Proto()),
+                         Ne(nullptr), Eq(nullptr))))
+      .WillOnce(fake_solve);
+
+  int callback_called_count = 0;
+  args.callback = [&](const CallbackData& callback_data) {
+    ++callback_called_count;
+    CallbackResult result;
+    result.AddLazyConstraint(basic_lp.a + basic_lp.b <= 3);
+    return result;
+  };
+  ASSERT_OK_AND_ASSIGN(const SolveResult result,
+                       solver->SolveWithoutUpdate(args));
+
+  EXPECT_EQ(callback_called_count, 1);
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+// Test calling IncrementalSolver with a solver that fails to returns the
+// SolverInterface for a given model.
+TEST(IncrementalSolverImplTest, FailingSolverInstantiation) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(absl::InternalError("instantiation failed"))));
+
+  ASSERT_THAT(IncrementalSolverImpl::New(factory_mock.AsStdFunction(),
+                                         &basic_lp.model, SolverType::kGlop,
+                                         /*user_canceller=*/nullptr,
+                                         /*remove_names=*/false),
+              StatusIs(absl::StatusCode::kInternal, "instantiation failed"));
+}
+
+// Test calling IncrementalSolver with a solver that returns an error on
+// SolverInterface::Solve().
+TEST(IncrementalSolverImplTest, FailingSolver) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(
+      solver_interface,
+      Solve(SolveArgsAre(EquivToProto(args.parameters.Proto()),
+                         EquivToProto(model_parameters), Eq(nullptr),
+                         EquivToProto(args.callback_registration.Proto()),
+                         Eq(nullptr), Eq(nullptr))))
+      .WillOnce(Return(absl::InternalError("solve failed")));
+
+  ASSERT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInternal, "solve failed"));
+}
+
+// Test calling IncrementalSolver with a solver that returns an error on
+// SolverInterface::Update().
+TEST(IncrementalSolverImplTest, FailingSolverUpdate) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+      .WillOnce(Return(absl::InternalError("*update failure*")));
+
+  ASSERT_THAT(solver->Update(), StatusIs(absl::StatusCode::kInternal,
+                                         AllOf(HasSubstr("*update failure*"),
+                                               HasSubstr("update failed"))));
+}
+
+// Test calling IncrementalSolver::Solve() with a callback and a non trivial
+// update.
+TEST(IncrementalSolverImplTest, UpdateAndSolve) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve = [&](const BaseSolver::SolveArgs& args)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    args.user_cb(cb_data);
+    return basic_lp.OptimalResult({basic_lp.a});
+  };
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(
+      factory_mock,
+
+      Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  // Update the model before calling Solve().
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+        .WillOnce(Return(true));
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(
+        solver_interface,
+        Solve(SolveArgsAre(EquivToProto(args.parameters.Proto()),
+                           EquivToProto(model_parameters), Eq(nullptr),
+                           EquivToProto(args.callback_registration.Proto()),
+                           Ne(nullptr), Eq(nullptr))))
+        .WillOnce(fake_solve);
+  }
+
+  int callback_called_count = 0;
+  args.callback = [&](const CallbackData& callback_data) {
+    ++callback_called_count;
+    CallbackResult result;
+    result.AddLazyConstraint(basic_lp.a + basic_lp.b <= 3);
+    return result;
+  };
+  ASSERT_OK_AND_ASSIGN(const SolveResult result, solver->Solve(args));
+
+  EXPECT_EQ(callback_called_count, 1);
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+// Test calling IncrementalSolver::Solve() with a solver that returns an error
+// on SolverInterface::Solve().
+TEST(IncrementalSolverImplTest, UpdateAndSolveWithFailingSolver) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(
+      solver_interface,
+      Solve(SolveArgsAre(EquivToProto(args.parameters.Proto()),
+                         EquivToProto(model_parameters), Eq(nullptr),
+                         EquivToProto(args.callback_registration.Proto()),
+                         Eq(nullptr), Eq(nullptr))))
+      .WillOnce(Return(absl::InternalError("solve failed")));
+
+  ASSERT_THAT(solver->Solve(args),
+              StatusIs(absl::StatusCode::kInternal, "solve failed"));
+}
+
+// Test calling IncrementalSolver::Solve() with a solver that returns an error
+// on SolverInterface::Update().
+TEST(IncrementalSolverImplTest, UpdateAndSolveWithFailingSolverUpdate) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+      .WillOnce(Return(absl::InternalError("*update failure*")));
+
+  ASSERT_THAT(solver->Solve({}), StatusIs(absl::StatusCode::kInternal,
+                                          AllOf(HasSubstr("*update failure*"),
+                                                HasSubstr("update failed"))));
+}
+
+TEST(IncrementalSolverImplTest, NullCallback) {
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no callback was provided")));
+}
+
+TEST(IncrementalSolverImplTest, WrongModelInModelParameters) {
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({other_basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(IncrementalSolverImplTest, WrongModelInCallbackRegistration) {
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.callback_registration.mip_solution_filter =
+      MakeKeepKeysFilter({other_basic_lp.a});
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  EXPECT_CALL(
+      factory_mock,
+
+      Call(SOLVER_TYPE_GLOP, EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(IncrementalSolverImplTest, WrongModelInCallbackResult) {
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve = [&](const BaseSolver::SolveArgs& args)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    args.user_cb(cb_data);
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver_interface;
+
+  args.callback = [&](const CallbackData& callback_data) {
+    CallbackResult result;
+    // We use the wrong model here.
+    result.AddLazyConstraint(other_basic_lp.a + other_basic_lp.b <= 3);
+    return result;
+  };
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP,
+                                 EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      IncrementalSolverImpl::New(
+          factory_mock.AsStdFunction(), &basic_lp.model, SolverType::kGlop,
+          /*user_canceller=*/nullptr, /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(
+      solver_interface,
+      Solve(SolveArgsAre(EquivToProto(args.parameters.Proto()),
+                         EquivToProto(model_parameters), Eq(nullptr),
+                         EquivToProto(args.callback_registration.Proto()),
+                         Ne(nullptr), Eq(nullptr))))
+      .WillOnce(fake_solve);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(IncrementalSolverImplTest, ComputeInfeasibleSubsystem) {
+  BasicInfeasibleLp lp;
+
+  BaseSolverMock solver_interface;
+
+  // The first computation.
+  ComputeInfeasibleSubsystemArguments args_1;
+  args_1.parameters.enable_output = true;
+
+  SolveInterrupter interrupter;
+  args_1.interrupter = &interrupter;
+
+  BaseSolverFactoryMock factory_mock;
+  EXPECT_CALL(factory_mock,
+              Call(SOLVER_TYPE_GLOP, EquivToProto(lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingBaseSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(std::unique_ptr<IncrementalSolver> solver,
+                       IncrementalSolverImpl::New(factory_mock.AsStdFunction(),
+                                                  &lp.model, SolverType::kGlop,
+                                                  /*user_canceller=*/nullptr,
+                                                  /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  EXPECT_CALL(solver_interface,
+              ComputeInfeasibleSubsystem(ComputeInfeasibleSubsystemArgsAre(
+                  EquivToProto(args_1.parameters.Proto()), Eq(nullptr),
+                  Eq(&interrupter))))
+      .WillOnce(Return(lp.InfeasibleResult()));
+
+  {
+    ASSERT_OK_AND_ASSIGN(
+        const ComputeInfeasibleSubsystemResult result,
+        solver->ComputeInfeasibleSubsystemWithoutUpdate(args_1));
+    EXPECT_EQ(result.feasibility, FeasibilityStatus::kInfeasible);
+  }
+
+  // Second computation with update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  const std::optional<ModelUpdateProto> update = lp.UpdateUpperBoundOfC();
+  ASSERT_TRUE(update);
+
+  ComputeInfeasibleSubsystemArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+        .WillOnce(Return(true));
+
+    EXPECT_CALL(
+        solver_interface,
+        ComputeInfeasibleSubsystem(ComputeInfeasibleSubsystemArgsAre(
+            EquivToProto(args_2.parameters.Proto()), Eq(nullptr), Eq(nullptr))))
+        .WillOnce(Return(lp.InfeasibleResult()));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const ComputeInfeasibleSubsystemResult result,
+                       solver->ComputeInfeasibleSubsystem(args_2));
+  EXPECT_EQ(result.feasibility, FeasibilityStatus::kInfeasible);
+}
+
+TEST(IncrementalSolverImplTest, UserCancellation) {
+  BasicLp basic_lp;
+
+  // Will be set to the provided local_canceller in the factory.
+  SolveInterrupter* provided_local_canceller = nullptr;
+
+  BaseSolverFactoryMock factory_mock;
+  BaseSolverMock solver;
+
+  EXPECT_CALL(factory_mock, Call(SOLVER_TYPE_GLOP, _, Ne(nullptr)))
+      .WillOnce([&](const SolverTypeProto solver_type, const ModelProto& model,
+                    SolveInterrupter* const local_canceller) {
+        provided_local_canceller = local_canceller;
+        return std::make_unique<DelegatingBaseSolver>(&solver);
+      });
+
+  SolveInterrupter user_canceller;
+
+  ASSERT_OK_AND_ASSIGN(
+      const std::unique_ptr<IncrementalSolver> incremental_solver,
+      IncrementalSolverImpl::New(factory_mock.AsStdFunction(), &basic_lp.model,
+                                 SolverType::kGlop,
+                                 /*user_canceller=*/&user_canceller,
+                                 /*remove_names=*/false));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver);
+
+  ASSERT_NE(provided_local_canceller, nullptr);
+
+  // Since user_canceller has not been cancelled yet the local canceller should
+  // still be untriggered.
+  EXPECT_FALSE(provided_local_canceller->IsInterrupted());
+
+  // Triggering the user canceller should trigger the local canceller.
+  user_canceller.Interrupt();
+  EXPECT_TRUE(provided_local_canceller->IsInterrupted());
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt::internal
diff --git a/ortools/math_opt/cpp/solve_result_test.cc b/ortools/math_opt/cpp/solve_result_test.cc
new file mode 100644
index 0000000000..94528b4ed3
--- /dev/null
+++ b/ortools/math_opt/cpp/solve_result_test.cc
@@ -0,0 +1,932 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/solve_result.h"
+
+#include <limits>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/time/time.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/protoutil.h"
+#include "ortools/math_opt/core/math_opt_proto_utils.h"
+#include "ortools/math_opt/cpp/enums_testing.h"
+#include "ortools/math_opt/cpp/linear_constraint.h"
+#include "ortools/math_opt/cpp/matchers.h"
+#include "ortools/math_opt/cpp/objective.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/result.pb.h"
+#include "ortools/math_opt/solution.pb.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+#include "ortools/math_opt/storage/model_storage.h"
+#include "ortools/math_opt/testing/stream.h"
+#include "ortools/pdlp/solve_log.pb.h"
+#include "ortools/util/fp_roundtrip_conv_testing.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+using ::testing::AllOf;
+using ::testing::HasSubstr;
+using ::testing::status::IsOkAndHolds;
+using ::testing::status::StatusIs;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(TerminationReason, EnumTest, TerminationReason);
+INSTANTIATE_TYPED_TEST_SUITE_P(Limit, EnumTest, Limit);
+INSTANTIATE_TYPED_TEST_SUITE_P(FeasibilityStatus, EnumTest, FeasibilityStatus);
+
+TEST(ObjectiveBounds, StringTest) {
+  const ObjectiveBounds objective_bounds = {.primal_bound = 1.0,
+                                            .dual_bound = 2.0};
+  std::string expected = "{primal_bound: 1, dual_bound: 2}";
+  EXPECT_EQ(objective_bounds.ToString(), expected);
+  EXPECT_EQ(StreamToString(objective_bounds), expected);
+}
+
+TEST(ObjectiveBounds, FloatingPointRoundTripPrimalBound) {
+  const ObjectiveBounds objective_bounds = {
+      .primal_bound = kRoundTripTestNumber, .dual_bound = kInf};
+  EXPECT_THAT(
+      objective_bounds.ToString(),
+      HasSubstr(absl::StrCat("primal_bound: ", kRoundTripTestNumberStr)));
+}
+
+TEST(ObjectiveBounds, FloatingPointRoundTripDualBound) {
+  const ObjectiveBounds objective_bounds = {.primal_bound = -kInf,
+                                            .dual_bound = kRoundTripTestNumber};
+  EXPECT_THAT(objective_bounds.ToString(),
+              HasSubstr(absl::StrCat("dual_bound: ", kRoundTripTestNumberStr)));
+}
+
+TEST(ObjectiveBounds, ProtoRoundTripTest) {
+  const ObjectiveBounds objective_bounds = {.primal_bound = 10,
+                                            .dual_bound = 20};
+  const ObjectiveBounds actual =
+      ObjectiveBounds::FromProto(objective_bounds.Proto());
+  EXPECT_EQ(actual.primal_bound, 10);
+  EXPECT_EQ(actual.dual_bound, 20);
+}
+
+TEST(ObjectiveBounds, MakeTrivial) {
+  EXPECT_THAT(ObjectiveBounds::MaximizeMakeTrivial(),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = -kInf, .dual_bound = kInf}));
+  EXPECT_THAT(ObjectiveBounds::MinimizeMakeTrivial(),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = kInf, .dual_bound = -kInf}));
+}
+
+TEST(ObjectiveBounds, MakeTrivialIsMaximize) {
+  EXPECT_THAT(ObjectiveBounds::MakeTrivial(/*is_maximize=*/true),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = -kInf, .dual_bound = kInf}));
+  EXPECT_THAT(ObjectiveBounds::MakeTrivial(/*is_maximize=*/false),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = kInf, .dual_bound = -kInf}));
+}
+
+TEST(ObjectiveBounds, MakeUnbounded) {
+  EXPECT_THAT(ObjectiveBounds::MaximizeMakeUnbounded(),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = kInf, .dual_bound = kInf}));
+  EXPECT_THAT(ObjectiveBounds::MinimizeMakeUnbounded(),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = -kInf, .dual_bound = -kInf}));
+}
+
+TEST(ObjectiveBounds, MakeUnboundedIsMaximize) {
+  EXPECT_THAT(ObjectiveBounds::MakeUnbounded(/*is_maximize=*/true),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = kInf, .dual_bound = kInf}));
+  EXPECT_THAT(ObjectiveBounds::MakeUnbounded(/*is_maximize=*/false),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = -kInf, .dual_bound = -kInf}));
+}
+
+TEST(ObjectiveBounds, MakeOptimal) {
+  EXPECT_THAT(ObjectiveBounds::MakeOptimal(/*objective_value=*/10.0),
+              ObjectiveBoundsNear(
+                  ObjectiveBounds{.primal_bound = 10.0, .dual_bound = 10.0}));
+}
+
+TEST(ProblemStatusTest, ProtoToProblemStatus) {
+  ProblemStatusProto proto;
+  proto.set_primal_status(FEASIBILITY_STATUS_UNDETERMINED);
+  proto.set_dual_status(FEASIBILITY_STATUS_FEASIBLE);
+  proto.set_primal_or_dual_infeasible(true);
+
+  ASSERT_OK_AND_ASSIGN(const ProblemStatus actual_status,
+                       ProblemStatus::FromProto(proto));
+  EXPECT_EQ(actual_status.primal_status, FeasibilityStatus::kUndetermined);
+  EXPECT_EQ(actual_status.dual_status, FeasibilityStatus::kFeasible);
+  EXPECT_EQ(actual_status.primal_or_dual_infeasible, true);
+}
+
+TEST(ProblemStatusTest, ProblemStatusToProto) {
+  const ProblemStatus problem_status = {
+      .primal_status = FeasibilityStatus::kUndetermined,
+      .dual_status = FeasibilityStatus::kFeasible,
+      .primal_or_dual_infeasible = true};
+  const ProblemStatusProto proto = problem_status.Proto();
+
+  EXPECT_EQ(proto.primal_status(), FEASIBILITY_STATUS_UNDETERMINED);
+  EXPECT_EQ(proto.dual_status(), FEASIBILITY_STATUS_FEASIBLE);
+  EXPECT_EQ(proto.primal_or_dual_infeasible(), true);
+}
+
+TEST(ProblemStatusTest, FromProtoInvalidInputDualStatus) {
+  ProblemStatusProto proto;
+  proto.set_primal_status(FEASIBILITY_STATUS_UNDETERMINED);
+  EXPECT_THAT(
+      ProblemStatus::FromProto(proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("dual_status")));
+}
+
+TEST(ProblemStatusTest, FromProtoInvalidInputPrimalStatus) {
+  ProblemStatusProto proto;
+  proto.set_dual_status(FEASIBILITY_STATUS_UNDETERMINED);
+  EXPECT_THAT(
+      ProblemStatus::FromProto(proto),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("primal_status")));
+}
+
+TEST(ProblemStatusTest, StringTest) {
+  const ProblemStatus problem_status = {
+      .primal_status = FeasibilityStatus::kInfeasible,
+      .dual_status = FeasibilityStatus::kFeasible,
+      .primal_or_dual_infeasible = false};
+
+  std::string expected =
+      "{primal_status: infeasible, dual_status: feasible, "
+      "primal_or_dual_infeasible: false}";
+  EXPECT_EQ(problem_status.ToString(), expected);
+  EXPECT_EQ(StreamToString(problem_status), expected);
+}
+
+TEST(SolveStats, ProtoRoundTripTest) {
+  const SolveStats solve_stats = {.solve_time = absl::Seconds(1),
+                                  .simplex_iterations = 1,
+                                  .barrier_iterations = 2,
+                                  .first_order_iterations = 3,
+                                  .node_count = 4};
+  ASSERT_OK_AND_ASSIGN(const SolveStatsProto proto, solve_stats.Proto());
+  ASSERT_OK_AND_ASSIGN(const SolveStats actual, SolveStats::FromProto(proto));
+  EXPECT_EQ(actual.solve_time, absl::Seconds(1));
+  EXPECT_EQ(actual.simplex_iterations, 1);
+  EXPECT_EQ(actual.barrier_iterations, 2);
+  EXPECT_EQ(actual.first_order_iterations, 3);
+  EXPECT_EQ(actual.node_count, 4);
+}
+
+TEST(SolveStats, ToProtoInvalidSolveTime) {
+  const SolveStats solve_stats = {.solve_time = absl::InfiniteDuration()};
+  EXPECT_THAT(solve_stats.Proto(),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       AllOf(HasSubstr("solve_time"), HasSubstr("finite"))));
+}
+
+TEST(SolveStats, FromProtoInvalidSolveTime) {
+  SolveStatsProto stats;
+  stats.mutable_solve_time()->set_nanos(-1);
+  stats.mutable_solve_time()->set_seconds(1);
+  EXPECT_THAT(
+      SolveStats::FromProto(stats),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("solve_time")));
+}
+
+TEST(SolveStats, StringTest) {
+  const SolveStats solve_stats = {.solve_time = absl::Seconds(1),
+                                  .simplex_iterations = 1,
+                                  .barrier_iterations = 2,
+                                  .first_order_iterations = 3,
+                                  .node_count = 4};
+
+  std::string expected =
+      "{solve_time: 1s, simplex_iterations: 1, "
+      "barrier_iterations: 2, first_order_iterations: 3, node_count: 4}";
+  EXPECT_EQ(solve_stats.ToString(), expected);
+  EXPECT_EQ(StreamToString(solve_stats), expected);
+}
+
+TEST(TerminationTest, ProtoRoundTripTestForFeasible) {
+  const Termination termination = Termination::Feasible(
+      /*is_maximize=*/true, Limit::kTime, 10.0, 20.0, "hit time limit");
+  ASSERT_OK_AND_ASSIGN(const Termination actual,
+                       Termination::FromProto(termination.Proto()));
+  EXPECT_EQ(actual.reason, TerminationReason::kFeasible);
+  EXPECT_EQ(actual.limit, Limit::kTime);
+  EXPECT_EQ(actual.detail, "hit time limit");
+  EXPECT_EQ(actual.problem_status.primal_status, FeasibilityStatus::kFeasible);
+  EXPECT_EQ(actual.problem_status.dual_status, FeasibilityStatus::kFeasible);
+  EXPECT_FALSE(actual.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(actual.objective_bounds,
+              ObjectiveBoundsNear({.primal_bound = 10.0, .dual_bound = 20.0}));
+}
+
+TEST(TerminationTest, InvalidUnspecifiedTerminationReason) {
+  TerminationProto termination;
+  EXPECT_THAT(
+      Termination::FromProto(termination),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("reason")));
+}
+
+TEST(TerminationTest, OptimalTwoArgument) {
+  const Termination termination = Termination::Optimal(10.0, 20.0, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kOptimal);
+  EXPECT_EQ(termination.limit, std::nullopt);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear({.primal_bound = 10.0, .dual_bound = 20.0}));
+}
+
+TEST(TerminationTest, OptimalOneArgument) {
+  const Termination termination = Termination::Optimal(10.0, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kOptimal);
+  EXPECT_EQ(termination.limit, std::nullopt);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear({.primal_bound = 10.0, .dual_bound = 10.0}));
+}
+
+class TerminationMinMaxTest : public ::testing::TestWithParam<bool> {};
+INSTANTIATE_TEST_SUITE_P(
+    TerminationMinMaxTests, TerminationMinMaxTest, testing::Values(true, false),
+    [](const testing::TestParamInfo<TerminationMinMaxTest::ParamType>& info) {
+      return info.param ? "max" : "min";
+    });
+
+TEST_P(TerminationMinMaxTest, InfeasibleDualNotFeasible) {
+  const bool is_maximize = GetParam();
+  const ObjectiveBounds expected_bounds =
+      ObjectiveBounds::MakeTrivial(is_maximize);
+  const Termination termination = Termination::Infeasible(
+      is_maximize, FeasibilityStatus::kUndetermined, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kInfeasible);
+  EXPECT_EQ(termination.limit, std::nullopt);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kInfeasible);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, InfeasibleDualFeasible) {
+  const bool is_maximize = GetParam();
+  const double bound = is_maximize ? -kInf : kInf;
+  const ObjectiveBounds expected_bounds = {.primal_bound = bound,
+                                           .dual_bound = bound};
+  const Termination termination = Termination::Infeasible(
+      is_maximize, FeasibilityStatus::kFeasible, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kInfeasible);
+  EXPECT_EQ(termination.limit, std::nullopt);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kInfeasible);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, InfeasibleOrUnboundedDualNotInfeasible) {
+  const bool is_maximize = GetParam();
+  const ObjectiveBounds expected_bounds =
+      ObjectiveBounds::MakeTrivial(is_maximize);
+  const Termination termination = Termination::InfeasibleOrUnbounded(
+      is_maximize, FeasibilityStatus::kUndetermined, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kInfeasibleOrUnbounded);
+  EXPECT_EQ(termination.limit, std::nullopt);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_TRUE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, InfeasibleOrUnboundedDualInfeasible) {
+  const bool is_maximize = GetParam();
+  const ObjectiveBounds expected_bounds =
+      ObjectiveBounds::MakeTrivial(is_maximize);
+  const Termination termination = Termination::InfeasibleOrUnbounded(
+      is_maximize, FeasibilityStatus::kInfeasible, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kInfeasibleOrUnbounded);
+  EXPECT_EQ(termination.limit, std::nullopt);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kInfeasible);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, Unbounded) {
+  const bool is_maximize = GetParam();
+  const ObjectiveBounds expected_bounds =
+      ObjectiveBounds::MakeUnbounded(is_maximize);
+  const Termination termination = Termination::Unbounded(is_maximize, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kUnbounded);
+  EXPECT_EQ(termination.limit, std::nullopt);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kInfeasible);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, NoSolutionFoundDualFeasible) {
+  const bool is_maximize = GetParam();
+  const double dual_bound = 20.0;
+  ObjectiveBounds expected_bounds = ObjectiveBounds::MakeTrivial(is_maximize);
+  expected_bounds.dual_bound = dual_bound;
+  const Termination termination = Termination::NoSolutionFound(
+      is_maximize, Limit::kTime, dual_bound, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kNoSolutionFound);
+  EXPECT_EQ(termination.limit, Limit::kTime);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, NoSolutionFoundDualNotfeasible) {
+  const bool is_maximize = GetParam();
+  const ObjectiveBounds expected_bounds =
+      ObjectiveBounds::MakeTrivial(is_maximize);
+  const Termination termination = Termination::NoSolutionFound(
+      is_maximize, Limit::kTime, std::nullopt, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kNoSolutionFound);
+  EXPECT_EQ(termination.limit, Limit::kTime);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, FeasibleDualFeasible) {
+  const bool is_maximize = GetParam();
+  const double primal_bound = is_maximize ? 10.0 : 20.0;
+  ObjectiveBounds expected_bounds = ObjectiveBounds::MakeTrivial(is_maximize);
+  expected_bounds.primal_bound = primal_bound;
+
+  const Termination termination = Termination::Feasible(
+      is_maximize, Limit::kTime, primal_bound, std::nullopt, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kFeasible);
+  EXPECT_EQ(termination.limit, Limit::kTime);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, Cutoff) {
+  const bool is_maximize = GetParam();
+  const ObjectiveBounds expected_bounds =
+      ObjectiveBounds::MakeTrivial(is_maximize);
+  const Termination termination = Termination::Cutoff(is_maximize, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kNoSolutionFound);
+  EXPECT_EQ(termination.limit, Limit::kCutoff);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kUndetermined);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST_P(TerminationMinMaxTest, FeasibleDualNotFeasible) {
+  const bool is_maximize = GetParam();
+  const double primal_bound = is_maximize ? 10.0 : 20.0;
+  const double dual_bound = is_maximize ? 20.0 : 10.0;
+  const ObjectiveBounds expected_bounds = {.primal_bound = primal_bound,
+                                           .dual_bound = dual_bound};
+  const Termination termination = Termination::Feasible(
+      is_maximize, Limit::kTime, primal_bound, dual_bound, "detail");
+  EXPECT_EQ(termination.reason, TerminationReason::kFeasible);
+  EXPECT_EQ(termination.limit, Limit::kTime);
+  EXPECT_EQ(termination.detail, "detail");
+  EXPECT_EQ(termination.problem_status.primal_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_EQ(termination.problem_status.dual_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_FALSE(termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(termination.objective_bounds,
+              ObjectiveBoundsNear(expected_bounds));
+}
+
+TEST(TerminationTest, StringTestWithLimit) {
+  const Termination termination = Termination::Feasible(
+      /*is_maximize=*/true, Limit::kTime, 10.0, 20.0, "hit time limit");
+  std::string expected =
+      "{reason: feasible, limit: time, detail: \"hit time limit\", "
+      "problem_status: "
+      "{primal_status: feasible, dual_status: feasible, "
+      "primal_or_dual_infeasible: false}, objective_bounds: {primal_bound: "
+      "10, "
+      "dual_bound: 20}}";
+  EXPECT_EQ(termination.ToString(), expected);
+  EXPECT_EQ(StreamToString(termination), expected);
+  EXPECT_EQ(absl::StrFormat("%v", termination), expected);
+}
+
+TEST(TerminationTest, StringTestNoLimit) {
+  const Termination termination = Termination::Optimal(10.0, "good answer");
+  std::string expected =
+      "{reason: optimal, detail: \"good answer\", problem_status: "
+      "{primal_status: "
+      "feasible, dual_status: feasible, primal_or_dual_infeasible: false}, "
+      "objective_bounds: {primal_bound: 10, dual_bound: 10}}";
+  EXPECT_EQ(termination.ToString(), expected);
+  EXPECT_EQ(StreamToString(termination), expected);
+  EXPECT_EQ(absl::StrFormat("%v", termination), expected);
+}
+
+TEST(TerminationTest, StringTestNoDetail) {
+  const Termination termination = Termination::Optimal(10.0);
+  std::string expected =
+      "{reason: optimal, problem_status: {primal_status: feasible, "
+      "dual_status: feasible, primal_or_dual_infeasible: false}, "
+      "objective_bounds: {primal_bound: 10, dual_bound: 10}}";
+  EXPECT_EQ(termination.ToString(), expected);
+  EXPECT_EQ(StreamToString(termination), expected);
+  EXPECT_EQ(absl::StrFormat("%v", termination), expected);
+}
+
+TEST(TerminationTest, StringTestDetailEscaping) {
+  const Termination termination =
+      Termination::Optimal(10.0, "hit \"3\" seconds");
+  std::string expected =
+      "{reason: optimal, detail: \"hit \\\"3\\\" seconds\", problem_status: "
+      "{primal_status: feasible, "
+      "dual_status: feasible, primal_or_dual_infeasible: false}, "
+      "objective_bounds: {primal_bound: 10, dual_bound: 10}}";
+  EXPECT_EQ(termination.ToString(), expected);
+  EXPECT_EQ(StreamToString(termination), expected);
+  EXPECT_EQ(absl::StrFormat("%v", termination), expected);
+}
+
+TEST(TerminationTest, LimitReached) {
+  const Termination termination_optimal = Termination::Optimal(10.0);
+  EXPECT_FALSE(termination_optimal.limit_reached());
+  const Termination termination_feasible = Termination::Feasible(
+      /*is_maximize=*/true, Limit::kTime, 10.0);
+  EXPECT_TRUE(termination_feasible.limit_reached());
+  const Termination termination_nosolution = Termination::NoSolutionFound(
+      /*is_maximize=*/true, Limit::kTime);
+  EXPECT_TRUE(termination_nosolution.limit_reached());
+}
+
+TEST(TerminationTest, EnsureReasonIs) {
+  EXPECT_OK(Termination(/*is_maximize=*/true, TerminationReason::kImprecise)
+                .EnsureReasonIs(TerminationReason::kImprecise));
+  EXPECT_THAT(Termination(/*is_maximize=*/true, TerminationReason::kFeasible)
+                  .EnsureReasonIs(TerminationReason::kOptimal),
+              StatusIs(absl::StatusCode::kInternal,
+                       HasSubstr("expected termination reason 'optimal' but "
+                                 "got {reason: feasible")));
+}
+
+TEST(TerminationTest, EnsureReasonIsAnyOf) {
+  EXPECT_OK(Termination(/*is_maximize=*/true, TerminationReason::kImprecise)
+                .EnsureReasonIsAnyOf({TerminationReason::kImprecise,
+                                      TerminationReason::kInfeasible}));
+  EXPECT_THAT(Termination(/*is_maximize=*/true, TerminationReason::kInfeasible)
+                  .EnsureReasonIsAnyOf({TerminationReason::kOptimal,
+                                        TerminationReason::kFeasible}),
+              StatusIs(absl::StatusCode::kInternal,
+                       HasSubstr("expected termination reason in {'optimal', "
+                                 "'feasible'} but got {reason: infeasible")));
+}
+
+TEST(TerminationTest, EnsureIsOptimal) {
+  EXPECT_OK(Termination::Optimal(10.0).EnsureIsOptimal());
+  EXPECT_THAT(Termination::Feasible(
+                  /*is_maximize=*/true, Limit::kTime, 10.0)
+                  .EnsureIsOptimal(),
+              StatusIs(absl::StatusCode::kInternal,
+                       HasSubstr("expected termination reason 'optimal' but "
+                                 "got {reason: feasible")));
+}
+
+TEST(TerminationTest, IsOptimal) {
+  EXPECT_TRUE(Termination::Optimal(10.0).IsOptimal());
+  EXPECT_FALSE(Termination::Feasible(
+                   /*is_maximize=*/true, Limit::kTime, 10.0)
+                   .IsOptimal());
+}
+
+TEST(TerminationTest, EnsureIsOptimalOrFeasible) {
+  EXPECT_OK(Termination::Optimal(10.0).EnsureIsOptimalOrFeasible());
+  EXPECT_OK(Termination::Feasible(
+                /*is_maximize=*/true, Limit::kTime, 10.0)
+                .EnsureIsOptimalOrFeasible());
+  EXPECT_THAT(Termination::Infeasible(
+                  /*is_maximize=*/true, FeasibilityStatus::kInfeasible)
+                  .EnsureIsOptimalOrFeasible(),
+              StatusIs(absl::StatusCode::kInternal,
+                       HasSubstr("expected termination reason in {'optimal', "
+                                 "'feasible'} but got {reason: infeasible")));
+}
+
+TEST(TerminationTest, IsOptimalOrFeasible) {
+  EXPECT_TRUE(Termination::Optimal(10.0).IsOptimalOrFeasible());
+  EXPECT_TRUE(Termination::Feasible(
+                  /*is_maximize=*/true, Limit::kTime, 10.0)
+                  .IsOptimalOrFeasible());
+  EXPECT_FALSE(Termination::Infeasible(
+                   /*is_maximize=*/true, FeasibilityStatus::kInfeasible)
+                   .IsOptimalOrFeasible());
+}
+
+SolveResultProto MinimalSolveResultProto() {
+  SolveResultProto proto;
+  *proto.mutable_termination() = OptimalTerminationProto(10.0, 10.0);
+  return proto;
+}
+
+SolveResultMatcherOptions StrictCheck() {
+  return {.tolerance = 0,
+          .first_solution_only = false,
+          .check_dual = true,
+          .check_rays = true,
+          .check_solutions_if_inf_or_unbounded = true,
+          .check_basis = true,
+          .inf_or_unb_soft_match = false};
+}
+
+TEST(SolveResultTest, MinimalSolveResultRoundTrips) {
+  ModelStorage model;
+  SolveResult solve_result(Termination::Optimal(10.0));
+
+  // Half trip
+  EXPECT_THAT(SolveResult::FromProto(&model, MinimalSolveResultProto()),
+              IsOkAndHolds(IsConsistentWith(solve_result, StrictCheck())));
+
+  ASSERT_OK_AND_ASSIGN(const SolveResultProto proto, solve_result.Proto());
+  // Full trip
+  EXPECT_THAT(SolveResult::FromProto(&model, proto),
+              IsOkAndHolds(IsConsistentWith(solve_result, StrictCheck())));
+}
+
+TEST(SolveResultTest, ProblemStatusInStatsButNotTermination) {
+  ModelStorage model;
+  SolveResultProto proto = MinimalSolveResultProto();
+  *proto.mutable_solve_stats()->mutable_problem_status() =
+      proto.termination().problem_status();
+  proto.mutable_termination()->clear_problem_status();
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult solve_result,
+                       SolveResult::FromProto(&model, proto));
+  EXPECT_EQ(solve_result.termination.problem_status.primal_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_EQ(solve_result.termination.problem_status.dual_status,
+            FeasibilityStatus::kFeasible);
+  EXPECT_FALSE(
+      solve_result.termination.problem_status.primal_or_dual_infeasible);
+  EXPECT_THAT(SolveResult::FromProto(&model, proto),
+              IsOkAndHolds(IsConsistentWith(solve_result, StrictCheck())));
+}
+
+TEST(SolveResultTest, ObjectiveBoundsInStatsButNotTermination) {
+  ModelStorage model;
+  SolveResultProto proto = MinimalSolveResultProto();
+  proto.mutable_solve_stats()->set_best_primal_bound(10.0);
+  proto.mutable_solve_stats()->set_best_dual_bound(20.0);
+  proto.mutable_termination()->clear_objective_bounds();
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult solve_result,
+                       SolveResult::FromProto(&model, proto));
+  EXPECT_DOUBLE_EQ(solve_result.termination.objective_bounds.primal_bound,
+                   10.0);
+  EXPECT_DOUBLE_EQ(solve_result.termination.objective_bounds.dual_bound, 20.0);
+  EXPECT_THAT(SolveResult::FromProto(&model, proto),
+              IsOkAndHolds(IsConsistentWith(solve_result, StrictCheck())));
+}
+
+TEST(SolveResultTest, SolveTimeRoundTrip) {
+  ModelStorage model;
+  const absl::Duration time = absl::Seconds(10);
+  SolveResultProto result_proto = MinimalSolveResultProto();
+  ASSERT_OK(util_time::EncodeGoogleApiProto(
+      time, result_proto.mutable_solve_stats()->mutable_solve_time()));
+  ASSERT_OK_AND_ASSIGN(const auto result,
+                       SolveResult::FromProto(&model, result_proto));
+  EXPECT_EQ(result.solve_time(), time);
+}
+
+TEST(SolveResultTest, ProtoInvalidSolveStats) {
+  SolveResult solve_result(Termination::Optimal(10.0));
+  solve_result.solve_stats.solve_time = absl::InfiniteDuration();
+  EXPECT_THAT(solve_result.Proto(),
+              StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(SolveResultTest, FromProtoInvalidTermination) {
+  ModelStorage model;
+  SolveResultProto result = MinimalSolveResultProto();
+  result.clear_termination();
+  EXPECT_THAT(SolveResult::FromProto(&model, result),
+              StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(SolveResultTest, FromProtoInvalidStats) {
+  ModelStorage model;
+  SolveResultProto result = MinimalSolveResultProto();
+  result.mutable_solve_stats()->mutable_solve_time()->set_nanos(-1);
+  result.mutable_solve_stats()->mutable_solve_time()->set_seconds(1);
+  EXPECT_THAT(SolveResult::FromProto(&model, result),
+              StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(SolveResultTest, FromProtoInvalidSolution) {
+  ModelStorage model;
+  SolveResultProto result = MinimalSolveResultProto();
+  // default primal solution is invalid, no
+  result.add_solutions()
+      ->mutable_primal_solution()
+      ->mutable_variable_values()
+      ->add_values(0);
+  EXPECT_THAT(SolveResult::FromProto(&model, result),
+              StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(SolveResultTest, FromProtoInvalidPrimalRay) {
+  ModelStorage model;
+  SolveResultProto result = MinimalSolveResultProto();
+  // default primal solution is invalid, no
+  result.add_primal_rays()->mutable_variable_values()->add_values(0);
+  EXPECT_THAT(SolveResult::FromProto(&model, result),
+              StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(SolveResultTest, FromProtoInvalidDualRay) {
+  ModelStorage model;
+  SolveResultProto result = MinimalSolveResultProto();
+  // default primal solution is invalid, no
+  result.add_dual_rays()->mutable_reduced_costs()->add_values(0);
+  EXPECT_THAT(SolveResult::FromProto(&model, result),
+              StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+class SolveResultModelTest : public testing::Test {
+ protected:
+  SolveResultModelTest()
+      : x_(&storage_, storage_.AddVariable("x")),
+        c_(&storage_, storage_.AddLinearConstraint("c")) {}
+
+  ModelStorage storage_;
+  Variable x_;
+  LinearConstraint c_;
+};
+
+TEST_F(SolveResultModelTest, RoundTripSolutions) {
+  SolveResult result(Termination::Optimal(10.0));
+  Solution s1;
+  s1.primal_solution = {.variable_values = {{x_, 1.0}},
+                        .objective_value = 1.0,
+                        .feasibility_status = SolutionStatus::kFeasible};
+  result.solutions.push_back(s1);
+  Solution s2;
+  s2.primal_solution = {.variable_values = {{x_, 0.0}},
+                        .objective_value = 0.0,
+                        .feasibility_status = SolutionStatus::kFeasible};
+
+  ASSERT_OK_AND_ASSIGN(const SolveResultProto proto, result.Proto());
+  EXPECT_THAT(SolveResult::FromProto(&storage_, proto),
+              IsOkAndHolds(IsConsistentWith(result, StrictCheck())));
+}
+
+TEST_F(SolveResultModelTest, RoundTripPrimalRays) {
+  SolveResult result(Termination::Unbounded(/*is_maximize=*/true));
+  result.primal_rays.push_back({.variable_values = {{x_, 1.0}}});
+  result.primal_rays.push_back({.variable_values = {{x_, 0.0}}});
+  ASSERT_OK_AND_ASSIGN(const SolveResultProto proto, result.Proto());
+  EXPECT_THAT(SolveResult::FromProto(&storage_, proto),
+              IsOkAndHolds(IsConsistentWith(result, StrictCheck())));
+}
+
+TEST_F(SolveResultModelTest, RoundTripDualRays) {
+  SolveResult result(Termination::Infeasible(/*is_maximize=*/true,
+                                             FeasibilityStatus::kInfeasible));
+  result.dual_rays.push_back(
+      {.dual_values = {{c_, 2.0}}, .reduced_costs = {{x_, 1.0}}});
+  result.dual_rays.push_back(
+      {.dual_values = {{c_, 3.0}}, .reduced_costs = {{x_, 0.0}}});
+  ASSERT_OK_AND_ASSIGN(const SolveResultProto proto, result.Proto());
+  EXPECT_THAT(SolveResult::FromProto(&storage_, proto),
+              IsOkAndHolds(IsConsistentWith(result, StrictCheck())));
+}
+
+TEST(SolveResultTest, RoundTripGscipOutput) {
+  ModelStorage model;
+  SolveResult solve_result(Termination::Optimal(10.0));
+  solve_result.gscip_solver_specific_output.set_status_detail("gscip_detail");
+  ASSERT_OK_AND_ASSIGN(const SolveResultProto proto, solve_result.Proto());
+  ASSERT_OK_AND_ASSIGN(const SolveResult round_trip,
+                       SolveResult::FromProto(&model, proto));
+
+  // Full trip
+  EXPECT_THAT(round_trip, IsConsistentWith(solve_result, StrictCheck()));
+  // Proto matcher is not portable
+  EXPECT_EQ(round_trip.gscip_solver_specific_output.status_detail(),
+            "gscip_detail");
+}
+
+TEST(SolveResultTest, RoundTripPdlpOutput) {
+  ModelStorage model;
+  SolveResult solve_result(Termination::Optimal(10.0));
+  solve_result.pdlp_solver_specific_output.mutable_convergence_information()
+      ->set_corrected_dual_objective(2.0);
+
+  ASSERT_OK_AND_ASSIGN(const SolveResultProto proto, solve_result.Proto());
+  ASSERT_OK_AND_ASSIGN(const SolveResult round_trip,
+                       SolveResult::FromProto(&model, proto));
+
+  // Full trip
+  EXPECT_THAT(round_trip, IsConsistentWith(solve_result, StrictCheck()));
+  EXPECT_NEAR(round_trip.pdlp_solver_specific_output.convergence_information()
+                  .corrected_dual_objective(),
+              2.0, 1e-6);
+}
+
+TEST(SolveResultTest, StringTestOptimal) {
+  SolveResult solve_result(Termination::Optimal(10.0));
+
+  // One solution.
+  solve_result.solutions.emplace_back();
+  EXPECT_EQ(StreamToString(solve_result),
+            "{termination: {reason: optimal, problem_status: {primal_status: "
+            "feasible, dual_status: feasible, primal_or_dual_infeasible: "
+            "false}, objective_bounds: {primal_bound: 10, dual_bound: 10}}, "
+            "solve_stats: {solve_time: 0, "
+            "simplex_iterations: 0, "
+            "barrier_iterations: 0, first_order_iterations: 0, node_count: 0}, "
+            "solutions: [1 available], primal_rays: [], dual_rays: []}");
+
+  // Two solutions.
+  solve_result.solutions.emplace_back();
+  EXPECT_EQ(StreamToString(solve_result),
+            "{termination: {reason: optimal, problem_status: {primal_status: "
+            "feasible, dual_status: feasible, primal_or_dual_infeasible: "
+            "false}, objective_bounds: {primal_bound: 10, dual_bound: 10}}, "
+            "solve_stats: {solve_time: 0, "
+            "simplex_iterations: 0, "
+            "barrier_iterations: 0, first_order_iterations: 0, node_count: 0}, "
+            "solutions: [2 available], primal_rays: [], dual_rays: []}");
+}
+
+TEST(SolveResultTest, StringTestUnbounded) {
+  SolveResult solve_result(Termination::Unbounded(/*is_maximize=*/true));
+
+  // One ray.
+  solve_result.primal_rays.emplace_back();
+  EXPECT_EQ(StreamToString(solve_result),
+            "{termination: {reason: unbounded, problem_status: {primal_status: "
+            "feasible, dual_status: infeasible, primal_or_dual_infeasible: "
+            "false}, objective_bounds: {primal_bound: inf, dual_bound: inf}}, "
+            "solve_stats: {solve_time: 0, "
+            "simplex_iterations: 0, "
+            "barrier_iterations: 0, first_order_iterations: 0, node_count: 0}, "
+            "solutions: [], primal_rays: [1 available], dual_rays: []}");
+
+  // Two rays.
+  solve_result.primal_rays.emplace_back();
+  EXPECT_EQ(StreamToString(solve_result),
+            "{termination: {reason: unbounded, problem_status: {primal_status: "
+            "feasible, dual_status: infeasible, primal_or_dual_infeasible: "
+            "false}, objective_bounds: {primal_bound: inf, dual_bound: inf}}, "
+            "solve_stats: {solve_time: 0, "
+            "simplex_iterations: 0, "
+            "barrier_iterations: 0, first_order_iterations: 0, node_count: 0}, "
+            "solutions: [], primal_rays: [2 available], dual_rays: []}");
+}
+
+TEST(SolveResultTest, StringTestInfeasible) {
+  SolveResult solve_result(Termination::Infeasible(
+      /*is_maximize=*/true, FeasibilityStatus::kFeasible));
+
+  // One ray.
+  solve_result.dual_rays.emplace_back();
+  EXPECT_EQ(
+      StreamToString(solve_result),
+      "{termination: {reason: infeasible, problem_status: {primal_status: "
+      "infeasible, dual_status: feasible, primal_or_dual_infeasible: false}, "
+      "objective_bounds: {primal_bound: -inf, dual_bound: -inf}}, "
+      "solve_stats: "
+      "{solve_time: 0, "
+      "simplex_iterations: 0, "
+      "barrier_iterations: 0, first_order_iterations: 0, node_count: 0}, "
+      "solutions: [], primal_rays: [], dual_rays: [1 available]}");
+
+  // Two rays.
+  solve_result.dual_rays.emplace_back();
+  EXPECT_EQ(
+      StreamToString(solve_result),
+      "{termination: {reason: infeasible, problem_status: {primal_status: "
+      "infeasible, dual_status: feasible, primal_or_dual_infeasible: false}, "
+      "objective_bounds: {primal_bound: -inf, dual_bound: -inf}}, "
+      "solve_stats: "
+      "{solve_time: 0, "
+      "simplex_iterations: 0, "
+      "barrier_iterations: 0, first_order_iterations: 0, node_count: 0}, "
+      "solutions: [], primal_rays: [], dual_rays: [2 available]}");
+}
+
+TEST(SolveResultTest, BestPrimalSolution) {
+  SolveResult result(Termination::Optimal(3.0));
+  result.solutions.emplace_back().primal_solution.emplace() = {
+      .objective_value = 3.0, .feasibility_status = SolutionStatus::kFeasible};
+  result.solutions.emplace_back().primal_solution.emplace() = {
+      .objective_value = 4.0, .feasibility_status = SolutionStatus::kFeasible};
+  EXPECT_EQ(result.best_primal_solution().objective_value, 3.0);
+  ASSERT_TRUE(result.has_primal_feasible_solution());
+  EXPECT_EQ(result.objective_value(), 3.0);
+  EXPECT_EQ(result.primal_bound(), 3.0);
+  EXPECT_EQ(result.dual_bound(), 3.0);
+  EXPECT_EQ(result.best_objective_bound(), 3.0);
+}
+
+TEST(SolveResultTest, PrimalAndDualBounds) {
+  SolveResult result(Termination::Feasible(
+      /*is_maximize=*/true, Limit::kIteration, /*finite_primal_objective=*/10.0,
+      /*optional_dual_objective=*/20.0));
+  EXPECT_EQ(result.primal_bound(), 10.0);
+  EXPECT_EQ(result.dual_bound(), 20.0);
+  EXPECT_EQ(result.best_objective_bound(), 20.0);
+}
+
+TEST(SolveResultTest, ObjectiveValue) {
+  ModelStorage model;
+  const Objective p = Objective::Primary(&model);
+  const Objective o =
+      Objective::Auxiliary(&model, model.AddAuxiliaryObjective(1));
+  SolveResult result(Termination::Optimal(10.0));
+  result.solutions.emplace_back().primal_solution.emplace() = {
+      .objective_value = 3.0,
+      .auxiliary_objective_values = {{o, 4.0}},
+      .feasibility_status = SolutionStatus::kFeasible};
+  result.solutions.emplace_back().primal_solution.emplace() = {
+      .objective_value = 5.0,
+      .auxiliary_objective_values = {{o, 6.0}},
+      .feasibility_status = SolutionStatus::kFeasible};
+  EXPECT_EQ(result.objective_value(), 3.0);
+  EXPECT_EQ(result.objective_value(p), 3.0);
+  EXPECT_EQ(result.objective_value(o), 4.0);
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/solve_test.cc b/ortools/math_opt/cpp/solve_test.cc
new file mode 100644
index 0000000000..fc591aade6
--- /dev/null
+++ b/ortools/math_opt/cpp/solve_test.cc
@@ -0,0 +1,1539 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/solve.h"
+
+#include <functional>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/base/status_macros.h"
+#include "ortools/math_opt/callback.pb.h"
+#include "ortools/math_opt/core/math_opt_proto_utils.h"
+#include "ortools/math_opt/core/solver_interface.h"
+#include "ortools/math_opt/core/solver_interface_mock.h"
+#include "ortools/math_opt/core/sparse_collection_matchers.h"
+#include "ortools/math_opt/cpp/callback.h"
+#include "ortools/math_opt/cpp/compute_infeasible_subsystem_result.h"
+#include "ortools/math_opt/cpp/enums.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/infeasible_subsystem.pb.h"
+#include "ortools/math_opt/model_parameters.pb.h"
+#include "ortools/math_opt/solution.pb.h"
+#include "ortools/math_opt/sparse_containers.pb.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+using ::testing::_;
+using ::testing::ByMove;
+using ::testing::Eq;
+using ::testing::EquivToProto;
+using ::testing::HasSubstr;
+using ::testing::InSequence;
+using ::testing::Mock;
+using ::testing::Ne;
+using ::testing::Optional;
+using ::testing::Pair;
+using ::testing::Return;
+using ::testing::UnorderedElementsAre;
+using ::testing::status::StatusIs;
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+// Basic LP model:
+//
+//   a and b are continuous variable
+//
+//   minimize a - b
+//       s.t. 0 <= a
+//            0 <= b <= 3
+struct BasicLp {
+  BasicLp();
+
+  // Sets the upper bound of variable b to 2.0 and returns the corresponding
+  // update.
+  std::optional<ModelUpdateProto> UpdateUpperBoundOfB();
+
+  // Returns the expected optimal result for this model. Only put the given set
+  // of variables in the result (to test filters). When `after_update` is true,
+  // returns the optimal result after UpdateUpperBoundOfB() has been called.
+  SolveResultProto OptimalResult(const absl::flat_hash_set<Variable>& vars,
+                                 bool after_update = false) const;
+
+  Model model;
+  const Variable a;
+  const Variable b;
+};
+
+BasicLp::BasicLp()
+    : a(model.AddVariable(0.0, kInf, false, "a")),
+      b(model.AddVariable(0.0, 3.0, false, "b")) {}
+
+std::optional<ModelUpdateProto> BasicLp::UpdateUpperBoundOfB() {
+  const std::unique_ptr<UpdateTracker> tracker = model.NewUpdateTracker();
+  model.set_upper_bound(b, 2.0);
+  return tracker->ExportModelUpdate().value();
+}
+
+SolveResultProto BasicLp::OptimalResult(
+    const absl::flat_hash_set<Variable>& vars, bool after_update) const {
+  SolveResultProto result;
+  result.mutable_termination()->set_reason(TERMINATION_REASON_OPTIMAL);
+  result.mutable_solve_stats()->mutable_problem_status()->set_primal_status(
+      FEASIBILITY_STATUS_FEASIBLE);
+  result.mutable_solve_stats()->mutable_problem_status()->set_dual_status(
+      FEASIBILITY_STATUS_FEASIBLE);
+  PrimalSolutionProto* const solution =
+      result.add_solutions()->mutable_primal_solution();
+  solution->set_objective_value(0.0);
+  solution->set_feasibility_status(SOLUTION_STATUS_FEASIBLE);
+  if (vars.contains(a)) {
+    solution->mutable_variable_values()->add_ids(a.id());
+    solution->mutable_variable_values()->add_values(0.0);
+  }
+  if (vars.contains(b)) {
+    solution->mutable_variable_values()->add_ids(b.id());
+    solution->mutable_variable_values()->add_values(after_update ? 2.0 : 3.0);
+  }
+  return result;
+}
+
+// Test calling Solve() without any callback.
+TEST(SolveTest, SuccessfulSolveNoCallback) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolveInterrupter interrupter;
+  args.interrupter = &interrupter;
+
+  args.message_callback = [](absl::Span<const std::string>) {};
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Ne(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(&interrupter)))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+// Test calling Solve() with a callback.
+TEST(SolveTest, SuccessfulSolveWithCallback) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback cb,
+          const SolveInterrupter* const interrupter)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    ASSIGN_OR_RETURN(const CallbackResultProto result, cb(cb_data));
+    return basic_lp.OptimalResult({basic_lp.a});
+  };
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Eq(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Ne(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+  }
+
+  int callback_called_count = 0;
+  args.callback = [&](const CallbackData& callback_data) {
+    ++callback_called_count;
+    CallbackResult result;
+    result.AddLazyConstraint(basic_lp.a + basic_lp.b <= 3);
+    return result;
+  };
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(basic_lp.model, EnumFromProto(registration.solver_type()).value(),
+            args));
+
+  EXPECT_EQ(callback_called_count, 1);
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+TEST(SolveTest, RemoveNamesSendsNoNames) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  Model model;
+  model.AddBinaryVariable("x");
+
+  SolveArguments args;
+  SolverInitArguments init_args;
+  init_args.remove_names = true;
+
+  ModelProto expected_model;
+  expected_model.mutable_variables()->add_ids(0);
+  expected_model.mutable_variables()->add_lower_bounds(0.0);
+  expected_model.mutable_variables()->add_upper_bounds(1.0);
+  expected_model.mutable_variables()->add_integers(true);
+
+  SolveResultProto fake_result;
+  *fake_result.mutable_termination() =
+      NoSolutionFoundTerminationProto(/*is_maximize=*/false, LIMIT_TIME);
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock, Call(EquivToProto(expected_model), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    EXPECT_CALL(solver, Solve(_, _, _, _, _, _)).WillOnce(Return(fake_result));
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const SolveResult result,
+      Solve(model, EnumFromProto(registration.solver_type()).value(), args,
+            init_args));
+}
+
+// Test calling Solve() with a solver that fails to returns the SolverInterface
+// for a given model.
+TEST(SolveTest, FailingSolveInstantiation) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolverInterfaceMock solver;
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(absl::InternalError("instantiation failed"))));
+
+  ASSERT_THAT(Solve(basic_lp.model,
+                    EnumFromProto(registration.solver_type()).value(), args),
+              StatusIs(absl::StatusCode::kInternal, "instantiation failed"));
+}
+
+// Test calling Solve() with a solver that returns an error on
+// SolverInterface::Solve().
+TEST(SolveTest, FailingSolve) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Eq(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Eq(nullptr), Eq(nullptr)))
+        .WillOnce(Return(absl::InternalError("solve failed")));
+  }
+
+  ASSERT_THAT(Solve(basic_lp.model,
+                    EnumFromProto(registration.solver_type()).value(), args),
+              StatusIs(absl::StatusCode::kInternal, "solve failed"));
+}
+
+TEST(SolveTest, NullCallback) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  SolverInterfaceMock solver;
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+  EXPECT_THAT(Solve(basic_lp.model,
+                    EnumFromProto(registration.solver_type()).value(), args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no callback was provided")));
+}
+
+TEST(SolveTest, WrongModelInModelParameters) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({other_basic_lp.a});
+
+  SolverInterfaceMock solver;
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+  EXPECT_THAT(Solve(basic_lp.model,
+                    EnumFromProto(registration.solver_type()).value(), args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(SolveTest, WrongModelInCallbackRegistration) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.callback_registration.mip_solution_filter =
+      MakeKeepKeysFilter({other_basic_lp.a});
+
+  SolverInterfaceMock solver;
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+  EXPECT_THAT(Solve(basic_lp.model,
+                    EnumFromProto(registration.solver_type()).value(), args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(SolveTest, WrongModelInCallbackResult) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback cb,
+          const SolveInterrupter* const interrupter)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    ASSIGN_OR_RETURN(const CallbackResultProto result, cb(cb_data));
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock,
+
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver, Solve(EquivToProto(args.parameters.Proto()),
+                              EquivToProto(model_parameters), Eq(nullptr),
+                              EquivToProto(args.callback_registration.Proto()),
+                              Ne(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+  }
+
+  args.callback = [&](const CallbackData& callback_data) {
+    CallbackResult result;
+    // We use the wrong model here.
+    result.AddLazyConstraint(other_basic_lp.a + other_basic_lp.b <= 3);
+    return result;
+  };
+
+  EXPECT_THAT(Solve(basic_lp.model,
+                    EnumFromProto(registration.solver_type()).value(), args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(IncrementalSolverTest, NullModel) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  EXPECT_THAT(NewIncrementalSolver(
+                  nullptr, EnumFromProto(registration.solver_type()).value()),
+              StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("model")));
+}
+
+TEST(IncrementalSolverTest, SolverType) {
+  BasicLp basic_lp;
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model, SolverType::kGlop));
+  EXPECT_EQ(solver->solver_type(), SolverType::kGlop);
+}
+
+// Test calling IncrementalSolver without any callback with a succeeding
+// non-empty update.
+TEST(IncrementalSolverTest, IncrementalSolveNoCallback) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolverInterfaceMock solver_interface;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolveInterrupter interrupter;
+  args_1.interrupter = &interrupter;
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                         args_1.model_parameters.Proto());
+    EXPECT_CALL(solver_interface,
+                Solve(EquivToProto(args_1.parameters.Proto()),
+                      EquivToProto(model_parameters_1), Eq(nullptr),
+                      EquivToProto(args_1.callback_registration.Proto()),
+                      Eq(nullptr), Eq(&interrupter)))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Second solve with update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+      .WillOnce(Return(true));
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_TRUE(update_result.did_update);
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_2,
+                         args_2.model_parameters.Proto());
+    EXPECT_CALL(solver_interface,
+                Solve(EquivToProto(args_2.parameters.Proto()),
+                      EquivToProto(model_parameters_2), Eq(nullptr),
+                      EquivToProto(args_2.callback_registration.Proto()),
+                      Eq(nullptr), Eq(nullptr)))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a, basic_lp.b},
+                                                /*after_update=*/true)));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_2,
+                       solver->SolveWithoutUpdate(args_2));
+
+  EXPECT_EQ(result_2.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(
+      result_2.variable_values(),
+      UnorderedElementsAre(Pair(basic_lp.a, 0.0), Pair(basic_lp.b, 2.0)));
+}
+
+TEST(IncrementalSolverTest, RemoveNamesSendsNoNamesOnModel) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  Model model;
+  model.AddBinaryVariable("x");
+
+  SolverInitArguments init_args;
+  init_args.remove_names = true;
+
+  ModelProto expected_model;
+  expected_model.mutable_variables()->add_ids(0);
+  expected_model.mutable_variables()->add_lower_bounds(0.0);
+  expected_model.mutable_variables()->add_upper_bounds(1.0);
+  expected_model.mutable_variables()->add_integers(true);
+
+  SolverInterfaceMock solver_interface;
+  EXPECT_CALL(factory_mock, Call(EquivToProto(expected_model), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  EXPECT_OK(NewIncrementalSolver(
+      &model, EnumFromProto(registration.solver_type()).value(), init_args));
+}
+
+TEST(IncrementalSolverTest, RemoveNamesSendsNoNamesOnModelUpdate) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  Model model;
+
+  SolveArguments args;
+  SolverInitArguments init_args;
+  init_args.remove_names = true;
+
+  SolverInterfaceMock solver_interface;
+  EXPECT_CALL(factory_mock, Call(_, _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&model,
+                           EnumFromProto(registration.solver_type()).value(),
+                           init_args));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  model.AddBinaryVariable("x");
+
+  ModelUpdateProto expected_update;
+  expected_update.mutable_new_variables()->add_ids(0);
+  expected_update.mutable_new_variables()->add_lower_bounds(0.0);
+  expected_update.mutable_new_variables()->add_upper_bounds(1.0);
+  expected_update.mutable_new_variables()->add_integers(true);
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(expected_update)))
+      .WillOnce(Return(true));
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_TRUE(update_result.did_update);
+}
+
+TEST(IncrementalSolverTest, RemoveNamesOnFullModelAfterUpdateFails) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  Model model;
+
+  SolveArguments args;
+  SolverInitArguments init_args;
+  init_args.remove_names = true;
+
+  SolverInterfaceMock solver_interface;
+  EXPECT_CALL(factory_mock, Call(_, _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&model,
+                           EnumFromProto(registration.solver_type()).value(),
+                           init_args));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  model.AddBinaryVariable("x");
+
+  ModelProto expected_model;
+  expected_model.mutable_variables()->add_ids(0);
+  expected_model.mutable_variables()->add_lower_bounds(0.0);
+  expected_model.mutable_variables()->add_upper_bounds(1.0);
+  expected_model.mutable_variables()->add_integers(true);
+
+  EXPECT_CALL(solver_interface, Update(_)).WillOnce(Return(false));
+  SolverInterfaceMock solver_interface2;
+  EXPECT_CALL(factory_mock, Call(EquivToProto(expected_model), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface2))));
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_FALSE(update_result.did_update);
+}
+
+// Test calling IncrementalSolver without any callback with an empty update.
+TEST(IncrementalSolverTest, IncrementalSolveWithEmptyUpdate) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolverInterfaceMock solver_interface;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                         args_1.model_parameters.Proto());
+    EXPECT_CALL(solver_interface,
+                Solve(EquivToProto(args_1.parameters.Proto()),
+                      EquivToProto(model_parameters_1), Eq(nullptr),
+                      EquivToProto(args_1.callback_registration.Proto()),
+                      Eq(nullptr), Eq(nullptr)))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Second solve with update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_2,
+                         args_2.model_parameters.Proto());
+    EXPECT_CALL(solver_interface,
+                Solve(EquivToProto(args_2.parameters.Proto()),
+                      EquivToProto(model_parameters_2), Eq(nullptr),
+                      EquivToProto(args_2.callback_registration.Proto()),
+                      Eq(nullptr), Eq(nullptr)))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a, basic_lp.b})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_TRUE(update_result.did_update);
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_2,
+                       solver->SolveWithoutUpdate(args_2));
+
+  EXPECT_EQ(result_2.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(
+      result_2.variable_values(),
+      UnorderedElementsAre(Pair(basic_lp.a, 0.0), Pair(basic_lp.b, 3.0)));
+}
+
+// Test calling IncrementalSolver without any callback and with a failing
+// update; thus resulting in the re-creation of the solver instead.
+//
+// This also tests that at any given time only one instance of Solver
+// exists. This is important for Gubori as only one instance can exist at any
+// given time when using a single-use license.
+TEST(IncrementalSolverTest, IncrementalSolveWithFailedUpdate) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolverInterfaceMock solver_1;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  // The current number of instances of solver.
+  int num_instances = 0;
+  const auto constructor_cb = [&]() {
+    ++num_instances;
+    // We only want one instance at most at any given time.
+    EXPECT_LE(num_instances, 1);
+  };
+  const auto destructor_cb = [&]() {
+    ASSERT_GE(num_instances, 1);
+    --num_instances;
+  };
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce([&](const ModelProto&, const SolverInterface::InitArgs&) {
+        constructor_cb();
+        return std::make_unique<DelegatingSolver>(&solver_1, destructor_cb);
+      });
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                         args_1.model_parameters.Proto());
+    EXPECT_CALL(solver_1,
+                Solve(EquivToProto(args_1.parameters.Proto()),
+                      EquivToProto(model_parameters_1), Eq(nullptr),
+                      EquivToProto(args_1.callback_registration.Proto()),
+                      Eq(nullptr), Eq(nullptr)))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Second solve with update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  SolverInterfaceMock solver_2;
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(solver_1, Update(EquivToProto(*update)))
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce([&](const ModelProto&, const SolverInterface::InitArgs&) {
+          constructor_cb();
+          return std::make_unique<DelegatingSolver>(&solver_2, destructor_cb);
+        });
+  }
+
+  ASSERT_OK_AND_ASSIGN(const UpdateResult update_result, solver->Update());
+  EXPECT_FALSE(update_result.did_update);
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+  Mock::VerifyAndClearExpectations(&solver_2);
+
+  {
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_2,
+                         args_2.model_parameters.Proto());
+    EXPECT_CALL(solver_2,
+                Solve(EquivToProto(args_2.parameters.Proto()),
+                      EquivToProto(model_parameters_2), Eq(nullptr),
+                      EquivToProto(args_2.callback_registration.Proto()),
+                      Eq(nullptr), Eq(nullptr)))
+        .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a, basic_lp.b},
+                                                /*after_update=*/true)));
+  }
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_2,
+                       solver->SolveWithoutUpdate(args_2));
+
+  EXPECT_EQ(result_2.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(
+      result_2.variable_values(),
+      UnorderedElementsAre(Pair(basic_lp.a, 0.0), Pair(basic_lp.b, 2.0)));
+}
+
+// Test calling IncrementalSolver without any callback and with an impossible
+// update, i.e. an update that contains an unsupported feature.
+TEST(IncrementalSolverTest, IncrementalSolveWithImpossibleUpdate) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolverInterfaceMock solver_1;
+
+  // The first solve.
+  SolveArguments args_1;
+  args_1.parameters.enable_output = true;
+  args_1.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver_1))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters_1,
+                       args_1.model_parameters.Proto());
+  EXPECT_CALL(solver_1,
+              Solve(EquivToProto(args_1.parameters.Proto()),
+                    EquivToProto(model_parameters_1), Eq(nullptr),
+                    EquivToProto(args_1.callback_registration.Proto()),
+                    Eq(nullptr), Eq(nullptr)))
+      .WillOnce(Return(basic_lp.OptimalResult({basic_lp.a})));
+
+  ASSERT_OK_AND_ASSIGN(const SolveResult result_1,
+                       solver->SolveWithoutUpdate(args_1));
+
+  EXPECT_EQ(result_1.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result_1.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+
+  // Update.
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_1);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  SolveArguments args_2;
+  args_2.parameters.enable_output = true;
+
+  {
+    InSequence s;
+
+    // The solver will refuse the update with the unsupported feature.
+    EXPECT_CALL(solver_1, Update(EquivToProto(*update)))
+        .WillOnce(Return(false));
+
+    // The solver factory will fail for the same reason.
+    EXPECT_CALL(factory_mock,
+                Call(EquivToProto(basic_lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(absl::InternalError("*unsupported model*"))));
+  }
+
+  ASSERT_THAT(solver->Update(),
+              StatusIs(absl::StatusCode::kInternal,
+                       AllOf(HasSubstr("*unsupported model*"),
+                             HasSubstr("solver re-creation failed"))));
+
+  // Next calls should fail and not crash.
+  basic_lp.model.set_lower_bound(basic_lp.a, -3.0);
+  EXPECT_THAT(solver->Update(), StatusIs(absl::StatusCode::kInvalidArgument,
+                                         HasSubstr("Update() failed")));
+  EXPECT_THAT(solver->SolveWithoutUpdate(),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("Update() failed")));
+}
+
+// Test calling IncrementalSolver with a callback. We don't test calling
+// Update() here since only the Solve() function takes a callback.
+TEST(IncrementalSolverTest, SuccessfulSolveWithCallback) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback cb,
+          const SolveInterrupter* const interrupter)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    ASSIGN_OR_RETURN(const CallbackResultProto result, cb(cb_data));
+    return basic_lp.OptimalResult({basic_lp.a});
+  };
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock,
+
+              Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(solver_interface,
+              Solve(EquivToProto(args.parameters.Proto()),
+                    EquivToProto(model_parameters), Eq(nullptr),
+                    EquivToProto(args.callback_registration.Proto()),
+                    Ne(nullptr), Eq(nullptr)))
+      .WillOnce(fake_solve);
+
+  int callback_called_count = 0;
+  args.callback = [&](const CallbackData& callback_data) {
+    ++callback_called_count;
+    CallbackResult result;
+    result.AddLazyConstraint(basic_lp.a + basic_lp.b <= 3);
+    return result;
+  };
+  ASSERT_OK_AND_ASSIGN(const SolveResult result,
+                       solver->SolveWithoutUpdate(args));
+
+  EXPECT_EQ(callback_called_count, 1);
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+// Test calling IncrementalSolver with a solver that fails to returns the
+// SolverInterface for a given model.
+TEST(IncrementalSolverTest, FailingSolverInstantiation) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolverInterfaceMock solver_interface;
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(ByMove(absl::InternalError("instantiation failed"))));
+
+  ASSERT_THAT(
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()),
+      StatusIs(absl::StatusCode::kInternal, "instantiation failed"));
+}
+
+// Test calling IncrementalSolver with a solver that returns an error on
+// SolverInterface::Solve().
+TEST(IncrementalSolverTest, FailingSolver) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(solver_interface,
+              Solve(EquivToProto(args.parameters.Proto()),
+                    EquivToProto(model_parameters), Eq(nullptr),
+                    EquivToProto(args.callback_registration.Proto()),
+                    Eq(nullptr), Eq(nullptr)))
+      .WillOnce(Return(absl::InternalError("solve failed")));
+
+  ASSERT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInternal, "solve failed"));
+}
+
+// Test calling IncrementalSolver with a solver that returns an error on
+// SolverInterface::Update().
+TEST(IncrementalSolverTest, FailingSolverUpdate) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+      .WillOnce(Return(absl::InternalError("*update failure*")));
+
+  ASSERT_THAT(solver->Update(), StatusIs(absl::StatusCode::kInternal,
+                                         AllOf(HasSubstr("*update failure*"),
+                                               HasSubstr("update failed"))));
+}
+
+// Test calling IncrementalSolver::Solve() with a callback and a non trivial
+// update.
+TEST(IncrementalSolverTest, UpdateAndSolve) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback cb,
+          const SolveInterrupter* const interrupter)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    ASSIGN_OR_RETURN(const CallbackResultProto result, cb(cb_data));
+    return basic_lp.OptimalResult({basic_lp.a});
+  };
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock,
+
+              Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  // Update the model before calling Solve().
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+        .WillOnce(Return(true));
+    ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                         args.model_parameters.Proto());
+    EXPECT_CALL(solver_interface,
+                Solve(EquivToProto(args.parameters.Proto()),
+                      EquivToProto(model_parameters), Eq(nullptr),
+                      EquivToProto(args.callback_registration.Proto()),
+                      Ne(nullptr), Eq(nullptr)))
+        .WillOnce(fake_solve);
+  }
+
+  int callback_called_count = 0;
+  args.callback = [&](const CallbackData& callback_data) {
+    ++callback_called_count;
+    CallbackResult result;
+    result.AddLazyConstraint(basic_lp.a + basic_lp.b <= 3);
+    return result;
+  };
+  ASSERT_OK_AND_ASSIGN(const SolveResult result, solver->Solve(args));
+
+  EXPECT_EQ(callback_called_count, 1);
+  EXPECT_EQ(result.termination.reason, TerminationReason::kOptimal);
+  EXPECT_THAT(result.variable_values(),
+              UnorderedElementsAre(Pair(basic_lp.a, 0.0)));
+}
+
+// Test calling IncrementalSolver::Solve() with a solver that returns an error
+// on SolverInterface::Solve().
+TEST(IncrementalSolverTest, UpdateAndSolveWithFailingSolver) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(solver_interface,
+              Solve(EquivToProto(args.parameters.Proto()),
+                    EquivToProto(model_parameters), Eq(nullptr),
+                    EquivToProto(args.callback_registration.Proto()),
+                    Eq(nullptr), Eq(nullptr)))
+      .WillOnce(Return(absl::InternalError("solve failed")));
+
+  ASSERT_THAT(solver->Solve(args),
+              StatusIs(absl::StatusCode::kInternal, "solve failed"));
+}
+
+// Test calling IncrementalSolver::Solve() with a solver that returns an error
+// on SolverInterface::Update().
+TEST(IncrementalSolverTest, UpdateAndSolveWithFailingSolverUpdate) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  const std::optional<ModelUpdateProto> update = basic_lp.UpdateUpperBoundOfB();
+  ASSERT_TRUE(update);
+
+  EXPECT_CALL(solver_interface, Update(EquivToProto(*update)))
+      .WillOnce(Return(absl::InternalError("*update failure*")));
+
+  ASSERT_THAT(solver->Solve(), StatusIs(absl::StatusCode::kInternal,
+                                        AllOf(HasSubstr("*update failure*"),
+                                              HasSubstr("update failed"))));
+}
+
+TEST(IncrementalSolverTest, NullCallback) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({basic_lp.a});
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("no callback was provided")));
+}
+
+TEST(IncrementalSolverTest, WrongModelInModelParameters) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.model_parameters =
+      ModelSolveParameters::OnlySomePrimalVariables({other_basic_lp.a});
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(IncrementalSolverTest, WrongModelInCallbackRegistration) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  // Here we use the wrong variable.
+  args.callback_registration.mip_solution_filter =
+      MakeKeepKeysFilter({other_basic_lp.a});
+
+  SolverInterfaceMock solver_interface;
+
+  EXPECT_CALL(factory_mock,
+
+              Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+TEST(IncrementalSolverTest, WrongModelInCallbackResult) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicLp basic_lp;
+  BasicLp other_basic_lp;
+
+  SolveArguments args;
+  args.parameters.enable_output = true;
+
+  args.callback_registration.add_lazy_constraints = true;
+  args.callback_registration.events.insert(CallbackEvent::kMipSolution);
+
+  const auto fake_solve =
+      [&](const SolveParametersProto&, const ModelSolveParametersProto&,
+          const MessageCallback message_cb, const CallbackRegistrationProto&,
+          SolverInterface::Callback cb,
+          const SolveInterrupter* const interrupter)
+      -> absl::StatusOr<SolveResultProto> {
+    CallbackDataProto cb_data;
+    cb_data.set_event(CALLBACK_EVENT_MIP_SOLUTION);
+    *cb_data.mutable_primal_solution_vector() = MakeSparseDoubleVector(
+        {{basic_lp.a.id(), 1.0}, {basic_lp.b.id(), 0.0}});
+    ASSIGN_OR_RETURN(const CallbackResultProto result, cb(cb_data));
+    return basic_lp.OptimalResult({basic_lp.a, basic_lp.b});
+  };
+
+  SolverInterfaceMock solver_interface;
+
+  args.callback = [&](const CallbackData& callback_data) {
+    CallbackResult result;
+    // We use the wrong model here.
+    result.AddLazyConstraint(other_basic_lp.a + other_basic_lp.b <= 3);
+    return result;
+  };
+
+  EXPECT_CALL(factory_mock, Call(EquivToProto(basic_lp.model.ExportModel()), _))
+      .WillOnce(Return(
+          ByMove(std::make_unique<DelegatingSolver>(&solver_interface))));
+
+  ASSERT_OK_AND_ASSIGN(
+      std::unique_ptr<IncrementalSolver> solver,
+      NewIncrementalSolver(&basic_lp.model,
+                           EnumFromProto(registration.solver_type()).value()));
+
+  Mock::VerifyAndClearExpectations(&factory_mock);
+  Mock::VerifyAndClearExpectations(&solver_interface);
+
+  ASSERT_OK_AND_ASSIGN(const ModelSolveParametersProto model_parameters,
+                       args.model_parameters.Proto());
+  EXPECT_CALL(solver_interface,
+              Solve(EquivToProto(args.parameters.Proto()),
+                    EquivToProto(model_parameters), Eq(nullptr),
+                    EquivToProto(args.callback_registration.Proto()),
+                    Ne(nullptr), Eq(nullptr)))
+      .WillOnce(fake_solve);
+
+  EXPECT_THAT(solver->SolveWithoutUpdate(args),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr(internal::kInputFromInvalidModelStorage)));
+}
+
+// Basic infeasible LP model:
+//
+//   minimize 0
+//       s.t. x <= -1 (linear constraint)
+//            0 <= x <= 1 (bounds)
+struct BasicInfeasibleLp {
+  BasicInfeasibleLp()
+      : x(model.AddContinuousVariable(0.0, 1.0, "x")),
+        c(model.AddLinearConstraint(x <= -1.0, "c")) {}
+
+  ComputeInfeasibleSubsystemResultProto InfeasibleResult() const {
+    ComputeInfeasibleSubsystemResultProto result;
+    result.set_feasibility(FEASIBILITY_STATUS_INFEASIBLE);
+    (*result.mutable_infeasible_subsystem()->mutable_variable_bounds())[0]
+        .set_lower(true);
+    (*result.mutable_infeasible_subsystem()->mutable_variable_bounds())[0]
+        .set_upper(false);
+    (*result.mutable_infeasible_subsystem()->mutable_linear_constraints())[0]
+        .set_lower(false);
+    (*result.mutable_infeasible_subsystem()->mutable_linear_constraints())[0]
+        .set_upper(true);
+    result.set_is_minimal(true);
+    return result;
+  }
+
+  Model model;
+  const Variable x;
+  const LinearConstraint c;
+};
+
+TEST(ComputeInfeasibleSubsystemTest, SuccessfulCall) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicInfeasibleLp lp;
+
+  ComputeInfeasibleSubsystemArguments args;
+  args.parameters.enable_output = true;
+
+  SolveInterrupter interrupter;
+  args.interrupter = &interrupter;
+
+  args.message_callback = [](absl::Span<const std::string>) {};
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock, Call(EquivToProto(lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    EXPECT_CALL(solver, ComputeInfeasibleSubsystem(
+                            EquivToProto(args.parameters.Proto()), Ne(nullptr),
+                            Eq(&interrupter)))
+        .WillOnce(Return(lp.InfeasibleResult()));
+  }
+
+  ASSERT_OK_AND_ASSIGN(
+      const ComputeInfeasibleSubsystemResult result,
+      ComputeInfeasibleSubsystem(
+          lp.model, EnumFromProto(registration.solver_type()).value(), args));
+
+  EXPECT_EQ(result.feasibility, FeasibilityStatus::kInfeasible);
+}
+
+TEST(ComputeInfeasibleSubsystemTest, FailingSolve) {
+  SolverInterfaceFactoryMock factory_mock;
+  SolverFactoryRegistration registration(factory_mock.AsStdFunction());
+
+  BasicInfeasibleLp lp;
+
+  ComputeInfeasibleSubsystemArguments args;
+  args.parameters.enable_output = true;
+
+  SolverInterfaceMock solver;
+  {
+    InSequence s;
+
+    EXPECT_CALL(factory_mock, Call(EquivToProto(lp.model.ExportModel()), _))
+        .WillOnce(Return(ByMove(std::make_unique<DelegatingSolver>(&solver))));
+
+    EXPECT_CALL(solver, ComputeInfeasibleSubsystem(
+                            EquivToProto(args.parameters.Proto()), Eq(nullptr),
+                            Eq(nullptr)))
+        .WillOnce(Return(absl::InternalError("infeasible subsystem failed")));
+  }
+
+  ASSERT_THAT(
+      ComputeInfeasibleSubsystem(
+          lp.model, EnumFromProto(registration.solver_type()).value(), args,
+          {}),
+      StatusIs(absl::StatusCode::kInternal, "infeasible subsystem failed"));
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/solver_resources_test.cc b/ortools/math_opt/cpp/solver_resources_test.cc
new file mode 100644
index 0000000000..08615404f4
--- /dev/null
+++ b/ortools/math_opt/cpp/solver_resources_test.cc
@@ -0,0 +1,103 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/solver_resources.h"
+
+#include <optional>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+using ::testing::EqualsProto;
+using ::testing::HasSubstr;
+using ::testing::Optional;
+
+TEST(SolverResourcesTest, Proto) {
+  {
+    const SolverResources empty;
+    EXPECT_THAT(empty.Proto(), EqualsProto(SolverResourcesProto{}));
+  }
+  {
+    const SolverResources resources = {.cpu = 3.5};
+    SolverResourcesProto expected;
+    expected.set_cpu(3.5);
+    EXPECT_THAT(resources.Proto(), EqualsProto(expected));
+  }
+  {
+    const SolverResources resources = {.ram = 70.0 * 1024.0 * 1024.0};
+    SolverResourcesProto expected;
+    expected.set_ram(70.0 * 1024.0 * 1024.0);
+    EXPECT_THAT(resources.Proto(), EqualsProto(expected));
+  }
+}
+
+TEST(SolverResourcesTest, FromProto) {
+  {
+    ASSERT_OK_AND_ASSIGN(const SolverResources resources,
+                         SolverResources::FromProto({}));
+    EXPECT_EQ(resources.cpu, std::nullopt);
+  }
+  {
+    SolverResourcesProto resources_proto;
+    resources_proto.set_cpu(3.5);
+    ASSERT_OK_AND_ASSIGN(const SolverResources resources,
+                         SolverResources::FromProto(resources_proto));
+    EXPECT_THAT(resources.cpu, Optional(3.5));
+  }
+  {
+    SolverResourcesProto resources_proto;
+    resources_proto.set_ram(70.0 * 1024.0 * 1024.0);
+    ASSERT_OK_AND_ASSIGN(const SolverResources resources,
+                         SolverResources::FromProto(resources_proto));
+    EXPECT_THAT(resources.ram, Optional(70.0 * 1024.0 * 1024.0));
+  }
+}
+
+TEST(SolverResourcesTest, AbslParseFlag) {
+  // Empty value.
+  {
+    SolverResources resources;
+    std::string error;
+    EXPECT_TRUE(AbslParseFlag("", &resources, &error));
+    EXPECT_EQ(resources.cpu, std::nullopt);
+    EXPECT_EQ(error, "");
+  }
+  // Test valid SolverResources::cpu.
+  {
+    SolverResources resources;
+    std::string error;
+    EXPECT_TRUE(AbslParseFlag("cpu:3.5", &resources, &error));
+    EXPECT_THAT(resources.cpu, Optional(3.5));
+    EXPECT_EQ(error, "");
+  }
+  // Test invalid SolverResources::cpu.
+  {
+    SolverResources resources;
+    std::string error;
+    EXPECT_FALSE(AbslParseFlag("cpu:a", &resources, &error));
+    EXPECT_EQ(resources.cpu, std::nullopt);
+    EXPECT_THAT(error, HasSubstr("double"));
+  }
+}
+
+TEST(SolverResourcesTest, AbslUnparseFlag) {
+  EXPECT_EQ(AbslUnparseFlag({}), "");
+  EXPECT_EQ(AbslUnparseFlag({.cpu = 3.5}), "cpu: 3.5");
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/statistics_test.cc b/ortools/math_opt/cpp/statistics_test.cc
new file mode 100644
index 0000000000..3cffb64a01
--- /dev/null
+++ b/ortools/math_opt/cpp/statistics_test.cc
@@ -0,0 +1,162 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/statistics.h"
+
+#include <limits>
+#include <optional>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/model.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+using ::testing::Optional;
+using ::testing::Pair;
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+
+std::string PrintToString(const ModelRanges& ranges) {
+  std::ostringstream oss;
+  oss << ranges;
+  return oss.str();
+}
+
+TEST(ModelRangesTest, Printing) {
+  EXPECT_EQ(PrintToString(ModelRanges{}),
+            "Objective terms           : no finite values\n"
+            "Variable bounds           : no finite values\n"
+            "Linear constraints bounds : no finite values\n"
+            "Linear constraints coeffs : no finite values");
+
+  EXPECT_EQ(
+      PrintToString(ModelRanges{
+          .objective_terms = std::make_pair(2.12345e-99, 1.12345e3),
+          .variable_bounds = std::make_pair(9.12345e-2, 1.12345e2),
+          .linear_constraint_bounds = std::make_pair(2.12345e6, 5.12345e99),
+          .linear_constraint_coefficients = std::make_pair(0.0, 0.0),
+      }),
+      "Objective terms           : [2.12e-99 , 1.12e+03 ]\n"
+      "Variable bounds           : [9.12e-02 , 1.12e+02 ]\n"
+      "Linear constraints bounds : [2.12e+06 , 5.12e+99 ]\n"
+      "Linear constraints coeffs : [0.00e+00 , 0.00e+00 ]");
+
+  EXPECT_EQ(
+      PrintToString(ModelRanges{
+          .objective_terms = std::make_pair(2.12345e-1, 1.12345e3),
+          .variable_bounds = std::make_pair(9.12345e-2, 1.12345e2),
+          .linear_constraint_bounds = std::make_pair(2.12345e6, 5.12345e99),
+          .linear_constraint_coefficients = std::make_pair(0.0, 1.0e100),
+      }),
+      "Objective terms           : [2.12e-01 , 1.12e+03 ]\n"
+      "Variable bounds           : [9.12e-02 , 1.12e+02 ]\n"
+      "Linear constraints bounds : [2.12e+06 , 5.12e+99 ]\n"
+      "Linear constraints coeffs : [0.00e+00 , 1.00e+100]");
+
+  EXPECT_EQ(
+      PrintToString(ModelRanges{
+          .objective_terms = std::make_pair(2.12345e-100, 1.12345e3),
+          .variable_bounds = std::make_pair(9.12345e-2, 1.12345e2),
+          .linear_constraint_bounds = std::make_pair(2.12345e6, 5.12345e99),
+          .linear_constraint_coefficients = std::make_pair(0.0, 0.0),
+      }),
+      "Objective terms           : [2.12e-100, 1.12e+03 ]\n"
+      "Variable bounds           : [9.12e-02 , 1.12e+02 ]\n"
+      "Linear constraints bounds : [2.12e+06 , 5.12e+99 ]\n"
+      "Linear constraints coeffs : [0.00e+00 , 0.00e+00 ]");
+
+  EXPECT_EQ(
+      PrintToString(ModelRanges{
+          .objective_terms = std::make_pair(2.12345e-100, 1.12345e3),
+          .variable_bounds = std::make_pair(9.12345e-2, 1.12345e2),
+          .linear_constraint_bounds = std::make_pair(2.12345e6, 5.12345e99),
+          .linear_constraint_coefficients = std::make_pair(0.0, 1.0e100),
+      }),
+      "Objective terms           : [2.12e-100, 1.12e+03 ]\n"
+      "Variable bounds           : [9.12e-02 , 1.12e+02 ]\n"
+      "Linear constraints bounds : [2.12e+06 , 5.12e+99 ]\n"
+      "Linear constraints coeffs : [0.00e+00 , 1.00e+100]");
+}
+
+TEST(ModelRangesTest, PrintingResetFlags) {
+  const ModelRanges ranges = {
+      .objective_terms = std::make_pair(2.12345e-100, 1.12345e3),
+      .variable_bounds = std::make_pair(9.12345e-2, 1.12345e2),
+      .linear_constraint_bounds = std::make_pair(2.12345e6, 5.12345e99),
+      .linear_constraint_coefficients = std::make_pair(0.0, 1.0e100),
+  };
+
+  std::ostringstream oss;
+  oss << ranges << '\n' << 1.23456789;
+
+  EXPECT_EQ(oss.str(),
+            "Objective terms           : [2.12e-100, 1.12e+03 ]\n"
+            "Variable bounds           : [9.12e-02 , 1.12e+02 ]\n"
+            "Linear constraints bounds : [2.12e+06 , 5.12e+99 ]\n"
+            "Linear constraints coeffs : [0.00e+00 , 1.00e+100]\n"
+            "1.23457");
+}
+
+TEST(ComputeModelRangesTest, Empty) {
+  const ModelRanges ranges = ComputeModelRanges(Model("model"));
+  EXPECT_EQ(ranges.objective_terms, std::nullopt);
+  EXPECT_EQ(ranges.variable_bounds, std::nullopt);
+  EXPECT_EQ(ranges.linear_constraint_bounds, std::nullopt);
+  EXPECT_EQ(ranges.linear_constraint_coefficients, std::nullopt);
+}
+
+TEST(ComputeModelRangesTest, OnlyZeroAndInfiniteValues) {
+  Model model("model");
+  model.AddContinuousVariable(/*lower_bound=*/0.0, /*upper_bound=*/kInf);
+  model.AddContinuousVariable(/*lower_bound=*/-kInf, /*upper_bound=*/0.0);
+  model.AddContinuousVariable(/*lower_bound=*/-kInf, /*upper_bound=*/kInf);
+  model.AddLinearConstraint(/*lower_bound=*/0.0, /*upper_bound=*/kInf);
+  model.AddLinearConstraint(/*lower_bound=*/-kInf, /*upper_bound=*/0.0);
+  model.AddLinearConstraint(/*lower_bound=*/-kInf, /*upper_bound=*/kInf);
+
+  const ModelRanges ranges = ComputeModelRanges(model);
+  EXPECT_EQ(ranges.objective_terms, std::nullopt);
+  EXPECT_EQ(ranges.variable_bounds, std::nullopt);
+  EXPECT_EQ(ranges.linear_constraint_bounds, std::nullopt);
+  EXPECT_EQ(ranges.linear_constraint_coefficients, std::nullopt);
+}
+
+TEST(ComputeModelRangesTest, MixedValues) {
+  Model model("model");
+  const Variable x = model.AddContinuousVariable(/*lower_bound=*/0.0,
+                                                 /*upper_bound=*/0.0, "x");
+  const Variable y = model.AddContinuousVariable(/*lower_bound=*/-kInf,
+                                                 /*upper_bound=*/1e-3, "y");
+  const Variable z = model.AddContinuousVariable(/*lower_bound=*/-3e2,
+                                                 /*upper_bound=*/kInf, "z");
+  model.Minimize(-5.0e4 * x + 1.0e-6 * z * x + 3.0 * y);
+  model.AddLinearConstraint(0.0 <= 1.25e-3 * y - 4.5e3 * x, "c");
+  model.AddLinearConstraint(/*lower_bound=*/-kInf, /*upper_bound=*/3e4);
+  model.AddLinearConstraint(-1e-5 <= 2.5e-3 * y <= 0.0);
+
+  const ModelRanges ranges = ComputeModelRanges(model);
+  EXPECT_THAT(ranges.objective_terms, Optional(Pair(1.0e-6, 5.0e4)));
+  EXPECT_THAT(ranges.variable_bounds, Optional(Pair(1e-3, 3e2)));
+  EXPECT_THAT(ranges.linear_constraint_bounds, Optional(Pair(1e-5, 3e4)));
+  EXPECT_THAT(ranges.linear_constraint_coefficients,
+              Optional(Pair(1.25e-3, 4.5e3)));
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/streamable_solver_init_arguments_test.cc b/ortools/math_opt/cpp/streamable_solver_init_arguments_test.cc
new file mode 100644
index 0000000000..060f5cb299
--- /dev/null
+++ b/ortools/math_opt/cpp/streamable_solver_init_arguments_test.cc
@@ -0,0 +1,50 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/streamable_solver_init_arguments.h"
+
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/parameters.pb.h"
+#include "ortools/math_opt/solvers/gurobi.pb.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+using ::testing::EqualsProto;
+
+TEST(StreamableInitArgumentsTest, Empty) {
+  const SolverInitializerProto args_proto;
+  ASSERT_OK_AND_ASSIGN(const StreamableSolverInitArguments args,
+                       StreamableSolverInitArguments::FromProto(args_proto));
+  EXPECT_THAT(args.Proto(), EqualsProto(args_proto));
+}
+
+TEST(StreamableGurobiInitArgumentsTest, ISV) {
+  SolverInitializerProto args_proto;
+  GurobiInitializerProto::ISVKey& isv_key_proto =
+      *args_proto.mutable_gurobi()->mutable_isv_key();
+  isv_key_proto.set_name("the name");
+  isv_key_proto.set_application_name("the application");
+  isv_key_proto.set_expiration(15);
+  isv_key_proto.set_key("the key");
+
+  ASSERT_OK_AND_ASSIGN(const StreamableSolverInitArguments args,
+                       StreamableSolverInitArguments::FromProto(args_proto));
+  EXPECT_THAT(args.Proto(), EqualsProto(args_proto));
+}
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/cpp/variable_and_expressions_nc_test.cc b/ortools/math_opt/cpp/variable_and_expressions_nc_test.cc
new file mode 100644
index 0000000000..6330c9a4c2
--- /dev/null
+++ b/ortools/math_opt/cpp/variable_and_expressions_nc_test.cc
@@ -0,0 +1,101 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This is a non-compilation test: go/cc_clang_verify_test.
+
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+
+namespace operations_research::math_opt {
+namespace {
+
+// This is kind of obvious, but here as a baseline.
+void CannotMutateTermsThroughConstReference() {
+  ModelStorage storage;
+  LinearExpression expr;
+  for (const auto& [var, coeff] : expr.terms()) {
+    // expected-error-re@+1 {{{{.*}}cannot assign to variable 'coeff'{{.*}}}}
+    coeff += 1.0;
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    var = Variable(&storage, storage.AddVariable("foo"));
+  }
+  for (const auto& term : expr.terms()) {
+    // expected-error-re@+1 {{{{.*}}cannot assign to variable 'term'{{.*}}}}
+    term.second += 1.0;
+    // And of course, one can't mutate the key.
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    term.first = Variable(&storage, storage.AddVariable("foo"));
+  }
+  for (const auto [var, coeff] : expr.terms()) {
+    // expected-error-re@+1 {{{{.*}}cannot assign to variable 'coeff'{{.*}}}}
+    coeff += 1.0;
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    var = Variable(&storage, storage.AddVariable("foo"));
+  }
+  for (const auto term : expr.terms()) {
+    // expected-error-re@+1 {{{{.*}}cannot assign to variable 'term'{{.*}}}}
+    term.second += 1.0;
+    // And of course, one can't mutate the key.
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    term.first = Variable(&storage, storage.AddVariable("foo"));
+  }
+}
+
+// People might think that they can mutate the coefficients through a non-const
+// reference. This is not supported.
+void CannotMutateTermsThroughReference() {
+  ModelStorage storage;
+  LinearExpression expr;
+  for (auto& term : expr.terms()) {
+    // expected-error-re@+1 {{{{.*}}cannot assign to variable 'term'{{.*}}}}
+    term.second += 1.0;
+    // And of course, one can't mutate the key.
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    term.first = Variable(&storage, storage.AddVariable("foo"));
+  }
+}
+void CannotMutateTermsThroughReferenceBinding() {
+  ModelStorage storage;
+  LinearExpression expr;
+  for (auto& [var, coeff] : expr.terms()) {
+    // expected-error-re@+1 {{{{.*}}cannot assign to variable 'coeff'{{.*}}}}
+    coeff += 1.0;
+    // And of course, one can't mutate the key.
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    var = Variable(&storage, storage.AddVariable("foo"));
+  }
+}
+
+// People might also think that the keys are proxy object that allow mutating
+// the coefficients through a non-const value. This is not supported either.
+void CannotMutateTermsThroughValue() {
+  ModelStorage storage;
+  LinearExpression expr;
+  for (auto term : expr.terms()) {
+    term.second += 1.0;
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    term.first = Variable(&storage, storage.AddVariable("foo"));
+  }
+}
+void CannotMutateTermsThroughValueBinding() {
+  ModelStorage storage;
+  LinearExpression expr;
+  for (auto [var, coeff] : expr.terms()) {
+    coeff += 1.0;
+    // expected-error-re@+1 {{{{.*}}no viable overloaded '='{{.*}}}}
+    var = Variable(&storage, storage.AddVariable("foo"));
+  }
+}
+
+}  // namespace
+}  // namespace operations_research::math_opt
diff --git a/ortools/math_opt/cpp/variable_and_expressions_test.cc b/ortools/math_opt/cpp/variable_and_expressions_test.cc
new file mode 100644
index 0000000000..7cb818374f
--- /dev/null
+++ b/ortools/math_opt/cpp/variable_and_expressions_test.cc
@@ -0,0 +1,7643 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/math_opt/cpp/variable_and_expressions.h"
+
+#include <initializer_list>
+#include <limits>
+#include <ostream>
+#include <sstream>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/math_opt/cpp/matchers.h"
+#include "ortools/math_opt/elemental/elements.h"
+#include "ortools/math_opt/storage/model_storage.h"
+#include "ortools/util/fp_roundtrip_conv.h"
+#include "ortools/util/fp_roundtrip_conv_testing.h"
+
+namespace operations_research {
+namespace math_opt {
+namespace {
+
+using ::testing::ContainerEq;
+using ::testing::ExplainMatchResult;
+using ::testing::IsEmpty;
+using ::testing::Not;
+using ::testing::Pair;
+using ::testing::PrintToString;
+using ::testing::UnorderedElementsAre;
+
+using internal::kObjectsFromOtherModelStorage;
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
+
+// Struct used as parameter in BoundedLinearExpressionEquiv matcher.
+struct LinearTerms {
+  LinearTerms() = default;
+  LinearTerms(std::initializer_list<LinearTerm> terms) : terms(terms) {}
+  std::vector<LinearTerm> terms;
+};
+
+std::ostream& operator<<(std::ostream& ostr, const LinearTerms& terms) {
+  if (terms.terms.empty()) {
+    ostr << "0";
+    return ostr;
+  }
+
+  bool first = true;
+  for (const auto& term : terms.terms) {
+    if (first) {
+      first = false;
+    } else {
+      ostr << " + ";
+    }
+    ostr << term.coefficient << "*" << term.variable;
+  }
+  return ostr;
+}
+
+// Return true if the two BoundedLinearExpression are equivalent. This is the
+// case when they have the same bounds (after removing the offset) and the same
+// coefficients. But this is also the case when they exchange their bounds and
+// change all the signs.
+//
+// For example these bounded expressions are equivalent:
+//   3 <= 2 * x - y + 2 <= 5
+//   4 <= 2 * x - y + 3 <= 6
+//   -5 <= -2 * x + y - 2 <= -3
+//
+// If one number is NaN the bounded expression will also be considered
+// different.
+//
+// Usage:
+//   EXPECT_THAT(-2 <= 3 * x + 2 * y <= 4,
+//               BoundedLinearExpressionEquiv(-2, LinearTerms({{x, 3}, {y, 2}}),
+//               4));
+MATCHER_P3(BoundedLinearExpressionEquiv, lower_bound, terms, upper_bound,
+           absl::StrFormat("%s equivalent to %s <= %s <= %s",
+                           negation ? "isn't" : "is",
+                           PrintToString(lower_bound), PrintToString(terms),
+                           PrintToString(upper_bound))) {
+  // We detect if we need to switch and negate bounds, and also negate terms.
+  const bool negation = arg.lower_bound_minus_offset() != lower_bound;
+  {
+    const double expected_lower_bound_minus_offset =
+        negation ? -upper_bound : lower_bound;
+    // We use the `!(x == y)` trick here so that NaN are seen as
+    // errors. Comparison with NaN is always false, hence the negation of
+    // equality will be true is at least one operand is NaN.
+    if (!(arg.lower_bound_minus_offset() ==
+          expected_lower_bound_minus_offset)) {
+      *result_listener << "lower_bound - offset = "
+                       << arg.lower_bound_minus_offset()
+                       << " != " << expected_lower_bound_minus_offset;
+      return false;
+    }
+  }
+  {
+    const double expected_upper_bound_minus_offset =
+        negation ? -lower_bound : upper_bound;
+    // We use the `!(x == y)` trick here so that NaN are seen as
+    // errors. Comparison with NaN is always false, hence the negation of
+    // equality will be true is at least one operand is NaN.
+    if (!(arg.upper_bound_minus_offset() ==
+          expected_upper_bound_minus_offset)) {
+      *result_listener << "upper_bound - offset = "
+                       << arg.upper_bound_minus_offset()
+                       << " != " << expected_upper_bound_minus_offset;
+      return false;
+    }
+  }
+  VariableMap<double> expected_terms;
+  for (const auto& term : terms.terms) {
+    expected_terms.emplace(term.variable,
+                           negation ? -term.coefficient : term.coefficient);
+  }
+  return ExplainMatchResult(ContainerEq(expected_terms), arg.expression.terms(),
+                            result_listener);
+}
+
+TEST(BoundedLinearExpressionMatcher, EmptyExpressions) {
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), -kInf, kInf),
+              BoundedLinearExpressionEquiv(-kInf, LinearTerms(), kInf));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), -3.0, 5.0),
+              BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), -5.0, 3.0),
+              BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0));
+
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), kNaN, 5.0),
+              Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0)));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), -3.0, kNaN),
+              Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0)));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), kNaN, kNaN),
+              Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0)));
+
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), -2.0, 5.0),
+              Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0)));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression(), -3.0, 6.0),
+              Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0)));
+}
+
+TEST(BoundedLinearExpressionMatcher, OffsetOnlyExpressions) {
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression({}, 3.0), -kInf, kInf),
+              BoundedLinearExpressionEquiv(-kInf, LinearTerms(), kInf));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression({}, 4.0), -3.0, 5.0),
+              BoundedLinearExpressionEquiv(-7.0, LinearTerms(), 1.0));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression({}, -4.0), -5.0, 3.0),
+              BoundedLinearExpressionEquiv(-7.0, LinearTerms(), 1.0));
+
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression({}, kNaN), -3.0, 5.0),
+              Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0)));
+
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression({}, 1.0), -3.0, 5.0),
+              Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms(), 5.0)));
+}
+
+TEST(BoundedLinearExpressionMatcher, OffsetAndTermsExpressions) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  EXPECT_THAT(BoundedLinearExpression(
+                  LinearExpression({{a, 1.0}, {b, -2.0}}, 3.0), -kInf, kInf),
+              BoundedLinearExpressionEquiv(
+                  -kInf, LinearTerms({{a, 1.0}, {b, -2.0}}), kInf));
+  EXPECT_THAT(BoundedLinearExpression(
+                  LinearExpression({{a, 1.0}, {b, -2.0}}, 4.0), -3.0, 5.0),
+              BoundedLinearExpressionEquiv(
+                  -7.0, LinearTerms({{a, 1.0}, {b, -2.0}}), 1.0));
+  EXPECT_THAT(BoundedLinearExpression(
+                  LinearExpression({{a, -1.0}, {b, 2.0}}, -4.0), -5.0, 3.0),
+              BoundedLinearExpressionEquiv(
+                  -7.0, LinearTerms({{a, 1.0}, {b, -2.0}}), 1.0));
+
+  EXPECT_THAT(BoundedLinearExpression(
+                  LinearExpression({{a, kNaN}, {b, -2.0}}, 0.0), -3.0, 5.0),
+              Not(BoundedLinearExpressionEquiv(
+                  -3.0, LinearTerms({{a, 1.0}, {b, -2.0}}), 5.0)));
+
+  EXPECT_THAT(BoundedLinearExpression(
+                  LinearExpression({{a, 1.0}, {b, -2.0}}, 0.0), -3.0, 5.0),
+              Not(BoundedLinearExpressionEquiv(
+                  -3.0, LinearTerms({{a, -1.0}, {b, -2.0}}), 5.0)));
+  EXPECT_THAT(BoundedLinearExpression(
+                  LinearExpression({{a, 1.0}, {b, -2.0}}, 0.0), -3.0, 5.0),
+              Not(BoundedLinearExpressionEquiv(
+                  -3.0, LinearTerms({{a, 1.0}, {b, -2.0}, {c, 3.0}}), 5.0)));
+  EXPECT_THAT(
+      BoundedLinearExpression(LinearExpression({{a, 1.0}, {b, -2.0}}, 0.0),
+                              -3.0, 5.0),
+      Not(BoundedLinearExpressionEquiv(-3.0, LinearTerms({{a, 1.0}}), 5.0)));
+  EXPECT_THAT(BoundedLinearExpression(
+                  LinearExpression({{a, -1.0}, {b, 2.0}}, -4.0), -5.0, 3.0),
+              Not(BoundedLinearExpressionEquiv(-7.0, LinearTerms(), 1.0)));
+  EXPECT_THAT(BoundedLinearExpression(LinearExpression({}, -4.0), -5.0, 3.0),
+              Not(BoundedLinearExpressionEquiv(
+                  -7.0, LinearTerms({{a, 1.0}, {b, -2.0}}), 1.0)));
+}
+
+// Struct used as parameter in BoundedLinearExpressionEquiv matcher.
+struct QuadraticTerms {
+  QuadraticTerms() = default;
+  QuadraticTerms(std::initializer_list<QuadraticTerm> terms) : terms(terms) {}
+  std::vector<QuadraticTerm> terms;
+};
+
+std::ostream& operator<<(std::ostream& ostr, const QuadraticTerms& terms) {
+  if (terms.terms.empty()) {
+    ostr << "0";
+    return ostr;
+  }
+
+  bool first = true;
+  for (const auto& term : terms.terms) {
+    if (first) {
+      first = false;
+    } else {
+      ostr << " + ";
+    }
+    ostr << term.coefficient() << "*" << term.first_variable();
+    if (term.first_variable() == term.second_variable()) {
+      ostr << "²";
+    } else {
+      ostr << "*" << term.second_variable();
+    }
+  }
+  return ostr;
+}
+
+// Return true if the two BoundedQuadraticExpression are equivalent. This is the
+// case when they have the same bounds (after removing the offset) and the same
+// coefficients. But this is also the case when they exchange their bounds and
+// change all the signs.
+//
+// For example these bounded expressions are equivalent:
+//   3 <= 2 * x * y - y + 2 <= 5
+//   4 <= 2 * x * y - y + 3 <= 6
+//   -5 <= -2 * x * y + y - 2 <= -3
+//
+// If one number is NaN the bounded expression will also be considered
+// different.
+//
+// Usage:
+//   EXPECT_THAT(-2 <= 3 * x * y + 2 * y <= 4,
+//               BoundedQuadraticExpressionEquiv(-2, QuadraticTerms({{x, y,
+//               3}}), LinearTerms({{x, 3}, {y, 2}}), 4));
+MATCHER_P4(BoundedQuadraticExpressionEquiv, lower_bound, quadratic_terms,
+           linear_terms, upper_bound,
+           absl::StrFormat("%s equivalent to %s <= %s + %s <= %s",
+                           negation ? "isn't" : "is",
+                           PrintToString(lower_bound),
+                           PrintToString(quadratic_terms),
+                           PrintToString(linear_terms),
+                           PrintToString(upper_bound))) {
+  // We detect if we need to switch and negate bounds, and also negate terms.
+  const bool negation = arg.lower_bound_minus_offset() != lower_bound;
+  {
+    const double expected_lower_bound_minus_offset =
+        negation ? -upper_bound : lower_bound;
+    // We use the `!(x == y)` trick here so that NaN are seen as
+    // errors. Comparison with NaN is always false, hence the negation of
+    // equality will be true is at least one operand is NaN.
+    if (!(arg.lower_bound_minus_offset() ==
+          expected_lower_bound_minus_offset)) {
+      *result_listener << "lower_bound - offset = "
+                       << arg.lower_bound_minus_offset()
+                       << " != " << expected_lower_bound_minus_offset;
+      return false;
+    }
+  }
+  {
+    const double expected_upper_bound_minus_offset =
+        negation ? -lower_bound : upper_bound;
+    // We use the `!(x == y)` trick here so that NaN are seen as
+    // errors. Comparison with NaN is always false, hence the negation of
+    // equality will be true is at least one operand is NaN.
+    if (!(arg.upper_bound_minus_offset() ==
+          expected_upper_bound_minus_offset)) {
+      *result_listener << "upper_bound - offset = "
+                       << arg.upper_bound_minus_offset()
+                       << " != " << expected_upper_bound_minus_offset;
+      return false;
+    }
+  }
+  VariableMap<double> expected_linear_terms;
+  for (const auto& term : linear_terms.terms) {
+    expected_linear_terms.insert(
+        {term.variable, negation ? -term.coefficient : term.coefficient});
+  }
+  QuadraticTermMap<double> expected_quadratic_terms;
+  for (const auto& term : quadratic_terms.terms) {
+    expected_quadratic_terms.insert(
+        {term.GetKey(), negation ? -term.coefficient() : term.coefficient()});
+  }
+  return ExplainMatchResult(ContainerEq(expected_linear_terms),
+                            arg.expression.linear_terms(), result_listener) &
+         ExplainMatchResult(ContainerEq(expected_quadratic_terms),
+                            arg.expression.quadratic_terms(), result_listener);
+}
+
+TEST(BoundedQuadraticExpressionMatcher, EmptyExpressions) {
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), -kInf, kInf),
+              BoundedQuadraticExpressionEquiv(-kInf, QuadraticTerms(),
+                                              LinearTerms(), kInf));
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), -3.0, 5.0),
+              BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                              LinearTerms(), 5.0));
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), -5.0, 3.0),
+              BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                              LinearTerms(), 5.0));
+
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), kNaN, 5.0),
+              Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                                  LinearTerms(), 5.0)));
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), -3.0, kNaN),
+              Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                                  LinearTerms(), 5.0)));
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), kNaN, kNaN),
+              Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                                  LinearTerms(), 5.0)));
+
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), -2.0, 5.0),
+              Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                                  LinearTerms(), 5.0)));
+  EXPECT_THAT(BoundedQuadraticExpression(QuadraticExpression(), -3.0, 6.0),
+              Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                                  LinearTerms(), 5.0)));
+}
+
+TEST(BoundedQuadraticExpressionMatcher, OffsetOnlyExpressions) {
+  EXPECT_THAT(
+      BoundedQuadraticExpression(QuadraticExpression({}, {}, 3.0), -kInf, kInf),
+      BoundedQuadraticExpressionEquiv(-kInf, QuadraticTerms(), LinearTerms(),
+                                      kInf));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(QuadraticExpression({}, {}, 4.0), -3.0, 5.0),
+      BoundedQuadraticExpressionEquiv(-7.0, QuadraticTerms(), LinearTerms(),
+                                      1.0));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(QuadraticExpression({}, {}, -4.0), -5.0, 3.0),
+      BoundedQuadraticExpressionEquiv(-7.0, QuadraticTerms(), LinearTerms(),
+                                      1.0));
+
+  EXPECT_THAT(
+      BoundedQuadraticExpression(QuadraticExpression({}, {}, kNaN), -3.0, 5.0),
+      Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(), LinearTerms(),
+                                          5.0)));
+
+  EXPECT_THAT(
+      BoundedQuadraticExpression(QuadraticExpression({}, {}, 1.0), -3.0, 5.0),
+      Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(), LinearTerms(),
+                                          5.0)));
+}
+
+TEST(BoundedQuadraticExpressionMatcher, OffsetAndLinearTermsOnlyExpressions) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, 1.0}, {b, -2.0}}, 3.0), -kInf, kInf),
+      BoundedQuadraticExpressionEquiv(
+          -kInf, QuadraticTerms(), LinearTerms({{a, 1.0}, {b, -2.0}}), kInf));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, 1.0}, {b, -2.0}}, 4.0), -3.0, 5.0),
+      BoundedQuadraticExpressionEquiv(-7.0, QuadraticTerms(),
+                                      LinearTerms({{a, 1.0}, {b, -2.0}}), 1.0));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, -1.0}, {b, 2.0}}, -4.0), -5.0, 3.0),
+      BoundedQuadraticExpressionEquiv(-7.0, QuadraticTerms(),
+                                      LinearTerms({{a, 1.0}, {b, -2.0}}), 1.0));
+
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, kNaN}, {b, -2.0}}, 0.0), -3.0, 5.0),
+      Not(BoundedQuadraticExpressionEquiv(
+          -3.0, QuadraticTerms(), LinearTerms({{a, 1.0}, {b, -2.0}}), 5.0)));
+
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, 1.0}, {b, -2.0}}, 0.0), -3.0, 5.0),
+      Not(BoundedQuadraticExpressionEquiv(
+          -3.0, QuadraticTerms(), LinearTerms({{a, -1.0}, {b, -2.0}}), 5.0)));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, 1.0}, {b, -2.0}}, 0.0), -3.0, 5.0),
+      Not(BoundedQuadraticExpressionEquiv(
+          -3.0, QuadraticTerms(), LinearTerms({{a, 1.0}, {b, -2.0}, {c, 3.0}}),
+          5.0)));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, 1.0}, {b, -2.0}}, 0.0), -3.0, 5.0),
+      Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms(),
+                                          LinearTerms({{a, 1.0}}), 5.0)));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({}, {{a, -1.0}, {b, 2.0}}, -4.0), -5.0, 3.0),
+      Not(BoundedQuadraticExpressionEquiv(-7.0, QuadraticTerms(), LinearTerms(),
+                                          1.0)));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(QuadraticExpression({}, {}, -4.0), -5.0, 3.0),
+      Not(BoundedQuadraticExpressionEquiv(
+          -7.0, QuadraticTerms(), LinearTerms({{a, 1.0}, {b, -2.0}}), 1.0)));
+}
+
+TEST(BoundedQuadraticExpressionMatcher, OffsetAndTermsExpressions) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  EXPECT_THAT(BoundedQuadraticExpression(
+                  QuadraticExpression({{a, a, 4.0}, {a, b, 5.0}},
+                                      {{a, 1.0}, {b, -2.0}}, 3.0),
+                  -kInf, kInf),
+              BoundedQuadraticExpressionEquiv(
+                  -kInf, QuadraticTerms({{a, a, 4.0}, {a, b, 5.0}}),
+                  LinearTerms({{a, 1.0}, {b, -2.0}}), kInf));
+  EXPECT_THAT(BoundedQuadraticExpression(
+                  QuadraticExpression({{a, a, 4.0}, {a, b, 5.0}},
+                                      {{a, 1.0}, {b, -2.0}}, 4.0),
+                  -3.0, 5.0),
+              BoundedQuadraticExpressionEquiv(
+                  -7.0, QuadraticTerms({{a, a, 4.0}, {a, b, 5.0}}),
+                  LinearTerms({{a, 1.0}, {b, -2.0}}), 1.0));
+  EXPECT_THAT(BoundedQuadraticExpression(
+                  QuadraticExpression({{a, a, 4.0}, {a, b, 5.0}},
+                                      {{a, -1.0}, {b, 2.0}}, -4.0),
+                  -5.0, 3.0),
+              BoundedQuadraticExpressionEquiv(
+                  -1.0, QuadraticTerms({{a, a, 4.0}, {a, b, 5.0}}),
+                  LinearTerms({{a, -1.0}, {b, 2.0}}), 7.0));
+
+  EXPECT_THAT(BoundedQuadraticExpression(
+                  QuadraticExpression({{a, a, kNaN}, {a, b, 5.0}},
+                                      {{a, 1.0}, {b, -2.0}}, 0.0),
+                  -3.0, 5.0),
+              Not(BoundedQuadraticExpressionEquiv(
+                  -3.0, QuadraticTerms({{a, a, 4.0}, {a, b, 5.0}}),
+                  LinearTerms({{a, 1.0}, {b, -2.0}}), 5.0)));
+
+  EXPECT_THAT(BoundedQuadraticExpression(
+                  QuadraticExpression({{a, a, 4.0}, {a, b, 5.0}},
+                                      {{a, 1.0}, {b, -2.0}}, 0.0),
+                  -3.0, 5.0),
+              Not(BoundedQuadraticExpressionEquiv(
+                  -3.0, QuadraticTerms({{a, a, -4.0}, {a, b, 5.0}}),
+                  LinearTerms({{a, 1.0}, {b, -2.0}}), 5.0)));
+  EXPECT_THAT(BoundedQuadraticExpression(
+                  QuadraticExpression({{a, a, 4.0}, {a, b, 5.0}},
+                                      {{a, 1.0}, {b, -2.0}}, 0.0),
+                  -3.0, 5.0),
+              Not(BoundedQuadraticExpressionEquiv(
+                  -3.0, QuadraticTerms({{a, a, 4.0}, {a, b, 5.0}, {a, c, 6.0}}),
+                  LinearTerms({{a, 1.0}, {b, -2.0}, {c, 3.0}}), 5.0)));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({{a, a, 4.0}, {a, b, 5.0}}, {{a, 1.0}, {b, -2.0}},
+                              0.0),
+          -3.0, 5.0),
+      Not(BoundedQuadraticExpressionEquiv(-3.0, QuadraticTerms({{a, a, 4.0}}),
+                                          LinearTerms({{a, 1.0}}), 5.0)));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(
+          QuadraticExpression({{a, a, 4.0}, {a, b, 5.0}}, {{a, -1.0}, {b, 2.0}},
+                              -4.0),
+          -5.0, 3.0),
+      Not(BoundedQuadraticExpressionEquiv(
+          -7.0, QuadraticTerms(), LinearTerms({{a, -1.0}, {b, 2.0}}), 1.0)));
+  EXPECT_THAT(
+      BoundedQuadraticExpression(QuadraticExpression({}, {}, -4.0), -5.0, 3.0),
+      Not(BoundedQuadraticExpressionEquiv(
+          -7.0, QuadraticTerms({{a, a, 4.0}, {a, b, 5.0}}), LinearTerms(),
+          1.0)));
+}
+
+TEST(Variable, OutputStreaming) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable());
+
+  auto to_string = [](Variable v) {
+    std::ostringstream oss;
+    oss << v;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(a), "a");
+  EXPECT_EQ(to_string(b), absl::StrCat("__var#", b.id(), "__"));
+}
+
+TEST(Variable, Accessors) {
+  ModelStorage storage;
+  {
+    const VariableId v_id =
+        storage.AddVariable(/*lower_bound=*/-kInf, /*upper_bound=*/kInf,
+                            /*is_integer=*/false, "continuous");
+    const Variable v(&storage, v_id);
+    EXPECT_EQ(v.name(), "continuous");
+    EXPECT_EQ(v.id(), v_id.value());
+    EXPECT_EQ(v.typed_id(), v_id);
+    EXPECT_EQ(v.lower_bound(), -kInf);
+    EXPECT_EQ(v.upper_bound(), kInf);
+    EXPECT_FALSE(v.is_integer());
+  }
+  {
+    const VariableId v_id =
+        storage.AddVariable(/*lower_bound=*/3.0, /*upper_bound=*/5.0,
+                            /*is_integer=*/true, "integer");
+    const Variable v(&storage, v_id);
+    EXPECT_EQ(v.name(), "integer");
+    EXPECT_EQ(v.id(), v_id.value());
+    EXPECT_EQ(v.typed_id(), v_id);
+    EXPECT_EQ(v.lower_bound(), 3.0);
+    EXPECT_EQ(v.upper_bound(), 5.0);
+    EXPECT_TRUE(v.is_integer());
+  }
+}
+
+TEST(Variable, NameAfterDeletion) {
+  Model model;
+  const Variable x = model.AddVariable("x");
+  ASSERT_EQ(x.name(), "x");
+
+  model.DeleteVariable(x);
+  EXPECT_EQ(x.name(), "[variable deleted from model]");
+}
+
+TEST(VariablesEqualityTest, SameModelAndVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable a_copy = a;
+
+  // First test with EXPECT_ macros. These works even if the `operator bool`
+  // conversion is explicit.
+  EXPECT_EQ(a, a);
+  EXPECT_EQ(a, a_copy);
+
+  // Then test with writing `==` directly.
+  EXPECT_TRUE(a == a);
+  EXPECT_TRUE(a == a_copy);
+
+  // And the operator `!=`.
+  EXPECT_FALSE(a != a);
+  EXPECT_FALSE(a != a_copy);
+}
+
+TEST(VariablesEqualityTest, SameModelTwoVariables) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with EXPECT_NE macro. It works even if the `operator bool`
+  // conversion is explicit.
+  EXPECT_NE(a, b);
+
+  // Then test with writing `==` directly to test the implicit cast.
+  EXPECT_FALSE(a == b);
+
+  // Same for `!=`.
+  EXPECT_TRUE(a != b);
+}
+
+TEST(VariablesEqualityTest, DifferentModelsSameVariable) {
+  // Create two variables with the same name and index but in two different
+  // models.
+  ModelStorage model_a;
+  const Variable a_a(&model_a, model_a.AddVariable("a"));
+  ModelStorage model_b;
+  const Variable b_a(&model_b, model_b.AddVariable("a"));
+
+  // First test with EXPECT_NE macro. It works even if the `operator bool`
+  // conversion is explicit.
+  EXPECT_NE(a_a, b_a);
+
+  // Then test with writing `==` directly to test the implicit cast.
+  EXPECT_FALSE(a_a == b_a);
+
+  // Same for `!=`.
+  EXPECT_TRUE(a_a != b_a);
+}
+
+TEST(VariablesEqualityTest, VariablesAsKeysInMap) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // Test using the variables as keys.
+  absl::flat_hash_map<Variable, int> map;
+  map.emplace(a, 1);
+  map[b] = 2;
+
+  EXPECT_EQ(map.at(a), 1);
+  EXPECT_EQ(map.at(b), 2);
+}
+
+TEST(LinearTermTest, FromVariableAndDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term(a, 3.0);
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 3.0);
+}
+
+TEST(LinearTermTest, Negation) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term = -LinearTerm(a, 3);
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, -3.0);
+}
+
+TEST(LinearTermTest, DoubleTimesVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term = 3 * a;
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 3.0);
+}
+
+TEST(LinearTermTest, VariableTimesDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term = a * 3;
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 3.0);
+}
+
+TEST(LinearTermTest, DoubleTimesLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term = 2 * LinearTerm(a, 3);
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 6.0);
+}
+
+TEST(LinearTermTest, LinearTermTimesDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term = LinearTerm(a, 3) * 2;
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 6.0);
+}
+
+TEST(LinearTermTest, LinearTermTimesAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  LinearTerm term(a, 3);
+  term *= 2;
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 6.0);
+}
+
+TEST(LinearTermTest, VariableDividedByDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term = a / 2;
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 0.5);
+}
+
+TEST(LinearTermTest, LinearTermDividedByDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearTerm term = LinearTerm(a, 4) / 2;
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 2.0);
+}
+
+TEST(LinearTermTest, LinearTermDividedByAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  LinearTerm term(a, 4);
+  term /= 2;
+  EXPECT_EQ(term.variable, a);
+  EXPECT_EQ(term.coefficient, 2.0);
+}
+
+// Define a reset function and a set of macros to test the constructor counters
+// of LinearExpression. When the counters are disabled, define empty
+// equivalents.
+#ifdef MATH_OPT_USE_EXPRESSION_COUNTERS
+void ResetExpressionCounters() {
+  LinearExpression::ResetCounters();
+  QuadraticExpression::ResetCounters();
+}
+#define EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(T, x) \
+  EXPECT_EQ(T::num_calls_default_constructor_, x);
+#define EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(T, x) \
+  EXPECT_EQ(T::num_calls_copy_constructor_, x);
+#define EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(T, x) \
+  EXPECT_EQ(T::num_calls_move_constructor_, x);
+#define EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(T, x) \
+  EXPECT_EQ(T::num_calls_initializer_list_constructor_, x);
+#define EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(x) \
+  EXPECT_EQ(QuadraticExpression::num_calls_linear_expression_constructor_, x);
+#define EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(x)              \
+  EXPECT_EQ(LinearExpression::num_calls_default_constructor_ +             \
+                LinearExpression::num_calls_copy_constructor_ +            \
+                LinearExpression::num_calls_move_constructor_ +            \
+                LinearExpression::num_calls_initializer_list_constructor_, \
+            x)                                                             \
+      << "num_calls_default_constructor: "                                 \
+      << LinearExpression::num_calls_default_constructor_                  \
+      << "\nnum_calls_copy_constructor: "                                  \
+      << LinearExpression::num_calls_copy_constructor_                     \
+      << "\nnum_calls_move_constructor: "                                  \
+      << LinearExpression::num_calls_move_constructor_                     \
+      << "\nnum_calls_initializer_list_constructor: "                      \
+      << LinearExpression::num_calls_initializer_list_constructor_
+#define EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(x)               \
+  EXPECT_EQ(QuadraticExpression::num_calls_default_constructor_ +              \
+                QuadraticExpression::num_calls_copy_constructor_ +             \
+                QuadraticExpression::num_calls_move_constructor_ +             \
+                QuadraticExpression::num_calls_initializer_list_constructor_ + \
+                QuadraticExpression::num_calls_linear_expression_constructor_, \
+            x)                                                                 \
+      << "num_calls_default_constructor: "                                     \
+      << QuadraticExpression::num_calls_default_constructor_                   \
+      << "\nnum_calls_copy_constructor: "                                      \
+      << QuadraticExpression::num_calls_copy_constructor_                      \
+      << "\nnum_calls_move_constructor: "                                      \
+      << QuadraticExpression::num_calls_move_constructor_                      \
+      << "\nnum_calls_initializer_list_constructor: "                          \
+      << QuadraticExpression::num_calls_initializer_list_constructor_          \
+      << "\nnum_calls_linear_expression_constructor: "                         \
+      << QuadraticExpression::num_calls_linear_expression_constructor_
+#else
+void ResetExpressionCounters() {}
+#define EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(T, x)
+#define EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(T, x)
+#define EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(T, x)
+#define EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(T, x)
+#define EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(x)
+#define EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(x)
+#define EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(x)
+#endif  // MATH_OPT_USE_EXPRESSION_COUNTERS
+
+TEST(VariableTest, Negation) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  ResetExpressionCounters();
+  {
+    const LinearExpression expr = -a;
+
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+    EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -1}}, 0)));
+  }
+
+  ResetExpressionCounters();
+  {
+    const QuadraticExpression expr = -a;
+
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+    EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, -1}}, 0)));
+  }
+}
+
+TEST(LinearExpressionTest, DefaultValue) {
+  const LinearExpression expr;
+  EXPECT_EQ(expr.offset(), 0.0);
+  EXPECT_THAT(expr.terms(), IsEmpty());
+  EXPECT_EQ(expr.storage(), nullptr);
+  EXPECT_THAT(expr.terms(), IsEmpty());
+}
+
+TEST(LinearExpressionTest, EmptyInitializerList) {
+  const LinearExpression expr({}, 5);
+  EXPECT_EQ(expr.offset(), 5.0);
+  EXPECT_THAT(expr.terms(), IsEmpty());
+  EXPECT_EQ(expr.storage(), nullptr);
+  EXPECT_THAT(expr.terms(), IsEmpty());
+}
+
+TEST(LinearExpressionTest, TermsFromSameModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearExpression expr({{a, 3}, {b, 5}, {a, -2}}, -1);
+  EXPECT_EQ(expr.offset(), -1.0);
+  EXPECT_THAT(expr.terms(), UnorderedElementsAre(Pair(a, 1), Pair(b, 5)));
+  EXPECT_EQ(expr.storage(), &storage);
+  EXPECT_THAT(expr.terms(), UnorderedElementsAre(Pair(a, 1), Pair(b, 5)));
+}
+
+TEST(LinearExpressionDeathTest, TermsFromDifferentModels) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+
+  EXPECT_DEATH(LinearExpression({{a, 3}, {b, 5}}, -1),
+               kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionTest, ReassignDifferentModels) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+  const LinearExpression expr_a = a + 2.0;
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+  LinearExpression expr_b_to_overwrite = 3.0 * b + 1.0;
+
+  expr_b_to_overwrite = expr_a;
+  EXPECT_THAT(expr_b_to_overwrite, IsIdentical(LinearExpression({{a, 1}}, 2)));
+  EXPECT_EQ(expr_b_to_overwrite.storage(), &model_a);
+}
+
+TEST(LinearExpressionTest, MoveConstruction) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+  LinearExpression expr_a = a + 2.0;
+  const LinearExpression expr_b = std::move(expr_a);
+
+  EXPECT_THAT(expr_b, IsIdentical(LinearExpression({{a, 1}}, 2)));
+  EXPECT_EQ(expr_b.storage(), &model_a);
+
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  EXPECT_THAT(expr_a.terms(), IsEmpty());
+  EXPECT_EQ(expr_a.storage(), nullptr);
+}
+
+TEST(LinearExpressionTest, MoveAssignment) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+  LinearExpression expr_a = a + 2.0;
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+  LinearExpression expr_b_to_overwrite = 3.0 * b + 1.0;
+
+  expr_b_to_overwrite = std::move(expr_a);
+
+  EXPECT_THAT(expr_b_to_overwrite, IsIdentical(LinearExpression({{a, 1}}, 2)));
+  EXPECT_EQ(expr_b_to_overwrite.storage(), &model_a);
+
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  EXPECT_THAT(expr_a.terms(), IsEmpty());
+  EXPECT_EQ(expr_a.storage(), nullptr);
+}
+
+TEST(LinearExpressionTest, EvaluateEmpty) {
+  const LinearExpression empty_expr;
+  {
+    ModelStorage storage;
+    const Variable a(&storage, storage.AddVariable("a"));
+    VariableMap<double> variable_values;
+    variable_values[a] = 10.0;
+    EXPECT_EQ(empty_expr.Evaluate(variable_values), 0.0);
+    EXPECT_EQ(empty_expr.EvaluateWithDefaultZero(variable_values), 0.0);
+  }
+  {
+    const VariableMap<double> empty_values;
+    EXPECT_EQ(empty_expr.Evaluate(empty_values), 0.0);
+    EXPECT_EQ(empty_expr.EvaluateWithDefaultZero(empty_values), 0.0);
+  }
+}
+
+TEST(LinearExpressionTest, EvaluateOnlyOffset) {
+  const LinearExpression constant_expr(8.0);
+  {
+    ModelStorage storage;
+    const Variable a(&storage, storage.AddVariable("a"));
+    VariableMap<double> variable_values;
+    variable_values[a] = 10.0;
+    EXPECT_EQ(constant_expr.Evaluate(variable_values), 8.0);
+    EXPECT_EQ(constant_expr.EvaluateWithDefaultZero(variable_values), 8.0);
+  }
+  {
+    const VariableMap<double> empty_values;
+    EXPECT_EQ(constant_expr.Evaluate(empty_values), 8.0);
+    EXPECT_EQ(constant_expr.EvaluateWithDefaultZero(empty_values), 8.0);
+  }
+}
+
+TEST(LinearExpressionTest, SimpleEvaluate) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearExpression expr = 3.0 * a + 5.0 * b - 2.0;
+  VariableMap<double> variable_values;
+  variable_values[a] = 10.0;
+  variable_values[b] = 100.0;
+  EXPECT_EQ(expr.Evaluate(variable_values), 528.0);
+}
+
+TEST(LinearExpressionTest, SimpleEvaluateWithDefault) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearExpression expr = 3.0 * a + 5.0 * b - 2.0;
+  VariableMap<double> variable_values;
+  variable_values[b] = 100.0;
+  EXPECT_EQ(expr.EvaluateWithDefaultZero(variable_values), 498.0);
+}
+
+TEST(LinearExpressionTest, StableEvaluateAndEvaluateWithDefault) {
+  // Here we test that the floating point sum of numbers is done in the sorted
+  // order of the variables ids. To do so we rely on a specific floating point
+  // number sequence (obtained with a Python script doing random tries) which
+  // floating point sum changes depending on the order of operations:
+  //
+  // 56.66114901664141 + 76.288516611269 + 73.11902164661139 +
+  //   0.677336454040622 + 43.75820160525244 = 250.50422533381482
+  // 56.66114901664141 + 76.288516611269 + 73.11902164661139 +
+  //   43.75820160525244 + 0.677336454040622 = 250.50422533381484
+  // 56.66114901664141 + 76.288516611269 + 0.677336454040622 +
+  //   73.11902164661139 + 43.75820160525244 = 250.50422533381487
+  // 76.288516611269 + 0.677336454040622 + 73.11902164661139 +
+  //   43.75820160525244 + 56.66114901664141 = 250.5042253338149
+  //
+  // Here we will use the first value as the offset of the linear expression (to
+  // test that it always taken into account in the same order).
+  constexpr double kOffset = 56.66114901664141;
+  const std::vector<double> coeffs = {76.288516611269, 73.11902164661139,
+                                      0.677336454040622, 43.75820160525244};
+
+  ModelStorage storage;
+  std::vector<Variable> vars;
+  VariableMap<double> variable_values;
+  for (int i = 0; i < coeffs.size(); ++i) {
+    vars.emplace_back(&storage, storage.AddVariable(absl::StrCat("v_", i)));
+    variable_values.try_emplace(vars.back(), 1.0);
+  }
+
+  LinearExpression expr = kOffset;
+  for (const int i : {3, 2, 0, 1}) {
+    expr += coeffs[i] * vars[i];
+  }
+
+  // Expected value for the sum which is:
+  //   - offset first
+  //   - then all terms sums in the order of variables' indices
+  // See the table in the comment above.
+  constexpr double kExpected = 250.50422533381482;
+
+  // Test Evaluate();
+  {
+    const double got = expr.Evaluate(variable_values);
+    EXPECT_EQ(got, kExpected)
+        << "got: " << RoundTripDoubleFormat(got)
+        << " expected: " << RoundTripDoubleFormat(kExpected);
+  }
+
+  // Test EvaluateWithDefaultZero();
+  {
+    const double got = expr.EvaluateWithDefaultZero(variable_values);
+    EXPECT_EQ(got, kExpected)
+        << "got: " << RoundTripDoubleFormat(got)
+        << " expected: " << RoundTripDoubleFormat(kExpected);
+  }
+}
+
+TEST(LinearExpressionDeathTest, EvaluateMisingVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearExpression expr = 3.0 * a + 5.0 * b - 2.0;
+  VariableMap<double> variable_values;
+  variable_values[b] = 100.0;
+  EXPECT_DEATH(expr.Evaluate(variable_values), "");
+}
+
+TEST(LinearExpressionDeathTest, EvaluateDifferentModels) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+  const LinearExpression expr = 3.0 * a - 2.0;
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+  VariableMap<double> variable_values;
+  variable_values[b] = 100.0;
+
+  EXPECT_DEATH(expr.Evaluate(variable_values), kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionDeathTest, EvaluateWithDefaultZeroDifferentModels) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+  const LinearExpression expr = 3.0 * a - 2.0;
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+  VariableMap<double> variable_values;
+  variable_values[b] = 100.0;
+
+  EXPECT_EQ(expr.EvaluateWithDefaultZero(variable_values), -2.0);
+}
+
+TEST(LinearExpressionTest, FromDouble) {
+  const LinearExpression expr = 4.0;
+
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({}, 4)));
+  EXPECT_EQ(expr.storage(), nullptr);
+  EXPECT_THAT(expr.terms(), IsEmpty());
+}
+
+TEST(LinearExpressionTest, FromVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearExpression expr = a;
+
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}}, 0)));
+  EXPECT_EQ(expr.storage(), &storage);
+  EXPECT_THAT(expr.terms(), UnorderedElementsAre(Pair(a, 1.0)));
+}
+
+TEST(LinearExpressionTest, FromLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const LinearExpression expr = LinearTerm(a, 3.0);
+
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}}, 0)));
+  EXPECT_EQ(expr.storage(), &storage);
+  EXPECT_THAT(expr.terms(), UnorderedElementsAre(Pair(a, 3.0)));
+}
+
+TEST(LinearExpressionTest, OutputStreaming) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  auto to_string = [](LinearExpression expression) {
+    std::ostringstream oss;
+    oss << expression;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(LinearExpression()), "0");
+  EXPECT_EQ(to_string(LinearExpression({}, -1)), "-1");
+  EXPECT_EQ(to_string(LinearExpression({}, -1)), "-1");
+  EXPECT_EQ(to_string(LinearExpression({{a, 0}}, -1)), "-1");
+  EXPECT_EQ(to_string(LinearExpression({{a, 3}, {b, 5}, {a, -2}}, -1)),
+            "a + 5*b - 1");
+  EXPECT_EQ(to_string(LinearExpression({{a, -1.0}, {b, -1.0}}, -2.0)),
+            "-a - b - 2");
+  EXPECT_EQ(to_string(LinearExpression({{a, kNaN}, {b, -kNaN}}, -kNaN)),
+            "nan*a + nan*b + nan");
+  EXPECT_EQ(to_string(LinearExpression({{a, kRoundTripTestNumber}})),
+            absl::StrCat(kRoundTripTestNumberStr, "*a"));
+  EXPECT_EQ(to_string(LinearExpression({}, kRoundTripTestNumber)),
+            kRoundTripTestNumberStr);
+}
+
+TEST(LinearExpressionTest, Negation) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = -LinearExpression({{a, 3}, {b, -2}}, 5);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -3}, {b, 2}}, -5)));
+}
+
+TEST(LinearExpressionTest, AdditionAssignmentDouble) {
+  LinearExpression expr;
+
+  ResetExpressionCounters();
+  expr += 3;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({}, 3)));
+
+  ResetExpressionCounters();
+  expr += -2;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({}, 1)));
+}
+
+TEST(LinearExpressionTest, AdditionAssignmentVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  LinearExpression expr;
+  ResetExpressionCounters();
+  expr += a;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr += a;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr += b;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 1}}, 0)));
+}
+
+TEST(LinearExpressionDeathTest, AdditionAssignmentVariableOtherModel) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+
+  LinearExpression expr;
+  expr += a;
+  EXPECT_DEATH(expr += b, kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionTest, AdditionAssignmentLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  LinearExpression expr;
+  ResetExpressionCounters();
+  expr += LinearTerm(a, 3);
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr += LinearTerm(a, -2);
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr += LinearTerm(b, -5);
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}, {b, -5}}, 0)));
+}
+
+TEST(LinearExpressionDeathTest, AdditionAssignmentLinearTermOtherModel) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+
+  LinearExpression expr;
+  expr += LinearTerm(a, 3);
+  EXPECT_DEATH(expr += LinearTerm(b, 2), kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionTest, AdditionAssignmentSelf) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression expr({{a, 2}, {b, 4}}, 2);
+  ResetExpressionCounters();
+  expr += expr;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 4}, {b, 8}}, 4)));
+}
+
+TEST(LinearExpressionTest, AdditionAssignmentOtherExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  LinearExpression expr;
+  expr += LinearExpression({{a, 2}, {b, 4}}, 2);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 4}}, 2)));
+
+  // Then add another expression with variables from the same ModelStorage.
+  expr += LinearExpression({{a, -3}, {c, 6}}, -4);
+  EXPECT_THAT(expr,
+              IsIdentical(LinearExpression({{a, -1}, {b, 4}, {c, 6}}, -2)));
+
+  // Then add another expression without variables (i.e. having null
+  // ModelStorage).
+  expr += LinearExpression({}, 3);
+  EXPECT_THAT(expr,
+              IsIdentical(LinearExpression({{a, -1}, {b, 4}, {c, 6}}, 1)));
+}
+
+TEST(LinearExpressionDeathTest, AdditionAssignmentOtherExpressionAndModel) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+
+  LinearExpression expr({{a, 1}}, 0);
+  const LinearExpression other({{b, 1}}, 0);
+  EXPECT_DEATH(expr += other, kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionTest, SubtractionAssignmentDouble) {
+  LinearExpression expr;
+
+  ResetExpressionCounters();
+  expr -= 3;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({}, -3)));
+
+  ResetExpressionCounters();
+  expr -= -2;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({}, -1)));
+}
+
+TEST(LinearExpressionTest, SubtractionAssignmentVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  LinearExpression expr;
+  ResetExpressionCounters();
+  expr -= a;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -1}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr -= a;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -2}}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr -= b;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -2}, {b, -1}}, 0)));
+}
+
+TEST(LinearExpressionDeathTest, SubtractionAssignmentVariableOtherModel) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+
+  LinearExpression expr;
+  expr -= a;
+  EXPECT_DEATH(expr -= b, kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionTest, SubtractionAssignmentLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  LinearExpression expr;
+  ResetExpressionCounters();
+  expr -= LinearTerm(a, 3);
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -3}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr -= LinearTerm(a, -2);
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -1}}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr -= LinearTerm(b, 5);
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -1}, {b, -5}}, 0)));
+}
+
+TEST(LinearExpressionDeathTest, SubtractionAssignmentLinearTermOtherModel) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+
+  LinearExpression expr;
+  expr -= LinearTerm(a, 3);
+  EXPECT_DEATH(expr -= LinearTerm(b, 2), kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionTest, SubtractionAssignmentOtherExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  // First test with a default expression, not associated with any Model.
+  LinearExpression expr;
+  expr -= LinearExpression({{a, 2}, {b, 4}}, 2);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -2}, {b, -4}}, -2)));
+
+  // Then subtract another expression with variables from the same Model.
+  expr -= LinearExpression({{a, -3}, {c, 6}}, -4);
+  EXPECT_THAT(expr,
+              IsIdentical(LinearExpression({{a, 1}, {b, -4}, {c, -6}}, 2)));
+
+  // Then subtract another expression without variables (i.e. having null
+  // ModelStorage).
+  expr -= LinearExpression({}, 3);
+  EXPECT_THAT(expr,
+              IsIdentical(LinearExpression({{a, 1}, {b, -4}, {c, -6}}, -1)));
+}
+
+TEST(LinearExpressionTest, SubtractionAssignmentSelf) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression expr({{a, 2}, {b, 4}}, 2);
+  ResetExpressionCounters();
+  expr -= expr;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 0}, {b, 0}}, 0)));
+}
+
+TEST(LinearExpressionDeathTest, SubtractionAssignmentOtherExpressionAndModel) {
+  ModelStorage model_a;
+  const Variable a(&model_a, model_a.AddVariable("a"));
+
+  ModelStorage model_b;
+  const Variable b(&model_b, model_b.AddVariable("b"));
+
+  LinearExpression expr({{a, 1}}, 0);
+  const LinearExpression other({{b, 1}}, 0);
+  EXPECT_DEATH(expr -= other, kObjectsFromOtherModelStorage);
+}
+
+TEST(LinearExpressionTest, VariablePlusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = a + 3;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}}, 3)));
+}
+
+TEST(LinearExpressionTest, DoublePlusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 + a;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}}, 3)));
+}
+
+TEST(LinearExpressionTest, LinearTermPlusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 2 * a + 3;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}}, 3)));
+}
+
+TEST(LinearExpressionTest, DoublePlusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 + 2 * a;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}}, 3)));
+}
+
+TEST(LinearExpressionTest, LinearTermPlusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 * a + 2 * a;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 5}}, 0)));
+}
+
+TEST(LinearExpressionTest, LinearTermPlusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 * a + b;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}, {b, 1}}, 0)));
+}
+
+TEST(LinearExpressionTest, VariablePlusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = a + 2 * a;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}}, 0)));
+}
+
+TEST(LinearExpressionTest, VariablePlusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = a + b;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}, {b, 1}}, 0)));
+}
+
+TEST(LinearExpressionTest, ExpressionPlusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (2 * a + b + 1) + 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 1}}, 6)));
+}
+
+TEST(LinearExpressionTest, DoublePlusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 5 + (2 * a + b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 1}}, 6)));
+}
+
+TEST(LinearExpressionTest, ExpressionPlusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (2 * a + b + 1) + b;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 2}}, 1)));
+}
+
+TEST(LinearExpressionTest, VariablePlusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = b + (2 * a + b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 2}}, 1)));
+}
+
+TEST(LinearExpressionTest, ExpressionPlusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (2 * a + b + 1) + 3 * b;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 4}}, 1)));
+}
+
+TEST(LinearExpressionTest, LinearTermPlusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 * b + (2 * a + b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 4}}, 1)));
+}
+
+TEST(LinearExpressionTest, ExpressionPlusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (3 * b + a + 2) + (2 * a + b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}, {b, 4}}, 3)));
+}
+
+TEST(LinearExpressionTest, VariableMinusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = a - 3;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}}, -3)));
+}
+
+TEST(LinearExpressionTest, DoubleMinusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 - a;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -1}}, 3)));
+}
+
+TEST(LinearExpressionTest, LinearTermMinusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 2 * a - 3;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}}, -3)));
+}
+
+TEST(LinearExpressionTest, DoubleMinusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 - 2 * a;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -2}}, 3)));
+}
+
+TEST(LinearExpressionTest, LinearTermMinusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 * a - 2 * a;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}}, 0)));
+}
+
+TEST(LinearExpressionTest, LinearTermMinusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 * a - b;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}, {b, -1}}, 0)));
+}
+
+TEST(LinearExpressionTest, VariableMinusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = a - 2 * a;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -1}}, 0)));
+}
+
+TEST(LinearExpressionTest, VariableMinusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = a - b;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}, {b, -1}}, 0)));
+}
+
+TEST(LinearExpressionTest, ExpressionMinusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (2 * a + b + 1) - 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 1}}, -4)));
+}
+
+TEST(LinearExpressionTest, DoubleMinusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 5 - (2 * a + b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -2}, {b, -1}}, 4)));
+}
+
+TEST(LinearExpressionTest, ExpressionMinusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (2 * a + 2 * b + 1) - b;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, 1}}, 1)));
+}
+
+TEST(LinearExpressionTest, VariableMinusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = b - (2 * a + 2 * b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -2}, {b, -1}}, -1)));
+}
+
+TEST(LinearExpressionTest, ExpressionMinusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (2 * a + b + 1) - 3 * b;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 2}, {b, -2}}, 1)));
+}
+
+TEST(LinearExpressionTest, LinearTermMinusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 3 * b - (2 * a + b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -2}, {b, 2}}, -1)));
+}
+
+TEST(LinearExpressionTest, ExpressionMinusExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = (3 * b + a + 2) - (2 * a + b + 1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, -1}, {b, 2}}, 1)));
+}
+
+TEST(LinearExpressionTest, ExpressionTimesAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression expr({{a, 3}, {b, 2}}, -2);
+  ResetExpressionCounters();
+  expr *= 2;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 6}, {b, 4}}, -4)));
+}
+
+TEST(LinearExpressionTest, DoubleTimesExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = 2 * LinearExpression({{a, 3}, {b, 2}}, -2);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 6}, {b, 4}}, -4)));
+}
+
+TEST(LinearExpressionTest, ExpressionTimesDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = LinearExpression({{a, 3}, {b, 2}}, -2) * 2;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 6}, {b, 4}}, -4)));
+}
+
+TEST(LinearExpressionTest, ExpressionDividedByAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression expr({{a, 3}, {b, 2}}, -2);
+  ResetExpressionCounters();
+  expr /= 2;
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1.5}, {b, 1}}, -1)));
+}
+
+TEST(LinearExpressionTest, ExpressionDividedByDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LinearExpression expr = LinearExpression({{a, 3}, {b, 2}}, -2) / 2;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1.5}, {b, 1}}, -1)));
+}
+
+TEST(LinearExpressionTest, AddSumInts) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<int> to_add = {2, 7};
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}}, 14)));
+}
+
+TEST(LinearExpressionTest, AddSumDoubles) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<double> to_add({2.0, 7.0});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}}, 14)));
+}
+
+TEST(LinearExpressionTest, AddSumVariables) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<Variable> to_add({b, c, b});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}, {b, 2}, {c, 1}}, 5)));
+}
+
+TEST(LinearExpressionTest, AddSumLinearTerms) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<LinearTerm> to_add({2.0 * b, 1.0 * c, 4.0 * b});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}, {b, 6}, {c, 1}}, 5)));
+}
+
+TEST(LinearExpressionTest, AddSumLinearExpressions) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<LinearExpression> to_add({a + b, 4.0 * b - 1.0});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 4}, {b, 5}}, 4)));
+}
+
+TEST(LinearExpressionTest, Sum) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+  const std::vector<Variable> summand({a, b, c, b});
+  const auto expr = Sum(summand);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 1}, {b, 2}, {c, 1}}, 0)));
+}
+
+TEST(LinearExpressionTest, AddInnerProductIntInt) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<int> first = {2, 3, 4};
+  const std::vector<int> second = {1, -1, 10};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}}, 44)));
+}
+
+TEST(LinearExpressionTest, AddInnerProductDoubleDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<double> first = {2.0, 3.0, 4.0};
+  const std::vector<double> second = {1.0, -1.0, 10.0};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 3}}, 44)));
+}
+
+TEST(LinearExpressionTest, AddInnerProductDoubleVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<double> first = {2.0, 3.0, 4.0};
+  const std::vector<Variable> second = {a, b, a};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 9}, {b, 3}}, 5)));
+}
+
+TEST(LinearExpressionTest, AddInnerProductVariableInt) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<Variable> first = {a, b, a};
+  const std::vector<int> second = {2, 3, 4};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 9}, {b, 3}}, 5)));
+}
+
+TEST(LinearExpressionTest, AddInnerProductIntLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<int> first = {2, 3, 4};
+  const std::vector<LinearTerm> second = {2.0 * a, 4.0 * b, 1.0 * a};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 11}, {b, 12}}, 5)));
+}
+
+TEST(LinearExpressionTest, AddInnerProductDoubleLinearExpr) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  LinearExpression expr = 3.0 * a + 5.0;
+  const std::vector<LinearExpression> first = {3.0 * b + 1, a + b};
+  const std::vector<double> second = {-1.0, 2.0};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 5}, {b, -1}}, 4)));
+}
+
+TEST(LinearExpressionTest, InnerProduct) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const std::vector<Variable> first = {a, b, a};
+  const std::vector<double> second = {2.0, 3.0, 4.0};
+  const auto expr = InnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(LinearExpression({{a, 6}, {b, 3}}, 0)));
+}
+
+TEST(LinearExpressionDeathTest, AddInnerProductSizeMismatchLeftMore) {
+  const std::vector<double> left = {2.0, 3.0, 4.0};
+  const std::vector<double> right = {1.0, -1.0};
+  LinearExpression expr;
+  EXPECT_DEATH(expr.AddInnerProduct(left, right), "left had more");
+}
+
+TEST(LinearExpressionDeathTest, AddInnerProductSizeMismatchRightMore) {
+  const std::vector<double> left = {2.0, 3.0};
+  const std::vector<double> right = {1.0, -1.0, 10.0};
+  LinearExpression expr;
+  EXPECT_DEATH(expr.AddInnerProduct(left, right), "right had more");
+}
+
+TEST(LinearExpressionTest, ExpressionGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LowerBoundedLinearExpression comparison = 3 * a + b + 2 >= 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}, {b, 1}}, 2)));
+  EXPECT_EQ(comparison.lower_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, DoubleLesserEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const LowerBoundedLinearExpression comparison = 5 <= 3 * a + b + 2;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}, {b, 1}}, 2)));
+  EXPECT_EQ(comparison.lower_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, LinearTermGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LowerBoundedLinearExpression comparison = 3 * a >= 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}}, 0)));
+  EXPECT_EQ(comparison.lower_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, DoubleLesserEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LowerBoundedLinearExpression comparison = 5 <= 3 * a;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}}, 0)));
+  EXPECT_EQ(comparison.lower_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, VariableGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LowerBoundedLinearExpression comparison = a >= 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 1}}, 0)));
+  EXPECT_EQ(comparison.lower_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, DoubleLesserEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const LowerBoundedLinearExpression comparison = 5 <= a;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 1}}, 0)));
+  EXPECT_EQ(comparison.lower_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, ExpressionLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const UpperBoundedLinearExpression comparison = 3 * a + b + 2 <= 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}, {b, 1}}, 2)));
+  EXPECT_EQ(comparison.upper_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, DoubleGreaterEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const UpperBoundedLinearExpression comparison = 5 >= 3 * a + b + 2;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}, {b, 1}}, 2)));
+  EXPECT_EQ(comparison.upper_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, LinearTermLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const UpperBoundedLinearExpression comparison = 3 * a <= 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}}, 0)));
+  EXPECT_EQ(comparison.upper_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, DoubleGreaterEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const UpperBoundedLinearExpression comparison = 5 >= 3 * a;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 3}}, 0)));
+  EXPECT_EQ(comparison.upper_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, VariableLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const UpperBoundedLinearExpression comparison = a <= 5;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 1}}, 0)));
+  EXPECT_EQ(comparison.upper_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, DoubleGreaterEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const UpperBoundedLinearExpression comparison = 5 >= a;
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(LinearExpression({{a, 1}}, 0)));
+  EXPECT_EQ(comparison.upper_bound, 5.0);
+}
+
+TEST(LinearExpressionTest, LowerBoundedExpressionLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = (2 <= 2 * a + 3 * b + 5) <= 4;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -3.0, LinearTerms({{a, 2}, {b, 3}}), -1.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 5);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, DoubleLesserEqualExpressionLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 <= 2 * a + 3 * b + 5 <= 4;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -3.0, LinearTerms({{a, 2}, {b, 3}}), -1.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 5);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, DoubleGreaterEqualLowerBoundedExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 4 >= (2 * a + 3 * b + 5 >= 2);
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -3.0, LinearTerms({{a, 2}, {b, 3}}), -1.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 5);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, DoubleGreaterEqualExpressionGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 4 >= 2 * a + 3 * b + 5 >= 2;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -3.0, LinearTerms({{a, 2}, {b, 3}}), -1.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 5);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, DoubleLesserEqualUpperBoundedExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 <= (2 * a + 3 * b + 5 <= 4);
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -3.0, LinearTerms({{a, 2}, {b, 3}}), -1.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 5);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, UpperBoundedExpressionGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = (4 >= 2 * a + 3 * b + 5) >= 2;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -3.0, LinearTerms({{a, 2}, {b, 3}}), -1.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 5);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, ExpressionLesserEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 <= a + 3;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, 1}, {b, 3}}), -2.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 2);
+}
+
+TEST(LinearExpressionTest, ExpressionLesserEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 <= 2 * b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, 2}, {b, 1}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermLesserEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * b <= 2 * a + 3 * b + 5;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, 2}, {b, 1}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableLesserEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = b <= 2 * a + 3 * b + 5;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, 2}, {b, 2}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, ExpressionLesserEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 <= b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, 2}, {b, 2}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, ExpressionGreaterEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 >= a + 3;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -2.0, LinearTerms({{a, 1}, {b, 3}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 2);
+}
+
+TEST(LinearExpressionTest, ExpressionGreaterEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 >= 2 * b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, 2}, {b, 1}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermGreaterEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * b >= 2 * a + 3 * b + 5;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, 2}, {b, 1}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableGreaterEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = b >= 2 * a + 3 * b + 5;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, 2}, {b, 2}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, ExpressionGreaterEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 >= b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, 2}, {b, 2}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermLesserEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a <= 2 * b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, 2}, {b, -2}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableLesserEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = b <= 2 * a;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, -2}, {b, 1}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableLesserEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = b <= a;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, -1}, {b, 1}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermLesserEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a <= b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -kInf, LinearTerms({{a, 2}, {b, -1}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermGreaterEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a >= 2 * b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              0.0, LinearTerms({{a, 2}, {b, -2}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableGreaterEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = b >= 2 * a;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              0.0, LinearTerms({{a, -2}, {b, 1}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableGreaterEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = b >= a;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              0.0, LinearTerms({{a, -1}, {b, 1}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermGreaterEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a >= b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              0.0, LinearTerms({{a, 2}, {b, -1}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, ExpressionEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 == 3 * a + b + 2;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -3.0, LinearTerms({{a, -1}, {b, 2}}), -3.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 2);
+}
+
+TEST(LinearExpressionTest, ExpressionEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 == 3 * a;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, -1}, {b, 3}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 3 * a == 2 * a + 3 * b + 5;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, -1}, {b, 3}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, ExpressionEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 == a;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, 1}, {b, 3}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = a == 2 * a + 3 * b + 5;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -5.0, LinearTerms({{a, 1}, {b, 3}}), -5.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, ExpressionEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a + 3 * b + 5 == 3;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -2.0, LinearTerms({{a, 2}, {b, 3}}), -2.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, DoubleEqualExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 3 == 2 * a + 3 * b + 5;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              -2.0, LinearTerms({{a, 2}, {b, 3}}), -2.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a == 3 * a;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(0.0, LinearTerms({{a, -1}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a == a;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(0.0, LinearTerms({{a, 1}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = a == 2 * a;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(0.0, LinearTerms({{a, -1}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, LinearTermEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 2 * a == 3;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(3.0, LinearTerms({{a, 2}}), 3.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, DoubleEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 3 == 2 * a;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(3.0, LinearTerms({{a, 2}}), 3.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = a == b;
+  EXPECT_THAT(comparison, BoundedLinearExpressionEquiv(
+                              0.0, LinearTerms({{a, 1}, {b, -1}}), 0.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, VariableEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = a == 3;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(3.0, LinearTerms({{a, 1}}), 3.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(LinearExpressionTest, DoubleEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 3 == a;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(3.0, LinearTerms({{a, 1}}), 3.0));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(BoundedLinearExpressionTest, FromLowerBoundedExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = 3 <= a;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(3.0, LinearTerms({{a, 1}}), kInf));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(BoundedLinearExpressionTest, FromUpperBoundedExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedLinearExpression comparison = a <= 5;
+  EXPECT_THAT(comparison,
+              BoundedLinearExpressionEquiv(-kInf, LinearTerms({{a, 1}}), 5));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 1);
+}
+
+TEST(BoundedLinearExpressionTest, OutputStreaming) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  auto to_string = [](BoundedLinearExpression bounded_expression) {
+    std::ostringstream oss;
+    oss << bounded_expression;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(BoundedLinearExpression(LinearExpression(), -1, 2)),
+            "-1 ≤ 0 ≤ 2");
+  EXPECT_EQ(to_string(BoundedLinearExpression(LinearExpression({}, -1), -1, 2)),
+            "-1 ≤ -1 ≤ 2");
+  EXPECT_EQ(to_string(BoundedLinearExpression(
+                LinearExpression({{a, 1}, {b, 5}}, -1), -1, 2)),
+            "-1 ≤ a + 5*b - 1 ≤ 2");
+  EXPECT_EQ(to_string(BoundedLinearExpression(
+                LinearExpression({{a, 1}, {b, 5}}, 0), -1, 2)),
+            "-1 ≤ a + 5*b ≤ 2");
+  EXPECT_EQ(
+      to_string(BoundedLinearExpression(LinearExpression({a, 2}), -kInf, 2)),
+      "2*a ≤ 2");
+  EXPECT_EQ(
+      to_string(BoundedLinearExpression(LinearExpression({a, 2}), -1, kInf)),
+      "2*a ≥ -1");
+  EXPECT_EQ(to_string(BoundedLinearExpression(LinearExpression({a, 2}), 3, 3)),
+            "2*a = 3");
+  EXPECT_EQ(to_string(BoundedLinearExpression(LinearExpression({a, 2}),
+                                              kRoundTripTestNumber, kInf)),
+            absl::StrCat("2*a ≥ ", kRoundTripTestNumberStr));
+  EXPECT_EQ(to_string(BoundedLinearExpression(LinearExpression({a, 2}), -kInf,
+                                              kRoundTripTestNumber)),
+            absl::StrCat("2*a ≤ ", kRoundTripTestNumberStr));
+  EXPECT_EQ(to_string(BoundedLinearExpression(LinearExpression({a, 2}), 0.0,
+                                              kRoundTripTestNumber)),
+            absl::StrCat("0 ≤ 2*a ≤ ", kRoundTripTestNumberStr));
+  EXPECT_EQ(to_string(BoundedLinearExpression(LinearExpression({a, 2}),
+                                              kRoundTripTestNumber, 3000.0)),
+            absl::StrCat(kRoundTripTestNumberStr, " ≤ 2*a ≤ 3000"));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Quadratic tests
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// QuadraticTermKey
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(QuadraticTermKeyTest, Constructors) {
+  ModelStorage storage;
+  const VariableId u_id = storage.AddVariable();
+  const VariableId v_id = storage.AddVariable();
+
+  {
+    const QuadraticTermKey in_order_key(&storage, {u_id, v_id});
+    EXPECT_EQ(in_order_key.storage(), &storage);
+    EXPECT_EQ(in_order_key.typed_id(), QuadraticProductId(u_id, v_id));
+
+    const QuadraticTermKey out_of_order_key(&storage, {v_id, u_id});
+    EXPECT_EQ(in_order_key, in_order_key);
+  }
+
+  const Variable u(&storage, u_id);
+  const Variable v(&storage, v_id);
+  {
+    const QuadraticTermKey in_order_key(u, v);
+    EXPECT_EQ(in_order_key.storage(), &storage);
+    EXPECT_EQ(in_order_key.typed_id(), QuadraticProductId(u_id, v_id));
+
+    const QuadraticTermKey out_of_order_key(v, u);
+    EXPECT_EQ(in_order_key, in_order_key);
+  }
+}
+
+TEST(QuadraticTermKeyDeathTest, ConstructorChecksOnDifferentModels) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, storage.AddVariable("b"));
+
+  EXPECT_DEATH(QuadraticTermKey(a, b), internal::kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticTermKeyTest, Accessors) {
+  ModelStorage storage;
+  const VariableId u_id = storage.AddVariable();
+  const VariableId v_id = storage.AddVariable();
+
+  const QuadraticProductId id(u_id, v_id);
+  const QuadraticTermKey key(&storage, id);
+  EXPECT_EQ(key.storage(), &storage);
+  const ModelStorage& const_model = storage;
+  EXPECT_EQ(key.storage(), &const_model);
+  EXPECT_EQ(key.typed_id(), id);
+  EXPECT_EQ(key.first().typed_id(), u_id);
+  EXPECT_EQ(key.second().typed_id(), v_id);
+  EXPECT_EQ(key.first().storage(), &const_model);
+  EXPECT_EQ(key.second().storage(), &const_model);
+}
+
+TEST(QuadraticTermKeyTest, OutputStreaming) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable());
+
+  auto to_string = [](QuadraticTermKey k) {
+    std::ostringstream oss;
+    oss << k;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(QuadraticTermKey(a, a)), "(a, a)");
+  EXPECT_EQ(to_string(QuadraticTermKey(a, b)),
+            absl::StrCat("(a, __var#", b.id(), "__)"));
+}
+
+TEST(QuadraticTermKeyTest, EqualityComparison) {
+  ModelStorage storage;
+  const VariableId u_id = storage.AddVariable();
+  const VariableId v_id = storage.AddVariable();
+  const QuadraticProductId qp_id(u_id, v_id);
+  const QuadraticTermKey key(&storage, qp_id);
+  EXPECT_TRUE(key == QuadraticTermKey(&storage, qp_id));
+  EXPECT_FALSE(key != QuadraticTermKey(&storage, qp_id));
+  EXPECT_FALSE(key ==
+               QuadraticTermKey(&storage, QuadraticProductId(u_id, u_id)));
+  EXPECT_TRUE(key !=
+              QuadraticTermKey(&storage, QuadraticProductId(u_id, u_id)));
+
+  const ModelStorage other_storage;
+  EXPECT_FALSE(key == QuadraticTermKey(&other_storage, qp_id));
+  EXPECT_TRUE(key != QuadraticTermKey(&other_storage, qp_id));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// QuadraticTerm (no arithmetic)
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(QuadraticTermTest, FromVariablesAndDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  {
+    // Verify that the same variable can appear in both slots
+    const QuadraticTerm term(a, a, 1.2);
+    EXPECT_EQ(term.first_variable(), a);
+    EXPECT_EQ(term.second_variable(), a);
+    EXPECT_EQ(term.coefficient(), 1.2);
+  }
+  {
+    const QuadraticTerm term(b, a, 1.2);
+    EXPECT_EQ(term.first_variable(), b);
+    EXPECT_EQ(term.second_variable(), a);
+    EXPECT_EQ(term.coefficient(), 1.2);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// QuadraticExpression (no arithmetic)
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(QuadraticExpressionTest, DefaultValue) {
+  const QuadraticExpression expr;
+  EXPECT_EQ(expr.offset(), 0.0);
+  EXPECT_THAT(expr.linear_terms(), IsEmpty());
+  EXPECT_EQ(expr.storage(), nullptr);
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+}
+
+TEST(QuadraticExpressionTest, EmptyInitializerList) {
+  const QuadraticExpression expr({}, {}, 0.0);
+  EXPECT_EQ(expr.offset(), 0.0);
+  EXPECT_THAT(expr.linear_terms(), IsEmpty());
+  EXPECT_EQ(expr.storage(), nullptr);
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+}
+
+TEST(QuadraticExpressionTest, FromDouble) {
+  const QuadraticExpression expr = 4.0;
+
+  EXPECT_EQ(expr.offset(), 4.0);
+  EXPECT_THAT(expr.linear_terms(), IsEmpty());
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+  EXPECT_EQ(expr.storage(), nullptr);
+  EXPECT_THAT(expr.linear_terms(), IsEmpty());
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+}
+
+TEST(QuadraticExpressionTest, FromVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const QuadraticExpression expr = a;
+
+  EXPECT_EQ(expr.offset(), 0.0);
+  EXPECT_THAT(expr.linear_terms(), UnorderedElementsAre(Pair(a, 1.0)));
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+  EXPECT_EQ(expr.storage(), &storage);
+  EXPECT_THAT(expr.linear_terms(), UnorderedElementsAre(Pair(a, 1.0)));
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+}
+
+TEST(QuadraticExpressionTest, FromLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const QuadraticExpression expr = LinearTerm(a, 3.0);
+
+  EXPECT_EQ(expr.offset(), 0.0);
+  EXPECT_THAT(expr.linear_terms(), UnorderedElementsAre(Pair(a, 3.0)));
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+  EXPECT_EQ(expr.storage(), &storage);
+  EXPECT_THAT(expr.linear_terms(), UnorderedElementsAre(Pair(a, 3.0)));
+  EXPECT_THAT(expr.quadratic_terms(), IsEmpty());
+}
+
+TEST(QuadraticExpressionTest, FromLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  LinearExpression linear_expr({{a, 1.2}, {b, 1.3}}, 1.4);
+  ResetExpressionCounters();
+
+  const QuadraticExpression quadratic_expr = std::move(linear_expr);
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_THAT(quadratic_expr,
+              IsIdentical(QuadraticExpression({}, {{a, 1.2}, {b, 1.3}}, 1.4)));
+  // We attempt to test that the we successfully moved out of linear_expr. Since
+  // there is an implicit move constructor call, we can only test that the
+  // terms_ field is empty, but not that offset_ is set to zero as well.
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  EXPECT_THAT(linear_expr.terms(), IsEmpty());
+}
+
+TEST(QuadraticExpressionTest, FromQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  const QuadraticExpression expr = QuadraticTerm(a, a, 3.0);
+
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, a, 3}}, {}, 0)));
+  EXPECT_EQ(expr.storage(), &storage);
+  EXPECT_THAT(expr.linear_terms(), IsEmpty());
+  EXPECT_THAT(expr.quadratic_terms(),
+              UnorderedElementsAre(Pair(QuadraticTermKey(a, a), 3.0)));
+}
+
+TEST(QuadraticExpressionTest, TermsFromSameModelOk) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  const QuadraticExpression expr({{a, b, 1.2}, {c, a, 2.5}, {b, a, -1.1}},
+                                 {{a, 1.3}}, 1.2);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression(
+                        {{a, b, 1.2 - 1.1}, {a, c, 2.5}}, {{a, 1.3}}, 1.2)));
+  EXPECT_EQ(expr.storage(), &storage);
+}
+
+TEST(QuadraticExpressionDeathTest, TermsFromDifferentModelsFail) {
+  ModelStorage first_model;
+  const Variable a(&first_model, first_model.AddVariable("a"));
+
+  ModelStorage second_model;
+  const Variable b(&second_model, second_model.AddVariable("b"));
+  const Variable c(&second_model, second_model.AddVariable("c"));
+
+  EXPECT_DEATH(QuadraticExpression({}, {{a, 3.0}, {b, 5.0}}, 0.0),
+               kObjectsFromOtherModelStorage);
+  EXPECT_DEATH(QuadraticExpression({{a, b, 1.2}}, {}, 0.0),
+               kObjectsFromOtherModelStorage);
+  EXPECT_DEATH(QuadraticExpression({{a, a, 1.4}, {b, c, 1.3}}, {}, 0.0),
+               kObjectsFromOtherModelStorage);
+  EXPECT_DEATH(QuadraticExpression({{b, c, 1.3}}, {{a, 1.4}}, 0.0),
+               kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, ReassignDifferentModels) {
+  ModelStorage first_model;
+  const Variable a(&first_model, first_model.AddVariable("a"));
+  const Variable b(&first_model, first_model.AddVariable("b"));
+  const QuadraticExpression first_expr({{a, b, 1.0}}, {}, 5.7);
+
+  ModelStorage second_model;
+  const Variable c(&second_model, second_model.AddVariable("c"));
+  QuadraticExpression second_expr_to_overwrite({}, {{c, 1.2}}, 3.4);
+
+  second_expr_to_overwrite = first_expr;
+  EXPECT_THAT(second_expr_to_overwrite,
+              IsIdentical(QuadraticExpression({{a, b, 1.0}}, {}, 5.7)));
+  EXPECT_EQ(second_expr_to_overwrite.storage(), &first_model);
+}
+
+TEST(QuadraticExpressionTest, MoveConstruction) {
+  ModelStorage first_model;
+  const Variable a(&first_model, first_model.AddVariable("a"));
+  const Variable b(&first_model, first_model.AddVariable("b"));
+  QuadraticExpression first_expr({{a, b, 1.0}}, {{a, 3.0}}, 5.7);
+
+  const QuadraticExpression second_expr = std::move(first_expr);
+
+  EXPECT_THAT(second_expr,
+              IsIdentical(QuadraticExpression({{a, b, 1.0}}, {{a, 3.0}}, 5.7)));
+  EXPECT_EQ(second_expr.storage(), &first_model);
+
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  EXPECT_THAT(first_expr, IsIdentical(QuadraticExpression()));
+  EXPECT_EQ(first_expr.storage(), nullptr);
+}
+
+TEST(QuadraticExpressionTest, MoveAssignment) {
+  ModelStorage first_model;
+  const Variable a(&first_model, first_model.AddVariable("a"));
+  const Variable b(&first_model, first_model.AddVariable("b"));
+  QuadraticExpression first_expr({{a, b, 1.0}}, {{a, 3.0}}, 5.7);
+
+  ModelStorage second_model;
+  const Variable c(&second_model, second_model.AddVariable("c"));
+  QuadraticExpression second_expr_to_overwrite({}, {{c, 1.2}}, 3.4);
+
+  second_expr_to_overwrite = std::move(first_expr);
+  EXPECT_THAT(second_expr_to_overwrite,
+              IsIdentical(QuadraticExpression({{a, b, 1.0}}, {{a, 3.0}}, 5.7)));
+  EXPECT_EQ(second_expr_to_overwrite.storage(), &first_model);
+
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  EXPECT_THAT(first_expr, IsIdentical(QuadraticExpression()));
+  EXPECT_EQ(first_expr.storage(), nullptr);
+}
+
+TEST(QuadraticExpressionTest, EvaluateEmpty) {
+  const QuadraticExpression expr;
+  {
+    ModelStorage storage;
+    const Variable a(&storage, storage.AddVariable("a"));
+    const Variable b(&storage, storage.AddVariable("b"));
+    VariableMap<double> variable_values;
+    variable_values[a] = 10.0;
+    variable_values[b] = 11.0;
+    EXPECT_EQ(expr.Evaluate(variable_values), 0.0);
+    EXPECT_EQ(expr.EvaluateWithDefaultZero(variable_values), 0.0);
+  }
+  {
+    VariableMap<double> variable_values;
+    EXPECT_EQ(expr.Evaluate(variable_values), 0.0);
+    EXPECT_EQ(expr.EvaluateWithDefaultZero(variable_values), 0.0);
+  }
+}
+
+TEST(QuadraticExpressionTest, EvaluateOnlyLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticExpression expr({}, {{a, 1.2}}, 3.4);
+  {
+    VariableMap<double> variable_values;
+    variable_values[a] = 10.0;
+    variable_values[b] = 11.0;
+    EXPECT_THAT(expr.Evaluate(variable_values), 10 * 1.2 + 3.4);
+    EXPECT_THAT(expr.EvaluateWithDefaultZero(variable_values), 10 * 1.2 + 3.4);
+  }
+  {
+    VariableMap<double> variable_values;
+    EXPECT_THAT(expr.EvaluateWithDefaultZero(variable_values), 3.4);
+  }
+}
+
+TEST(QuadraticExpressionTest, SimpleEvaluate) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticExpression expr({{a, b, 1.0}}, {{a, 3.0}, {b, 5.0}}, 2.0);
+  VariableMap<double> variable_values;
+  variable_values[a] = 10.0;
+  variable_values[b] = 100.0;
+  EXPECT_THAT(expr.Evaluate(variable_values),
+              1.0 * 10.0 * 100.0 + 3.0 * 10.0 + 5.0 * 100.0 + 2.0);
+}
+
+TEST(QuadraticExpressionTest, SimpleEvaluateWithDefault) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticExpression expr({{a, a, 4.0}, {b, a, 1.0}},
+                                 {{b, 5.0}, {a, 3.0}}, 2.0);
+  VariableMap<double> variable_values;
+  variable_values[a] = 10.0;
+  EXPECT_THAT(expr.EvaluateWithDefaultZero(variable_values),
+              4.0 * 10.0 * 10.0 + 3.0 * 10.0 + 2.0);
+}
+
+TEST(QuadraticExpressionTest, StableEvaluateAndEvaluateWithDefault) {
+  // Here we test that the floating point sum of numbers is done in the sorted
+  // order of the variables ids and variables id pairs. To do so we rely on a
+  // specific floating point number sequence (obtained with a Python script
+  // doing random tries) which floating point sum changes depending on the order
+  // of operations:
+  //
+  // 56.66114901664141 + 76.288516611269 + 73.11902164661139 +
+  //   0.677336454040622 + 43.75820160525244 = 250.50422533381482
+  // 56.66114901664141 + 76.288516611269 + 73.11902164661139 +
+  //   43.75820160525244 + 0.677336454040622 = 250.50422533381484
+  // 56.66114901664141 + 76.288516611269 + 0.677336454040622 +
+  //   73.11902164661139 + 43.75820160525244 = 250.50422533381487
+  // 76.288516611269 + 0.677336454040622 + 73.11902164661139 +
+  //   43.75820160525244 + 56.66114901664141 = 250.5042253338149
+  //
+  // Here we will use the first value as the offset of the linear expression (to
+  // test that it always taken into account in the same order).
+  constexpr double kOffset = 56.66114901664141;
+  const std::vector<double> linear_coeffs = {
+      76.288516611269, 73.11902164661139, 0.677336454040622, 43.75820160525244};
+  const std::vector<double> quadratic_coeffs = {
+      76.288516611269, 0.677336454040622, 73.11902164661139, 43.75820160525244,
+      56.66114901664141};
+
+  ModelStorage storage;
+  std::vector<Variable> vars;
+  VariableMap<double> variable_values;
+  for (int i = 0; i < linear_coeffs.size(); ++i) {
+    vars.emplace_back(&storage, storage.AddVariable(absl::StrCat("v_", i)));
+    variable_values.try_emplace(vars.back(), 1.0);
+  }
+
+  QuadraticExpression expr = kOffset;
+  for (const int i : {3, 2, 0, 1}) {
+    expr += linear_coeffs[i] * vars[i];
+  }
+  const std::vector<std::pair<int, int>> quad_term_keys = {
+      {0, 0}, {0, 1}, {0, 2}, {1, 1}, {1, 2}};
+  for (const int i : {4, 0, 3, 1, 2}) {
+    const auto [v1, v2] = quad_term_keys[i];
+    expr += quadratic_coeffs[i] * vars[v1] * vars[v2];
+  }
+
+  // Expected value for the sum which is:
+  //   - offset first
+  //   - then all linear terms sums in the order of variables' indices
+  //   - then all quadratic terms sums in the order of variables' indices' pairs
+  double expected = kOffset;
+  for (const double v : linear_coeffs) {
+    expected += v;
+  }
+  for (const double v : quadratic_coeffs) {
+    expected += v;
+  }
+
+  // Test Evaluate();
+  {
+    const double got = expr.Evaluate(variable_values);
+    EXPECT_EQ(got, expected)
+        << "got: " << RoundTripDoubleFormat(got)
+        << " expected: " << RoundTripDoubleFormat(expected);
+  }
+
+  // Test EvaluateWithDefaultZero();
+  {
+    const double got = expr.EvaluateWithDefaultZero(variable_values);
+    EXPECT_EQ(got, expected)
+        << "got: " << RoundTripDoubleFormat(got)
+        << " expected: " << RoundTripDoubleFormat(expected);
+  }
+}
+
+TEST(QuadraticExpressionDeathTest, EvaluateMissingVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticExpression expr({{b, a, 1.0}}, {{b, 5.0}, {a, 3.0}}, 2.0);
+  VariableMap<double> variable_values;
+  variable_values[a] = 10.0;
+  EXPECT_DEATH(expr.Evaluate(variable_values), "");
+}
+
+TEST(QuadraticExpressionDeathTest, EvaluateDifferentModels) {
+  ModelStorage first_model;
+  const Variable a(&first_model, first_model.AddVariable("a"));
+  const Variable b(&first_model, first_model.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.0}}, {}, 2.0);
+
+  ModelStorage second_model;
+  const Variable c(&second_model, second_model.AddVariable("c"));
+  VariableMap<double> variable_values;
+  variable_values[c] = 100.0;
+
+  EXPECT_DEATH(expr.Evaluate(variable_values), kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, EvaluateWithDefaultZeroDifferentModels) {
+  ModelStorage first_model;
+  const Variable a(&first_model, first_model.AddVariable("a"));
+  const Variable b(&first_model, first_model.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.0}}, {}, 2.0);
+
+  ModelStorage second_model;
+  const Variable c(&second_model, second_model.AddVariable("c"));
+  VariableMap<double> variable_values;
+  variable_values[c] = 100.0;
+
+  EXPECT_EQ(expr.EvaluateWithDefaultZero(variable_values), 2.0);
+}
+
+TEST(QuadraticExpressionTest, OutputStreaming) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  auto to_string = [](QuadraticExpression expr) {
+    std::ostringstream oss;
+    oss << expr;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(QuadraticExpression()), "0");
+  EXPECT_EQ(to_string(QuadraticExpression({}, {}, -1)), "-1");
+  EXPECT_EQ(to_string(QuadraticExpression(
+                {}, {{a, 3}, {b, -5}, {a, -2}, {b, 0}}, -1)),
+            "a - 5*b - 1");
+  EXPECT_EQ(to_string(QuadraticExpression(
+                {{a, b, -1.2}, {a, a, -1.3}, {b, b, 1.0}}, {{a, 1.4}}, 1.5)),
+            "-1.3*a² - 1.2*a*b + b² + 1.4*a + 1.5");
+  EXPECT_EQ(
+      to_string(QuadraticExpression({{a, b, kRoundTripTestNumber}}, {}, 0.0)),
+      absl::StrCat(kRoundTripTestNumberStr, "*a*b"));
+  EXPECT_EQ(
+      to_string(QuadraticExpression({}, {{a, kRoundTripTestNumber}}, 0.0)),
+      absl::StrCat(kRoundTripTestNumberStr, "*a"));
+  EXPECT_EQ(to_string(QuadraticExpression({}, {}, kRoundTripTestNumber)),
+            kRoundTripTestNumberStr);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Arithmetic (non-member)
+////////////////////////////////////////////////////////////////////////////////
+
+// ----------------------------- Addition (+) ----------------------------------
+
+TEST(QuadraticExpressionTest, DoublePlusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = 3.4 + term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2}}, {}, 3.4)));
+}
+
+TEST(QuadraticExpressionTest, DoublePlusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = 7.8 + std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{b, 3.4}},
+                                                      7.8 + 5.6)));
+}
+
+TEST(QuadraticExpressionTest, VariablePlusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = b + term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{b, 1}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, VariablePlusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(b, c, 1.2);
+
+  EXPECT_DEATH(a + other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, VariablePlusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = b + std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}}, {{b, 1 * 3.4 + 1}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest, VariablePlusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{b, c, 1.2}}, {{b, 3.4}}, 5.6);
+
+  EXPECT_DEATH(a + other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearTermPlusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm first_term(a, 1.2);
+  const QuadraticTerm second_term(b, a, 3.4);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_term + second_term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 3.4}}, {{a, 1.2}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, LinearTermPlusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm term(a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearTerm other_term(c, 1.2);
+
+  EXPECT_DEATH(term + other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearTermPlusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm term(a, 1.2);
+  QuadraticExpression expr({{a, b, 3.4}}, {{b, 5.6}}, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term + std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 3.4}}, {{a, 1.2}, {b, 5.6}}, 7.8)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     LinearTermPlusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearTerm term(a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{b, c, 3.4}}, {{b, 5.6}}, 7.8);
+
+  EXPECT_DEATH(term + other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionPlusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  LinearExpression expr({{a, 1.2}}, 3.4);
+  const QuadraticTerm term(b, a, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) + term;
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 5.6}}, {{a, 1.2}}, 3.4)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     LinearExpressionPlusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearExpression expr({{a, 1.2}}, 3.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(c, c, 5.6);
+
+  EXPECT_DEATH(expr + other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionPlusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearExpression first_expr({{a, 1.2}}, 3.4);
+  QuadraticExpression second_expr({{a, b, 5.6}}, {{b, 7.8}}, 9.0);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_expr + std::move(second_expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 5.6}}, {{a, 1.2}, {b, 7.8}}, 3.4 + 9.0)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     LinearExpressionPlusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearExpression expr({{a, 1.2}}, 3.4);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{b, c, 5.6}}, {{b, 7.8}}, 9.0);
+
+  EXPECT_DEATH(expr + other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermPlusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term + 3.4;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2}}, {}, 3.4)));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermPlusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term + a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{a, 1}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticTermPlusVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable other_var(&other_storage, other_storage.AddVariable("c"));
+
+  EXPECT_DEATH(term + other_var, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermPlusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm first_term(a, b, 1.2);
+  const LinearTerm second_term(a, 3.4);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_term + second_term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{a, 3.4}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticTermPlusLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearTerm other_term({c, 3.4});
+
+  EXPECT_DEATH(term + other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermPlusLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  LinearExpression expr({{a, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term + std::move(expr);
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{a, 3.4}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticTermPlusLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearExpression other_expr({{c, 1.2}}, 1.3);
+
+  EXPECT_DEATH(term + other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermPlusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm first_term(a, b, 1.2);
+  const QuadraticTerm second_term(b, b, 3.4);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_term + second_term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}, {b, b, 3.4}}, {}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticTermPlusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(c, c, 1.2);
+
+  EXPECT_DEATH(term + other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermPlusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  QuadraticExpression expr({{a, b, 3.4}}, {{b, 5.6}}, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term + std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2 + 3.4}},
+                                                      {{b, 5.6}}, 7.8)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticTermPlusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const QuadraticTerm term(a, a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{b, c, 1.2}}, {{b, 1.3}}, 1.4);
+
+  EXPECT_DEATH(term + other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionPlusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) + 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{b, 3.4}},
+                                                      5.6 + 7.8)));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionPlusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) + a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}}, {{a, 1}, {b, 3.4}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticExpressionPlusVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable other_var(&other_storage, other_storage.AddVariable("c"));
+
+  EXPECT_DEATH(expr + other_var, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionPlusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  const LinearTerm term(a, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) + term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}}, {{a, 7.8}, {b, 3.4}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionPlusLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearTerm other_term(c, 7.8);
+
+  EXPECT_DEATH(expr + other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionPlusLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression first_expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  const LinearExpression second_expr({{a, 7.8}}, 9.0);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(first_expr) + second_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}}, {{a, 7.8}, {b, 3.4}}, 5.6 + 9)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionPlusLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearExpression other_expr({{c, 7.8}}, 9.0);
+
+  EXPECT_DEATH(expr + other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionPlusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  const QuadraticTerm term(a, a, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) + term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, a, 7.8}, {a, b, 1.2}}, {{b, 3.4}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionPlusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(c, c, 7.8);
+
+  EXPECT_DEATH(expr + other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionPlusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression first_expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  QuadraticExpression second_expr({{b, b, 7.8}}, {{a, 9.0}}, 1.3);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result =
+      std::move(first_expr) + std::move(second_expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}, {b, b, 7.8}},
+                                              {{a, 9}, {b, 3.4}}, 5.6 + 1.3)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionPlusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{c, c, 1.2}}, {{c, 3.4}}, 5.6);
+
+  EXPECT_DEATH(expr + other_expr, kObjectsFromOtherModelStorage);
+}
+
+// --------------------------- Subtraction (-) ---------------------------------
+
+TEST(QuadraticTermTest, QuadraticTermNegation) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term = QuadraticTerm(a, b, 1.2);
+
+  const QuadraticTerm result = -term;
+
+  EXPECT_EQ(result.first_variable(), a);
+  EXPECT_EQ(result.second_variable(), b);
+  EXPECT_EQ(result.coefficient(), -1.2);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionNegation) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = -std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, -1.2}},
+                                                      {{b, -3.4}}, -5.6)));
+}
+
+TEST(QuadraticExpressionTest, DoubleMinusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = 3.4 - term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, -1.2}}, {}, 3.4)));
+}
+
+TEST(QuadraticExpressionTest, DoubleMinusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = 7.8 - std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, -1.2}},
+                                                      {{b, -3.4}}, 7.8 - 5.6)));
+}
+
+TEST(QuadraticExpressionTest, VariableMinusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = b - term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, -1.2}}, {{b, 1}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, VariableMinusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(b, c, 1.2);
+
+  EXPECT_DEATH(a - other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, VariableMinusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = b - std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, -1.2}},
+                                                      {{b, 1 - 3.4}}, -5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest, VariableMinusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{b, c, 1.2}}, {{b, 1.3}}, 1.4);
+
+  EXPECT_DEATH(a - other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearTermMinusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm first_term(a, 1.2);
+  const QuadraticTerm second_term(b, a, 3.4);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_term - second_term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, -3.4}}, {{a, 1.2}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, LinearTermMinusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearTerm term(a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(b, c, 1.2);
+
+  EXPECT_DEATH(term - other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearTermMinusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm term(a, 1.2);
+  QuadraticExpression expr({{a, b, 3.4}}, {{b, 5.6}}, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term - std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, -3.4}}, {{a, 1.2}, {b, -5.6}}, -7.8)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     LinearTermMinusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearTerm term(a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{b, c, 1.2}}, {{b, 1.3}}, 1.4);
+
+  EXPECT_DEATH(term - other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionMinusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  LinearExpression expr({{a, 1.2}}, 3.4);
+  const QuadraticTerm term(b, a, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) - term;
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, -5.6}},
+                                                      {{a, 1.2}}, 3.4)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     LinearExpressionMinusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearExpression expr({{a, 1.2}}, 3.4);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(b, c, 5.6);
+
+  EXPECT_DEATH(expr - other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionMinusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearExpression first_expr({{a, 1.2}}, 3.4);
+  QuadraticExpression second_expr({{a, b, 5.6}}, {{b, 7.8}}, 9.0);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_expr - std::move(second_expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, -5.6}}, {{a, 1.2}, {b, -7.8}}, 3.4 - 9.0)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     LinearExpressionMinusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearExpression expr({{a, 1.2}}, 3.4);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{b, c, 1.2}}, {{b, 1.3}}, 1.4);
+
+  EXPECT_DEATH(expr - other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermMinusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term - 3.4;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}}, {}, -3.4)));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermMinusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term - a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{a, -1}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticTermMinusVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable other_var(&other_storage, other_storage.AddVariable("c"));
+
+  EXPECT_DEATH(term - other_var, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermMinusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm first_term(a, b, 1.2);
+  const LinearTerm second_term(a, 3.4);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_term - second_term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{a, -3.4}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticTermMinusLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearTerm other_term({c, 3.4});
+
+  EXPECT_DEATH(term - other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermMinusLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  LinearExpression expr({{a, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term - std::move(expr);
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2}},
+                                                      {{a, -3.4}}, -5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticTermMinusLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearExpression other_expr({{c, 1.2}}, 1.3);
+
+  EXPECT_DEATH(term - other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermMinusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm first_term(a, b, 1.2);
+  const QuadraticTerm second_term(b, b, 3.4);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = first_term - second_term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}, {b, b, -3.4}}, {}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticTermMinusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(c, c, 1.2);
+
+  EXPECT_DEATH(term - other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermMinusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+  QuadraticExpression expr({{a, b, 3.4}}, {{b, 5.6}}, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = term - std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2 - 3.4}},
+                                                      {{b, -5.6}}, -7.8)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticTermMinusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{c, c, 1.2}}, {{c, 1.3}}, 1.4);
+
+  EXPECT_DEATH(term - other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionMinusDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) - 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{b, 3.4}},
+                                                      5.6 - 7.8)));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionMinusVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) - a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}}, {{a, -1}, {b, 3.4}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest, QuadraticExpressionMinusVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable other_var(&other_storage, other_storage.AddVariable("c"));
+
+  EXPECT_DEATH(expr - other_var, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionMinusLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  const LinearTerm term(a, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) - term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}}, {{a, -7.8}, {b, 3.4}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionMinusLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearTerm other_term(c, 7.8);
+
+  EXPECT_DEATH(expr - other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionMinusLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression first_expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  const LinearExpression second_expr({{a, 7.8}}, 9.0);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(first_expr) - second_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2}}, {{a, -7.8}, {b, 3.4}}, 5.6 - 9)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionMinusLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearExpression other_expr({{c, 7.8}}, 9.0);
+
+  EXPECT_DEATH(expr - other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionMinusQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  const QuadraticTerm term(a, a, 7.8);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) - term;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, a, -7.8}, {a, b, 1.2}}, {{b, 3.4}}, 5.6)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionMinusQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(c, c, 7.8);
+
+  EXPECT_DEATH(expr - other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionMinusQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression first_expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  QuadraticExpression second_expr({{b, b, 7.8}}, {{a, 9.0}}, 1.3);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result =
+      std::move(first_expr) - std::move(second_expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result,
+              IsIdentical(QuadraticExpression({{a, b, 1.2}, {b, b, -7.8}},
+                                              {{a, -9}, {b, 3.4}}, 5.6 - 1.3)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     QuadraticExpressionMinusQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_expr({{c, c, 1.2}}, {{c, 3.4}}, 5.6);
+
+  EXPECT_DEATH(expr - other_expr, kObjectsFromOtherModelStorage);
+}
+
+// ---------------------------- Multiplication (*) -----------------------------
+
+TEST(QuadraticTermTest, DoubleTimesQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  const QuadraticTerm result = 3.4 * term;
+
+  EXPECT_EQ(result.first_variable(), a);
+  EXPECT_EQ(result.second_variable(), b);
+  EXPECT_THAT(result.coefficient(), 3.4 * 1.2);
+}
+
+TEST(QuadraticExpressionTest, DoubleTimesQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = 7.8 * std::move(expr);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 7.8 * 1.2}}, {{b, 7.8 * 3.4}}, 7.8 * 5.6)));
+}
+
+TEST(QuadraticTermTest, VariableTimesVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm result = a * b;
+
+  EXPECT_EQ(result.coefficient(), 1.0);
+  EXPECT_EQ(result.first_variable(), a);
+  EXPECT_EQ(result.second_variable(), b);
+}
+
+TEST(QuadraticTermDeathTest, VariableTimesVariableOtherModel) {
+  ModelStorage storage;
+  const Variable var(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable other_var(&other_storage, other_storage.AddVariable("c"));
+
+  EXPECT_DEATH(var * other_var, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticTermTest, VariableTimesLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm term(a, 1.2);
+
+  const QuadraticTerm result = b * term;
+
+  EXPECT_EQ(result.coefficient(), 1.2);
+  EXPECT_EQ(result.first_variable(), b);
+  EXPECT_EQ(result.second_variable(), a);
+}
+
+TEST(QuadraticTermDeathTest, VariableTimesLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const LinearTerm other_term(b, 1.2);
+
+  EXPECT_DEATH(a * other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, VariableTimesLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  {
+    const LinearExpression expr({{a, 1.2}, {b, 3.4}}, 5.6);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result = a * expr;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                            {{a, a, 1.2}, {a, b, 3.4}}, {{a, 5.6}}, 0)));
+  }
+
+  // Now we test that we do not introduce extra terms if there is a zero offset.
+  {
+    const LinearExpression expr_no_offset({{a, 1.2}, {b, 3.4}}, 0.0);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result_no_offset = a * expr_no_offset;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result_no_offset, IsIdentical(QuadraticExpression(
+                                      {{a, a, 1.2}, {a, b, 3.4}}, {}, 0)));
+  }
+}
+
+TEST(QuadraticExpressionDeathTest, VariableTimesLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const LinearExpression other_expr({{b, 1.2}}, 3.4);
+
+  EXPECT_DEATH(a * other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticTermTest, LinearTermTimesVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm term = LinearTerm(a, 1.2);
+
+  const QuadraticTerm result = term * b;
+
+  EXPECT_EQ(result.coefficient(), 1.2);
+  EXPECT_EQ(result.first_variable(), a);
+  EXPECT_EQ(result.second_variable(), b);
+}
+
+TEST(QuadraticTermDeathTest, LinearTermTimesVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearTerm term = LinearTerm(a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable other_var(&other_storage,
+                           other_storage.AddVariable("other_var"));
+
+  EXPECT_DEATH(term * other_var, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticTermTest, LinearTermTimesLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm first_term(a, 1.2);
+  const LinearTerm second_term(b, 3.4);
+
+  const QuadraticTerm result = first_term * second_term;
+
+  EXPECT_THAT(result.coefficient(), 1.2 * 3.4);
+  EXPECT_EQ(result.first_variable(), a);
+  EXPECT_EQ(result.second_variable(), b);
+}
+
+TEST(QuadraticTermDeathTest, LinearTermTimesLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearTerm term(a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const LinearTerm other_term(b, 1.2);
+
+  EXPECT_DEATH(term * other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearTermTimesLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm term(a, 1.2);
+  {
+    const LinearExpression expr({{a, 3.4}, {b, 5.6}}, 7.8);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result = term * expr;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                            {{a, a, 1.2 * 3.4}, {a, b, 1.2 * 5.6}},
+                            {{a, 1.2 * 7.8}}, 0)));
+  }
+
+  // Now we test that we do not introduce extra terms if there is a zero offset.
+  {
+    const LinearExpression expr_no_offset({{a, 3.4}, {b, 5.6}}, 0.0);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result_no_offset = term * expr_no_offset;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result_no_offset,
+                IsIdentical(QuadraticExpression(
+                    {{a, a, 1.2 * 3.4}, {a, b, 1.2 * 5.6}}, {}, 0)));
+  }
+}
+
+TEST(QuadraticExpressionDeathTest, LinearTermTimesLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearTerm term(a, 1.2);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const LinearExpression other_expr({{b, 3.4}}, 5.6);
+
+  EXPECT_DEATH(term * other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionTimesVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  {
+    const LinearExpression expr({{a, 1.2}, {b, 3.4}}, 5.6);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result = expr * a;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                            {{a, a, 1.2}, {a, b, 3.4}}, {{a, 5.6}}, 0)));
+  }
+
+  // Now we test that we do not introduce extra terms if there is a zero offset.
+  {
+    const LinearExpression expr_no_offset({{a, 1.2}, {b, 3.4}}, 0.0);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result_no_offset = expr_no_offset * a;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result_no_offset, IsIdentical(QuadraticExpression(
+                                      {{a, a, 1.2}, {a, b, 3.4}}, {}, 0)));
+  }
+}
+
+TEST(QuadraticExpressionDeathTest, LinearExpressionTimesVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearExpression expr({{a, 1.2}}, 3.4);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+
+  EXPECT_DEATH(expr * b, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionTimesLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const LinearTerm term(a, 7.8);
+  {
+    const LinearExpression expr({{a, 1.2}, {b, 3.4}}, 5.6);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result = expr * term;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                            {{a, a, 1.2 * 7.8}, {a, b, 3.4 * 7.8}},
+                            {{a, 5.6 * 7.8}}, 0)));
+  }
+
+  // Now we test that we do not introduce extra terms if there is a zero offset.
+  {
+    const LinearExpression expr_no_offset({{a, 1.2}, {b, 3.4}}, 0.0);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result_no_offset = expr_no_offset * term;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result_no_offset,
+                IsIdentical(QuadraticExpression(
+                    {{a, a, 1.2 * 7.8}, {a, b, 3.4 * 7.8}}, {}, 0)));
+  }
+}
+
+TEST(QuadraticExpressionDeathTest, LinearExpressionTimesLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearExpression expr({{a, 1.2}}, 3.4);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const LinearTerm other_term(b, 5.6);
+
+  EXPECT_DEATH(expr * other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionTimesLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  {
+    const LinearExpression expr({{a, 1.2}, {b, 3.4}}, 5.6);
+    const LinearExpression other_expr({{a, 7.8}}, 9.0);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result = expr * other_expr;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(result,
+                IsIdentical(QuadraticExpression(
+                    {{a, a, 1.2 * 7.8}, {a, b, 3.4 * 7.8}},
+                    {{a, 1.2 * 9 + 5.6 * 7.8}, {b, 3.4 * 9}}, 5.6 * 9)));
+  }
+
+  // Now we test that we do not introduce extra terms if there is a zero offset
+  // from the left-hand-side expression.
+  {
+    const LinearExpression expr_no_offset({{a, 1.2}, {b, 3.4}}, 0.0);
+    const LinearExpression other_expr({{a, 7.8}}, 9.0);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result_no_lhs_offset =
+        expr_no_offset * other_expr;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(
+        result_no_lhs_offset,
+        IsIdentical(QuadraticExpression({{a, a, 1.2 * 7.8}, {a, b, 3.4 * 7.8}},
+                                        {{a, 1.2 * 9}, {b, 3.4 * 9}}, 0)));
+  }
+  // Now we test that we do not introduce extra terms if there is a zero offset
+  // from the right-hand-side expression.
+  {
+    const LinearExpression expr({{a, 1.2}, {b, 3.4}}, 5.6);
+    const LinearExpression other_expr_no_offset({{a, 7.8}}, 0.0);
+    ResetExpressionCounters();
+
+    const QuadraticExpression result_no_rhs_offset =
+        expr * other_expr_no_offset;
+
+    EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+    EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+    EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+    EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+    EXPECT_THAT(
+        result_no_rhs_offset,
+        IsIdentical(QuadraticExpression({{a, a, 1.2 * 7.8}, {a, b, 3.4 * 7.8}},
+                                        {{a, 5.6 * 7.8}}, 0)));
+  }
+}
+
+TEST(QuadraticExpressionDeathTest,
+     LinearExpressionTimesLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const LinearExpression expr({{a, 1.2}}, 3.4);
+
+  ModelStorage other_storage;
+  const Variable b(&other_storage, other_storage.AddVariable("b"));
+  const LinearExpression other_expr({{b, 5.6}}, 7.8);
+
+  EXPECT_DEATH(expr * other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticTermTest, QuadraticTermTimesDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  const QuadraticTerm result = term * 3.4;
+
+  EXPECT_THAT(result.coefficient(), 1.2 * 3.4);
+  EXPECT_EQ(result.first_variable(), a);
+  EXPECT_EQ(result.second_variable(), b);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionTimesDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) * 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2 * 7.8}}, {{b, 3.4 * 7.8}}, 5.6 * 7.8)));
+}
+
+// ------------------------------- Division (/) --------------------------------
+// 1 QuadraticTerm, 1 QuadraticExpression
+
+TEST(QuadraticTermTest, QuadraticTermDividedByDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const QuadraticTerm term(a, b, 1.2);
+
+  const QuadraticTerm result = term / 3.4;
+
+  EXPECT_THAT(result.coefficient(), 1.2 / 3.4);
+  EXPECT_EQ(result.first_variable(), a);
+  EXPECT_EQ(result.second_variable(), b);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionDividedByDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  const QuadraticExpression result = std::move(expr) / 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_THAT(result, IsIdentical(QuadraticExpression(
+                          {{a, b, 1.2 / 7.8}}, {{b, 3.4 / 7.8}}, 5.6 / 7.8)));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Arithmetic (assignment operators)
+////////////////////////////////////////////////////////////////////////////////
+
+// ----------------------------- Addition (+) ----------------------------------
+
+TEST(QuadraticExpressionTest, AdditionAssignmentDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  expr += 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{b, 3.4}},
+                                                    5.6 + 7.8)));
+}
+
+TEST(QuadraticExpressionTest, AdditionAssignmentVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  ResetExpressionCounters();
+
+  expr += a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 1}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr += a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 2}}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr += b;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 2}, {b, 1}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, AdditionAssignmentVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable other_var(&other_storage,
+                           other_storage.AddVariable("other_var"));
+
+  EXPECT_DEATH(expr += other_var, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, AdditionAssignmentLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  ResetExpressionCounters();
+
+  expr += LinearTerm(a, 3);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 3}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr += LinearTerm(a, -2);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 1}}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr += LinearTerm(b, -5);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 1}, {b, -5}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, AdditionAssignmentLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearTerm other_term(c, 1.0);
+
+  EXPECT_DEATH(expr += other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, AdditionAssignmentLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  const LinearExpression another_expr({{a, 2}, {b, 4}}, 2);
+  ResetExpressionCounters();
+
+  expr += another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 2}, {b, 4}}, 2)));
+
+  // Then add another expression with variables from the same ModelStorage.
+  const LinearExpression yet_another_expr({{a, -3}, {b, 6}}, -4);
+  ResetExpressionCounters();
+
+  expr += yet_another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(
+      expr, IsIdentical(QuadraticExpression({}, {{a, 2 - 3}, {b, 4 + 6}}, -2)));
+
+  // Then add another expression without variables (i.e. having null
+  // ModelStorage).
+  const LinearExpression no_vars_expr({}, 3);
+  ResetExpressionCounters();
+
+  expr += no_vars_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(
+      expr, IsIdentical(QuadraticExpression({}, {{a, 2 - 3}, {b, 4 + 6}}, 1)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     AdditionAssignmentLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearExpression other_expr({{c, 1.0}}, 2.0);
+
+  EXPECT_DEATH(expr += other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, AdditionAssignmentQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  ResetExpressionCounters();
+
+  expr += QuadraticTerm(a, b, 3);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, b, 3}}, {}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr += QuadraticTerm(a, a, -2);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({{a, a, -2}, {a, b, 3}}, {}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr += QuadraticTerm(a, b, -4);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(
+      expr, IsIdentical(QuadraticExpression({{a, a, -2}, {a, b, -1}}, {}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, AdditionAssignmentQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(c, c, 1.2);
+
+  EXPECT_DEATH(expr += other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, AdditionAssignmentQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  const QuadraticExpression another_expr({{a, c, 2.4}}, {{a, 2}, {b, 4}}, 2);
+  ResetExpressionCounters();
+
+  expr += another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, c, 2.4}},
+                                                    {{a, 2}, {b, 4}}, 2)));
+
+  // Then add another expression with variables from the same ModelStorage.
+  const QuadraticExpression yet_another_expr({{c, b, 1.1}}, {{a, -3}, {c, 6}},
+                                             -4);
+  ResetExpressionCounters();
+
+  expr += yet_another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({{a, c, 2.4}, {b, c, 1.1}},
+                                              {{a, -1}, {b, 4}, {c, 6}}, -2)));
+
+  // Then add another expression without variables (i.e. having null
+  // ModelStorage).
+  const QuadraticExpression no_vars_expr({}, {}, 3);
+  ResetExpressionCounters();
+
+  expr += no_vars_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({{a, c, 2.4}, {b, c, 1.1}},
+                                              {{a, -1}, {b, 4}, {c, 6}}, 1)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     AdditionAssignmentQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_term({{c, c, 1.2}}, {{c, 3.4}}, 5.6);
+
+  EXPECT_DEATH(expr += other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, AdditionAssignmentSelf) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({}, {{a, 2}, {b, 4}}, 2.0);
+  ResetExpressionCounters();
+
+  expr += expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, 4}, {b, 8}}, 4)));
+}
+
+// --------------------------- Subtraction (-) ---------------------------------
+
+TEST(QuadraticExpressionTest, SubtractionAssignmentDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  expr -= 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, b, 1.2}}, {{b, 3.4}},
+                                                    5.6 - 7.8)));
+}
+
+TEST(QuadraticExpressionTest, SubtractionAssignmentVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  ResetExpressionCounters();
+
+  expr -= a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, -1}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr -= a;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, -2}}, 0)));
+
+  // Subtract another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr -= b;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({}, {{a, -2}, {b, -1}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, SubtractionAssignmentVariableOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+
+  EXPECT_DEATH(expr -= c, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, SubtractionAssignmentLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  ResetExpressionCounters();
+
+  expr -= LinearTerm(a, 3);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, -3}}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // subtracting the same variable.
+  ResetExpressionCounters();
+  expr -= LinearTerm(a, -2);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, -1}}, 0)));
+
+  // Subtract another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr -= LinearTerm(b, -5);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({}, {{a, -1}, {b, 5}}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest, SubtractionAssignmentLinearTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearTerm other_term(c, 1.0);
+
+  EXPECT_DEATH(expr -= other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, SubtractionAssignmentLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  const LinearExpression another_expr({{a, 2}, {b, 4}}, 2);
+  ResetExpressionCounters();
+
+  expr -= another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({}, {{a, -2}, {b, -4}}, -2)));
+
+  // Then add another expression with variables from the same ModelStorage.
+  const LinearExpression yet_another_expr({{a, -3}, {b, 6}}, -4);
+  ResetExpressionCounters();
+
+  expr -= yet_another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({}, {{a, 1}, {b, -10}}, 2)));
+
+  // Then subtract another expression without variables (i.e. having null
+  // ModelStorage).
+  const LinearExpression no_vars_expr({}, 3);
+  ResetExpressionCounters();
+
+  expr -= no_vars_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({}, {{a, 1}, {b, -10}}, -1)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     SubtractionAssignmentLinearExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const LinearExpression other_expr({{c, 1.0}}, 2.0);
+
+  EXPECT_DEATH(expr -= other_expr, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, SubtractionAssignmentQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  ResetExpressionCounters();
+
+  expr -= QuadraticTerm(a, b, 3);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, b, -3}}, {}, 0)));
+
+  // Reuse the previous expression now connected to a ModelStorage to test
+  // adding the same variable.
+  ResetExpressionCounters();
+  expr -= QuadraticTerm(a, a, -2);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({{a, a, 2}, {a, b, -3}}, {}, 0)));
+
+  // Add another variable from the same ModelStorage.
+  ResetExpressionCounters();
+  expr -= QuadraticTerm(a, b, -4);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({{a, a, 2}, {a, b, 1}}, {}, 0)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     SubtractionAssignmentQuadraticTermOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticTerm other_term(c, c, 1.2);
+
+  EXPECT_DEATH(expr -= other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, SubtractionAssignmentQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  // First test with a default expression, not associated with any ModelStorage.
+  QuadraticExpression expr;
+  const QuadraticExpression another_expr({{a, c, 2.4}}, {{a, 2}, {b, 4}}, 2);
+  ResetExpressionCounters();
+
+  expr -= another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, c, -2.4}},
+                                                    {{a, -2}, {b, -4}}, -2)));
+
+  // Then add another expression with variables from the same ModelStorage.
+  QuadraticExpression yet_another_expr({{c, b, 1.1}}, {{a, -3}, {c, 6}}, -4);
+  ResetExpressionCounters();
+
+  expr -= yet_another_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({{a, c, -2.4}, {b, c, -1.1}},
+                                              {{a, 1}, {b, -4}, {c, -6}}, 2)));
+
+  // Then add another expression without variables (i.e. having null
+  // ModelStorage).
+  const QuadraticExpression no_vars_expr({}, {}, 3);
+  ResetExpressionCounters();
+
+  expr -= no_vars_expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr,
+              IsIdentical(QuadraticExpression({{a, c, -2.4}, {b, c, -1.1}},
+                                              {{a, 1}, {b, -4}, {c, -6}}, -1)));
+}
+
+TEST(QuadraticExpressionDeathTest,
+     SubtractionAssignmentQuadraticExpressionOtherModel) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 1.3}}, 1.4);
+
+  ModelStorage other_storage;
+  const Variable c(&other_storage, other_storage.AddVariable("c"));
+  const QuadraticExpression other_term({{c, c, 1.2}}, {{c, 3.4}}, 5.6);
+
+  EXPECT_DEATH(expr -= other_term, kObjectsFromOtherModelStorage);
+}
+
+TEST(QuadraticExpressionTest, SubtractionAssignmentSelf) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  expr -= expr;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression({{a, b, 1.2 - 1.2}},
+                                                    {{b, 3.4 - 3.4}}, 0)));
+}
+
+// ---------------------------- Multiplication (*) -----------------------------
+
+TEST(QuadraticTermTest, QuadraticTermTimesDoubleAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticTerm term = QuadraticTerm(a, b, 1.2);
+
+  term *= 2.0;
+
+  EXPECT_EQ(term.first_variable(), a);
+  EXPECT_EQ(term.second_variable(), b);
+  EXPECT_EQ(term.coefficient(), 2.4);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionTimesDoubleAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  expr *= 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression(
+                        {{a, b, 1.2 * 7.8}}, {{b, 3.4 * 7.8}}, 5.6 * 7.8)));
+}
+
+// ------------------------------- Division (/) --------------------------------
+
+TEST(QuadraticTermTest, QuadraticTermDividedByDoubleAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticTerm term = QuadraticTerm(a, b, 1.2);
+
+  term /= 2.0;
+
+  EXPECT_EQ(term.first_variable(), a);
+  EXPECT_EQ(term.second_variable(), b);
+  EXPECT_EQ(term.coefficient(), 0.6);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionDividedByDoubleAssignment) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr({{a, b, 1.2}}, {{b, 3.4}}, 5.6);
+  ResetExpressionCounters();
+
+  expr /= 7.8;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_THAT(expr, IsIdentical(QuadraticExpression(
+                        {{a, b, 1.2 / 7.8}}, {{b, 3.4 / 7.8}}, 5.6 / 7.8)));
+}
+
+TEST(QuadraticExpressionTest, AddSumInts) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<int> to_add = {2, 7};
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 3 * a + 14));
+}
+
+TEST(QuadraticExpressionTest, AddSumDoubles) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<double> to_add({2.0, 7.0});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 3 * a + 14));
+}
+
+TEST(QuadraticExpressionTest, AddSumVariables) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<Variable> to_add({b, c, b});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 3 * a + 2 * b + c + 5));
+}
+
+TEST(QuadraticExpressionTest, AddSumLinearTerms) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const Variable c(&storage, storage.AddVariable("c"));
+
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<LinearTerm> to_add({2.0 * b, 1.0 * c, 4.0 * b});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 3 * a + 6 * b + c + 5));
+}
+
+TEST(QuadraticExpressionTest, AddSumLinearExpressions) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<LinearExpression> to_add({a + b, 4.0 * b - 1.0});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 4 * a + 5 * b + 4));
+}
+
+TEST(QuadraticExpressionTest, AddSumQuadraticTerms) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<QuadraticTerm> to_add({a * a, 2 * a * b});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(3 * a * a + 2 * a * b + 3 * a + 5));
+}
+
+TEST(QuadraticExpressionTest, AddSumQuadraticExpressions) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<QuadraticExpression> to_add(
+      {a * a - 1, 2 * a * b + 3 * b * b + 2});
+  expr.AddSum(to_add);
+  EXPECT_THAT(expr, IsIdentical(3 * a * a + 2 * a * b + 3 * b * b + 3 * a + 6));
+}
+
+TEST(QuadraticExpressionTest, Sum) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const std::vector<QuadraticExpression> summand(
+      {a * a, 2 * a * b + 3 * b + 4, 5 * b * a + 6 * b + 7});
+  EXPECT_THAT(QuadraticExpression::Sum(summand),
+              IsIdentical(a * a + 7 * a * b + 9 * b + 11));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductIntInt) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<int> first = {2, 3, 4};
+  const std::vector<int> second = {1, -1, 10};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 3 * a + 44));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductDoubleDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<double> first = {2.0, 3.0, 4.0};
+  const std::vector<double> second = {1.0, -1.0, 10.0};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 3 * a + 44));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductDoubleVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<double> first = {2.0, 3.0, 4.0};
+  const std::vector<Variable> second = {a, b, a};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 9 * a + 3 * b + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductIntLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<int> first = {2, 3, 4};
+  const std::vector<LinearTerm> second = {2.0 * a, 4.0 * b, 1.0 * a};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 11 * a + 12 * b + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductDoubleLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<double> first = {-1.0, 2.0};
+  const std::vector<LinearExpression> second = {3.0 * b + 1, a + b};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 5 * a - b + 4));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductDoubleQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<double> first = {-1.0, 2.0};
+  const std::vector<QuadraticTerm> second = {3.0 * a * a, 4 * a * b};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(-a * a + 8 * a * b + 3 * a + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductDoubleQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<double> first = {-1.0, 2.0};
+  const std::vector<QuadraticExpression> second = {3.0 * a * b + 1,
+                                                   4 * a * a + b};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(10 * a * a - 3 * a * b + 3 * a + 2 * b + 4));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductVariableVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<Variable> first = {a, b, a};
+  const std::vector<Variable> second = {a, a, b};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(3 * a * a + 2 * a * b + 3 * a + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductVariableLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<Variable> first = {a, b, a};
+  const std::vector<LinearTerm> second = {2 * a, 3 * a, 4 * b};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(4 * a * a + 7 * a * b + 3 * a + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductVariableLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<Variable> first = {a, b, a};
+  const std::vector<LinearExpression> second = {2 * a + 3, 4 * a + 5 * b, 6};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr,
+              IsIdentical(4 * a * a + 4 * a * b + 5 * b * b + 12 * a + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductLinearTermLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<LinearTerm> first = {1 * a, 2 * a, 3 * b};
+  const std::vector<LinearTerm> second = {1 * a, 2 * b, 3 * b};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(3 * a * a + 4 * a * b + 9 * b * b + 3 * a + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductLinearTermLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<LinearTerm> first = {1 * a, 2 * b, 3 * a};
+  const std::vector<LinearExpression> second = {2 * a + 3, 4 * a + 5 * b, 6};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr,
+              IsIdentical(4 * a * a + 8 * a * b + 10 * b * b + 24 * a + 5));
+}
+
+TEST(QuadraticExpressionTest, AddInnerProductLinearExpressionLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  QuadraticExpression expr = 2.0 * a * a + 3.0 * a + 5.0;
+  const std::vector<LinearExpression> first = {3 * b + a + 1, 2 * a - 2};
+  const std::vector<LinearExpression> second = {2 * a + 3, 3 * a + 5 * b};
+  expr.AddInnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(10 * a * a + 16 * a * b + 2 * a - b + 8));
+}
+
+TEST(QuadraticExpressionTest, InnerProduct) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+  const std::vector<Variable> first = {a, b, a};
+  const std::vector<LinearTerm> second = {2.0 * a, 3.0 * a, 4.0 * b};
+  const auto expr = QuadraticExpression::InnerProduct(first, second);
+  EXPECT_THAT(expr, IsIdentical(2 * a * a + 7 * a * b));
+}
+
+TEST(QuadraticExpressionDeathTest, AddInnerProductSizeMismatchLeftMore) {
+  const std::vector<double> left = {2.0, 3.0, 4.0};
+  const std::vector<double> right = {1.0, -1.0};
+  QuadraticExpression expr;
+  EXPECT_DEATH(expr.AddInnerProduct(left, right), "left had more");
+}
+
+TEST(QuadraticExpressionDeathTest, AddInnerProductSizeMismatchRightMore) {
+  const std::vector<double> left = {2.0, 3.0};
+  const std::vector<double> right = {1.0, -1.0, 10.0};
+  QuadraticExpression expr;
+  EXPECT_DEATH(expr.AddInnerProduct(left, right), "right had more");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Quadratic greater than (>=) operators
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(QuadraticExpressionTest, DoubleGreaterEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 3;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const UpperBoundedQuadraticExpression comparison = lhs >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 2}}, {}, 0)));
+  EXPECT_EQ(comparison.upper_bound, 3);
+}
+
+TEST(QuadraticExpressionTest, DoubleGreaterEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 3;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const UpperBoundedQuadraticExpression comparison = lhs >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 2}}, {{b, 3}}, 4)));
+  EXPECT_EQ(comparison.upper_bound, 3);
+}
+
+TEST(QuadraticExpressionTest,
+     DoubleGreaterEqualLowerBoundedQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 6;
+  LowerBoundedQuadraticExpression rhs = (2 * a * b + 3 * b + 4 >= 5);
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(1, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms({{b, 3}}), 2));
+}
+
+TEST(QuadraticExpressionTest, VariableGreaterEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const Variable lhs = a;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, -2}}),
+                                              LinearTerms({{a, 1}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, VariableGreaterEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const Variable lhs = a;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              4, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 1}, {b, -3}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, LinearTermGreaterEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearTerm lhs = 3 * a;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, -2}}),
+                                              LinearTerms({{a, 3}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, LinearTermGreaterEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearTerm lhs = 3 * a;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              4, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}, {b, -3}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionGreaterEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression lhs = 3 * a + 4;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) >= rhs;
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(-4, QuadraticTerms({{a, b, -2}}),
+                                              LinearTerms({{a, 3}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionGreaterEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression lhs = 3 * a + 4;
+  QuadraticExpression rhs = 2 * a * b + 4 * b + 5;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              1, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}, {b, -4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const double rhs = 4;
+
+  ResetExpressionCounters();
+  const LowerBoundedQuadraticExpression comparison = lhs >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 3}}, {}, 0)));
+  EXPECT_EQ(comparison.lower_bound, 4);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermGreaterEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const Variable rhs = a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, 3}}),
+                                              LinearTerms({{a, -1}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermGreaterEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const LinearTerm rhs = 4 * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, 3}}),
+                                              LinearTerms({{a, -4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermGreaterEqualLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  LinearExpression rhs = 4 * a + 5;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(5, QuadraticTerms({{a, b, 3}}),
+                                              LinearTerms({{a, -4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermGreaterEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const QuadraticTerm rhs = 4 * a * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              0, QuadraticTerms({{a, a, -4}, {a, b, 3}}),
+                              LinearTerms(), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermGreaterEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  QuadraticExpression rhs = 4 * a * a + 5 * b + 6;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              6, QuadraticTerms({{a, a, -4}, {a, b, 3}}),
+                              LinearTerms({{b, -5}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const double rhs = 6;
+
+  ResetExpressionCounters();
+  const LowerBoundedQuadraticExpression comparison = std::move(lhs) >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 3}}, {{b, 4}}, 5)));
+  EXPECT_EQ(comparison.lower_bound, 6);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionGreaterEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const Variable rhs = a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -5, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -1}, {b, 4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionGreaterEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const LinearTerm rhs = 6 * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -5, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -6}, {b, 4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionGreaterEqualLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  LinearExpression rhs = 6 * a + 7;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              2, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -6}, {b, 4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionGreaterEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const QuadraticTerm rhs = 6 * a * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -5, QuadraticTerms({{a, a, -6}, {a, b, 3}}),
+                              LinearTerms({{b, 4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest,
+     QuadraticExpressionGreaterEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  QuadraticExpression rhs = 6 * a * a + 7 * a + 8;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) >= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              3, QuadraticTerms({{a, a, -6}, {a, b, 3}}),
+                              LinearTerms({{a, -7}, {b, 4}}), kInf));
+}
+
+TEST(QuadraticExpressionTest,
+     UpperBoundedQuadraticExpressionGreaterEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  UpperBoundedQuadraticExpression lhs = (2 * a * b + 3 * b + 4 <= 5);
+  const double rhs = 1;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) >= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(-3, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms({{b, 3}}), 1));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Quadratic less than (<=) operators
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(QuadraticExpressionTest, DoubleLesserEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 3;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const LowerBoundedQuadraticExpression comparison = lhs <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 2}}, {}, 0)));
+  EXPECT_EQ(comparison.lower_bound, 3);
+}
+
+TEST(QuadraticExpressionTest, DoubleLesserEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 3;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const LowerBoundedQuadraticExpression comparison = lhs <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 2}}, {{b, 3}}, 4)));
+  EXPECT_EQ(comparison.lower_bound, 3);
+}
+
+TEST(QuadraticExpressionTest,
+     DoubleLesserEqualUpperBoundedQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 1;
+  UpperBoundedQuadraticExpression rhs = (2 * a * b + 3 * b + 4 <= 5);
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(-3, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms({{b, 3}}), 1));
+}
+
+TEST(QuadraticExpressionTest, VariableLesserEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const Variable lhs = a;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 1}}), 0));
+}
+
+TEST(QuadraticExpressionTest, VariableLesserEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const Variable lhs = a;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 1}, {b, -3}}), 4));
+}
+
+TEST(QuadraticExpressionTest, LinearTermLesserEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearTerm lhs = 3 * a;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}}), 0));
+}
+
+TEST(QuadraticExpressionTest, LinearTermLesserEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearTerm lhs = 3 * a;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}, {b, -3}}), 4));
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionLesserEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression lhs = 3 * a + 4;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) <= rhs;
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}}), -4));
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionLesserEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression lhs = 3 * a + 4;
+  QuadraticExpression rhs = 2 * a * b + 4 * b + 5;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}, {b, -4}}), 1));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const double rhs = 4;
+
+  ResetExpressionCounters();
+  const UpperBoundedQuadraticExpression comparison = lhs <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 3}}, {}, 0)));
+  EXPECT_EQ(comparison.upper_bound, 4);
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermLesserEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const Variable rhs = a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -1}}), 0));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermLesserEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const LinearTerm rhs = 4 * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -4}}), 0));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermLesserEqualLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  LinearExpression rhs = 4 * a + 5;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -4}}), 5));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermLesserEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const QuadraticTerm rhs = 4 * a * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, a, -4}, {a, b, 3}}),
+                              LinearTerms(), 0));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermLesserEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  QuadraticExpression rhs = 4 * a * a + 5 * b + 6;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, a, -4}, {a, b, 3}}),
+                              LinearTerms({{b, -5}}), 6));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const double rhs = 6;
+
+  ResetExpressionCounters();
+  const UpperBoundedQuadraticExpression comparison = std::move(lhs) <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison.expression,
+              IsIdentical(QuadraticExpression({{a, b, 3}}, {{b, 4}}, 5)));
+  EXPECT_EQ(comparison.upper_bound, 6);
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionLesserEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const Variable rhs = a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -1}, {b, 4}}), -5));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionLesserEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const LinearTerm rhs = 6 * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -6}, {b, 4}}), -5));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionLesserEqualLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  LinearExpression rhs = 6 * a + 7;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -6}, {b, 4}}), 2));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionLesserEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const QuadraticTerm rhs = 6 * a * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, a, -6}, {a, b, 3}}),
+                              LinearTerms({{b, 4}}), -5));
+}
+
+TEST(QuadraticExpressionTest,
+     QuadraticExpressionLesserEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  QuadraticExpression rhs = 6 * a * a + 7 * a + 8;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) <= std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -kInf, QuadraticTerms({{a, a, -6}, {a, b, 3}}),
+                              LinearTerms({{a, -7}, {b, 4}}), 3));
+}
+
+TEST(QuadraticExpressionTest,
+     LowerBoundedQuadraticExpressionLesserEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LowerBoundedQuadraticExpression lhs = (2 * a * b + 3 * b + 4 >= 5);
+  const double rhs = 6;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) <= rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(1, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms({{b, 3}}), 2));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Quadratic equals (==) operators
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(QuadraticExpressionTest, DoubleEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 3;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(3, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms(), 3));
+}
+
+TEST(QuadraticExpressionTest, DoubleEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const double lhs = 3;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(-1, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms({{b, 3}}), -1));
+}
+
+TEST(QuadraticExpressionTest, VariableEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const Variable lhs = a;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms({{a, -1}}), 0));
+}
+
+TEST(QuadraticExpressionTest, VariableEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const Variable lhs = a;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              4, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 1}, {b, -3}}), 4));
+}
+
+TEST(QuadraticExpressionTest, LinearTermEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearTerm lhs = 3 * a;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, 2}}),
+                                              LinearTerms({{a, -3}}), 0));
+}
+
+TEST(QuadraticExpressionTest, LinearTermEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const LinearTerm lhs = 3 * a;
+  QuadraticExpression rhs = 2 * a * b + 3 * b + 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              4, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}, {b, -3}}), 4));
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression lhs = 3 * a + 4;
+  const QuadraticTerm rhs = 2 * a * b;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) == rhs;
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 4);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(-4, QuadraticTerms({{a, b, -2}}),
+                                              LinearTerms({{a, 3}}), -4));
+}
+
+TEST(QuadraticExpressionTest, LinearExpressionEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  LinearExpression lhs = 3 * a + 4;
+  QuadraticExpression rhs = 2 * a * b + 4 * b + 5;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) == std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              1, QuadraticTerms({{a, b, -2}}),
+                              LinearTerms({{a, 3}, {b, -4}}), 1));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const double rhs = 4;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(4, QuadraticTerms({{a, b, 3}}),
+                                              LinearTerms(), 4));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const Variable rhs = a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, -3}}),
+                                              LinearTerms({{a, 1}}), 0));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const LinearTerm rhs = 4 * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(0, QuadraticTerms({{a, b, -3}}),
+                                              LinearTerms({{a, 4}}), 0));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermEqualLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  LinearExpression rhs = 4 * a + 5;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == std::move(rhs);
+
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(5, QuadraticTerms({{a, b, 3}}),
+                                              LinearTerms({{a, -4}}), 5));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  const QuadraticTerm rhs = 4 * a * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              0, QuadraticTerms({{a, a, 4}, {a, b, -3}}),
+                              LinearTerms(), 0));
+}
+
+TEST(QuadraticExpressionTest, QuadraticTermEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const QuadraticTerm lhs = 3 * a * b;
+  QuadraticExpression rhs = 4 * a * a + 5 * b + 6;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = lhs == std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -6, QuadraticTerms({{a, a, 4}, {a, b, -3}}),
+                              LinearTerms({{b, 5}}), -6));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionEqualDouble) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const double rhs = 6;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(-1, QuadraticTerms({{a, b, -3}}),
+                                              LinearTerms({{b, -4}}), -1));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionEqualVariable) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const Variable rhs = a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -5, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -1}, {b, 4}}), -5));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionEqualLinearTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const LinearTerm rhs = 6 * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -5, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -6}, {b, 4}}), -5));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionEqualLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  LinearExpression rhs = 6 * a + 7;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) == std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              2, QuadraticTerms({{a, b, 3}}),
+                              LinearTerms({{a, -6}, {b, 4}}), 2));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionEqualQuadraticTerm) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  const QuadraticTerm rhs = 6 * a * a;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = std::move(lhs) == rhs;
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              -5, QuadraticTerms({{a, a, -6}, {a, b, 3}}),
+                              LinearTerms({{b, 4}}), -5));
+}
+
+TEST(QuadraticExpressionTest, QuadraticExpressionEqualQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  QuadraticExpression lhs = 3 * a * b + 4 * b + 5;
+  QuadraticExpression rhs = 6 * a * a + 7 * a + 8;
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison =
+      std::move(lhs) == std::move(rhs);
+
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 3);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(comparison, BoundedQuadraticExpressionEquiv(
+                              3, QuadraticTerms({{a, a, -6}, {a, b, 3}}),
+                              LinearTerms({{a, -7}, {b, 4}}), 3));
+}
+
+TEST(BoundedQuadraticExpressionTest, FromVariablesEquality) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  const internal::VariablesEquality linear_comparison = a == b;
+  ResetExpressionCounters();
+
+  const BoundedQuadraticExpression quadratic_comparison(linear_comparison);
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(quadratic_comparison,
+              BoundedQuadraticExpressionEquiv(
+                  0, QuadraticTerms(), LinearTerms({{a, 1}, {b, -1}}), 0));
+}
+
+TEST(LowerBoundedQuadraticExpressionTest, FromLowerBoundedLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  LowerBoundedLinearExpression linear_comparison = 2 * a >= 3;
+  ResetExpressionCounters();
+
+  const LowerBoundedQuadraticExpression quadratic_comparison(
+      std::move(linear_comparison));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(quadratic_comparison.expression,
+              IsIdentical(QuadraticExpression({}, {{a, 2}}, 0)));
+  EXPECT_EQ(quadratic_comparison.lower_bound, 3);
+}
+
+TEST(BoundedQuadraticExpressionTest, FromLowerBoundedLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  LowerBoundedLinearExpression linear_comparison = 2 * a >= 3;
+  ResetExpressionCounters();
+
+  const BoundedQuadraticExpression quadratic_comparison(
+      std::move(linear_comparison));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(quadratic_comparison,
+              BoundedQuadraticExpressionEquiv(3, QuadraticTerms(),
+                                              LinearTerms({{a, 2}}), kInf));
+}
+
+TEST(UpperBoundedQuadraticExpressionTest, FromUpperBoundedLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  UpperBoundedLinearExpression linear_comparison = 2 * a <= 3;
+  ResetExpressionCounters();
+
+  const UpperBoundedQuadraticExpression quadratic_comparison(
+      std::move(linear_comparison));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(quadratic_comparison.expression,
+              IsIdentical(QuadraticExpression({}, {{a, 2}}, 0)));
+  EXPECT_EQ(quadratic_comparison.upper_bound, 3);
+}
+
+TEST(BoundedQuadraticExpressionTest, FromUpperBoundedLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  UpperBoundedLinearExpression linear_comparison = 2 * a <= 3;
+  ResetExpressionCounters();
+
+  const BoundedQuadraticExpression quadratic_comparison(
+      std::move(linear_comparison));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(quadratic_comparison,
+              BoundedQuadraticExpressionEquiv(-kInf, QuadraticTerms(),
+                                              LinearTerms({{a, 2}}), 3));
+}
+
+TEST(BoundedQuadraticExpressionTest, FromBoundedLinearExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  BoundedLinearExpression linear_comparison = (2 <= 3 * a <= 4);
+  ResetExpressionCounters();
+
+  const BoundedQuadraticExpression quadratic_comparison(
+      std::move(linear_comparison));
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(LinearExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(LinearExpression, 0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(1);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_THAT(quadratic_comparison,
+              BoundedQuadraticExpressionEquiv(2, QuadraticTerms(),
+                                              LinearTerms({{a, 3}}), 4));
+}
+
+TEST(BoundedQuadraticExpressionTest, FromLowerBoundedQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = 3 <= a * a;
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(3.0, QuadraticTerms({{a, a, 1}}),
+                                              LinearTerms(), kInf));
+}
+
+TEST(BoundedQuadraticExpressionTest, FromUpperBoundedQuadraticExpression) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+
+  ResetExpressionCounters();
+  const BoundedQuadraticExpression comparison = a * a <= 5;
+  EXPECT_THAT(comparison,
+              BoundedQuadraticExpressionEquiv(
+                  -kInf, QuadraticTerms({{a, a, 1}}), LinearTerms(), 5));
+  EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS(0);
+  EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR(0);
+  EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_COPY_CONSTRUCTOR(QuadraticExpression, 0);
+  EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR(QuadraticExpression, 2);
+  EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR(QuadraticExpression, 1);
+}
+
+TEST(BoundedQuadraticExpressionTest, OutputStreaming) {
+  ModelStorage storage;
+  const Variable a(&storage, storage.AddVariable("a"));
+  const Variable b(&storage, storage.AddVariable("b"));
+
+  auto to_string = [](BoundedQuadraticExpression bounded_expression) {
+    std::ostringstream oss;
+    oss << bounded_expression;
+    return oss.str();
+  };
+
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(QuadraticExpression(), -1, 2)),
+            "-1 ≤ 0 ≤ 2");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({}, {}, -1), -1, 2)),
+            "-1 ≤ -1 ≤ 2");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({}, {{a, 1}, {b, 5}}, -1), -1, 2)),
+            "-1 ≤ a + 5*b - 1 ≤ 2");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({}, {{a, 1}, {b, 5}}, 0), -1, 2)),
+            "-1 ≤ a + 5*b ≤ 2");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({}, {{a, 2}}, 0), -kInf, 2)),
+            "2*a ≤ 2");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({}, {{a, 2}}, 0), -1, kInf)),
+            "2*a ≥ -1");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({}, {{a, 2}}, 0), 3, 3)),
+            "2*a = 3");
+
+  EXPECT_EQ(
+      to_string(BoundedQuadraticExpression(
+          QuadraticExpression({{a, a, 3}, {a, b, 4}}, {{a, 1}, {b, 5}}, -1), -1,
+          2)),
+      "-1 ≤ 3*a² + 4*a*b + a + 5*b - 1 ≤ 2");
+  EXPECT_EQ(
+      to_string(BoundedQuadraticExpression(
+          QuadraticExpression({{a, a, 3}, {a, b, 4}}, {{a, 1}, {b, 5}}, 0), -1,
+          2)),
+      "-1 ≤ 3*a² + 4*a*b + a + 5*b ≤ 2");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({{a, a, 2}}, {}, 0), -kInf, 2)),
+            "2*a² ≤ 2");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({{a, a, 2}}, {}, 0), -1, kInf)),
+            "2*a² ≥ -1");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({{a, a, 2}}, {}, 0), 3, 3)),
+            "2*a² = 3");
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({{a, a, 2}}, {}, 0), -kInf,
+                kRoundTripTestNumber)),
+            absl::StrCat("2*a² ≤ ", kRoundTripTestNumberStr));
+  EXPECT_EQ(
+      to_string(BoundedQuadraticExpression(
+          QuadraticExpression({{a, a, 2}}, {}, 0), kRoundTripTestNumber, kInf)),
+      absl::StrCat("2*a² ≥ ", kRoundTripTestNumberStr));
+  EXPECT_EQ(to_string(BoundedQuadraticExpression(
+                QuadraticExpression({{a, a, 2}}, {}, 0), kRoundTripTestNumber,
+                kRoundTripTestNumber)),
+            absl::StrCat("2*a² = ", kRoundTripTestNumberStr));
+  EXPECT_EQ(
+      to_string(BoundedQuadraticExpression(
+          QuadraticExpression({{a, a, 2}}, {}, 0), kRoundTripTestNumber, 3000)),
+      absl::StrCat(kRoundTripTestNumberStr, " ≤ 2*a² ≤ 3000"));
+  EXPECT_EQ(
+      to_string(BoundedQuadraticExpression(
+          QuadraticExpression({{a, a, 2}}, {}, 0), 0.0, kRoundTripTestNumber)),
+      absl::StrCat("0 ≤ 2*a² ≤ ", kRoundTripTestNumberStr));
+}
+
+#undef EXPECT_NUM_CALLS_DEFAULT_CONSTRUCTOR
+#undef EXPECT_NUM_CALLS_COPY_CONSTRUCTOR
+#undef EXPECT_NUM_CALLS_MOVE_CONSTRUCTOR
+#undef EXPECT_NUM_CALLS_INITIALIZER_LIST_CONSTRUCTOR
+#undef EXPECT_NUM_CALLS_LINEAR_TO_QUADRATIC_CONSTRUCTOR
+#undef EXPECT_NUM_CALLS_TO_LINEAR_EXPRESSION_CONSTRUCTORS
+#undef EXPECT_NUM_CALLS_TO_QUADRATIC_EXPRESSION_CONSTRUCTORS
+
+}  // namespace
+}  // namespace math_opt
+}  // namespace operations_research
diff --git a/ortools/math_opt/elemental/BUILD.bazel b/ortools/math_opt/elemental/BUILD.bazel
index 2b03c5d97e..8b1c2de959 100644
--- a/ortools/math_opt/elemental/BUILD.bazel
+++ b/ortools/math_opt/elemental/BUILD.bazel
@@ -540,20 +540,6 @@ cc_test(
     ],
 )
 
-cc_test(
-    name = "elemental_from_proto_fuzz_test",
-    srcs = ["elemental_from_proto_fuzz_test.cc"],
-    tags = ["componentid:1147829"],
-    deps = [
-        ":elemental",
-        ":elemental_matcher",
-        "//ortools/base:fuzztest",
-        "//ortools/base:gmock_main",
-        "//ortools/math_opt:model_update_cc_proto",
-        "@abseil-cpp//absl/status:statusor",
-    ],
-)
-
 cc_test(
     name = "elemental_update_from_proto_test",
     srcs = ["elemental_update_from_proto_test.cc"],
diff --git a/ortools/math_opt/elemental/CMakeLists.txt b/ortools/math_opt/elemental/CMakeLists.txt
index 8656b60254..c1fe79df97 100644
--- a/ortools/math_opt/elemental/CMakeLists.txt
+++ b/ortools/math_opt/elemental/CMakeLists.txt
@@ -61,7 +61,7 @@ if(BUILD_TESTING)
         ${_FILE_NAME}
       LINK_LIBRARIES
         benchmark::benchmark
-        GTest::gmock
+        ortools::base_gmock
         GTest::gtest_main
         ortools::math_opt_matchers
         ortools::math_opt_elemental_matcher
diff --git a/ortools/math_opt/elemental/element_storage.h b/ortools/math_opt/elemental/element_storage.h
index a796a11522..e4f011412a 100644
--- a/ortools/math_opt/elemental/element_storage.h
+++ b/ortools/math_opt/elemental/element_storage.h
@@ -107,8 +107,7 @@ class SparseElementStorage {
 class ElementStorage {
   // Functions with deduced return must be defined before they are used.
  private:
-  // std::visit is very slow, see
-  // 5253596299885805568
+  // std::visit is very slow, see yaqs/5253596299885805568.
   //
   // This function is static, taking Self as template argument, to avoid
   // having const and non-const versions. Post C++ 23, prefer:
diff --git a/ortools/math_opt/elemental/elemental_test.cc b/ortools/math_opt/elemental/elemental_test.cc
index 11744b4bf0..d973d14a56 100644
--- a/ortools/math_opt/elemental/elemental_test.cc
+++ b/ortools/math_opt/elemental/elemental_test.cc
@@ -78,8 +78,7 @@ TEST(ElementalTest, HaveNames) {
 ////////////////////////////////////////////////////////////////////////////////
 
 // Typed tests do not work with non-type template parameters, so we need to
-// wrap the values with a type. See
-// 8947385822189977600
+// wrap the values with a type. See yaqs/8947385822189977600.
 template <ElementType e>
 class ElementTypeProxy {
  public:
diff --git a/ortools/math_opt/python/BUILD.bazel b/ortools/math_opt/python/BUILD.bazel
index 3088901638..877e801b48 100644
--- a/ortools/math_opt/python/BUILD.bazel
+++ b/ortools/math_opt/python/BUILD.bazel
@@ -234,7 +234,7 @@ py_library(
         ":variables",
         "//ortools/math_opt:result_py_pb2",
         "//ortools/math_opt/solvers:osqp_py_pb2",
-        "//ortools/math_opt/solvers/gscip:gscip_proto_py_pb2",
+        "//ortools/math_opt/solvers/gscip:gscip_py_pb2",
     ],
 )
 
@@ -288,7 +288,7 @@ py_library(
         "//ortools/math_opt/solvers:gurobi_py_pb2",
         "//ortools/math_opt/solvers:highs_py_pb2",
         "//ortools/math_opt/solvers:osqp_py_pb2",
-        "//ortools/math_opt/solvers/gscip:gscip_proto_py_pb2",
+        "//ortools/math_opt/solvers/gscip:gscip_py_pb2",
         "//ortools/pdlp:solvers_py_pb2",
         "//ortools/sat:sat_parameters_py_pb2",
     ],
@@ -308,7 +308,7 @@ py_test(
         "//ortools/math_opt/solvers:gurobi_py_pb2",
         "//ortools/math_opt/solvers:highs_py_pb2",
         "//ortools/math_opt/solvers:osqp_py_pb2",
-        "//ortools/math_opt/solvers/gscip:gscip_proto_py_pb2",
+        "//ortools/math_opt/solvers/gscip:gscip_py_pb2",
         "//ortools/pdlp:solvers_py_pb2",
         "//ortools/sat:sat_parameters_py_pb2",
     ],
diff --git a/ortools/math_opt/python/bounded_expressions.py b/ortools/math_opt/python/bounded_expressions.py
index 768c687ee2..d9d024f7bd 100644
--- a/ortools/math_opt/python/bounded_expressions.py
+++ b/ortools/math_opt/python/bounded_expressions.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 # Copyright 2010-2025 Google LLC
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
diff --git a/ortools/math_opt/python/ipc/proto_converter.py b/ortools/math_opt/python/ipc/proto_converter.py
index 8065352550..c5aaf38251 100644
--- a/ortools/math_opt/python/ipc/proto_converter.py
+++ b/ortools/math_opt/python/ipc/proto_converter.py
@@ -16,7 +16,7 @@
 
 Provides several conversion functions to transform from/to protos exposed in the
 Operations Research API to the internal protos in
-/ortools/math_opt/.*.proto.
+ortools/math_opt/.*.proto.
 """
 
 from google.protobuf import message
diff --git a/ortools/math_opt/python/linear_expression_test.py b/ortools/math_opt/python/linear_expression_test.py
index 013a7dfda4..d36be4c769 100644
--- a/ortools/math_opt/python/linear_expression_test.py
+++ b/ortools/math_opt/python/linear_expression_test.py
@@ -2479,7 +2479,7 @@ class UnsupportedProductOperandTest(parameterized.TestCase):
 
         # pylint: disable=pointless-statement
         # pytype: disable=unsupported-operands
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, expected_string):
             lhs * rhs
 
@@ -2501,7 +2501,7 @@ class UnsupportedProductOperandTest(parameterized.TestCase):
 
         # pylint: disable=pointless-statement
         # pytype: disable=unsupported-operands
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, expected_string):
             lhs / rhs
 
@@ -2566,7 +2566,7 @@ class UnsupportedAdditionOperandTest(parameterized.TestCase):
 
         # pylint: disable=pointless-statement
         # pytype: disable=unsupported-operands
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, expected_string):
             if linear_or_quadratic_first:
                 linear_or_quadratic + other
@@ -2602,7 +2602,7 @@ class UnsupportedAdditionOperandTest(parameterized.TestCase):
 
         # pylint: disable=pointless-statement
         # pytype: disable=unsupported-operands
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, expected_string):
             if linear_or_quadratic_first:
                 linear_or_quadratic - other
@@ -2622,7 +2622,7 @@ class UnsupportedAdditionOperandTest(parameterized.TestCase):
 class UnsupportedInitializationTest(parameterized.TestCase):
 
     def test_linear_sum_not_tuple(self):
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, "object is not iterable"):
             variables.LinearSum(2.0)
         # pytype: enable=wrong-arg-types
@@ -2630,19 +2630,19 @@ class UnsupportedInitializationTest(parameterized.TestCase):
     def test_linear_sum_not_linear_in_tuple(self):
         mod = model.Model()
         x = mod.add_binary_variable(name="x")
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, "unsupported type in iterable argument"):
             variables.LinearSum((2.0, x * x))
         # pytype: enable=wrong-arg-types
 
     def test_quadratic_sum_not_tuple(self):
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, "object is not iterable"):
             variables.QuadraticSum(2.0)
         # pytype: enable=wrong-arg-types
 
     def test_quadratic_sum_not_linear_in_tuple(self):
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(TypeError, "unsupported type in iterable argument"):
             variables.QuadraticSum((2.0, "string"))
         # pytype: enable=wrong-arg-types
@@ -2650,7 +2650,7 @@ class UnsupportedInitializationTest(parameterized.TestCase):
     def test_linear_product_not_scalar(self):
         mod = model.Model()
         x = mod.add_binary_variable(name="x")
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(
             TypeError, "unsupported type for scalar argument in LinearProduct"
         ):
@@ -2658,7 +2658,7 @@ class UnsupportedInitializationTest(parameterized.TestCase):
         # pytype: enable=wrong-arg-types
 
     def test_linear_product_not_linear(self):
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(
             TypeError, "unsupported type for linear argument in LinearProduct"
         ):
@@ -2668,7 +2668,7 @@ class UnsupportedInitializationTest(parameterized.TestCase):
     def test_quadratic_product_not_scalar(self):
         mod = model.Model()
         x = mod.add_binary_variable(name="x")
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(
             TypeError, "unsupported type for scalar argument in QuadraticProduct"
         ):
@@ -2676,7 +2676,7 @@ class UnsupportedInitializationTest(parameterized.TestCase):
         # pytype: enable=wrong-arg-types
 
     def test_quadratic_product_not_quadratic(self):
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(
             TypeError, "unsupported type for linear argument in QuadraticProduct"
         ):
@@ -2686,7 +2686,7 @@ class UnsupportedInitializationTest(parameterized.TestCase):
     def test_linear_linear_product_first_not_linear(self):
         mod = model.Model()
         x = mod.add_binary_variable(name="x")
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(
             TypeError,
             "unsupported type for first_linear argument in LinearLinearProduct",
@@ -2697,7 +2697,7 @@ class UnsupportedInitializationTest(parameterized.TestCase):
     def test_linear_linear_product_second_not_linear(self):
         mod = model.Model()
         x = mod.add_binary_variable(name="x")
-        # pytype: disable=wrong-arg-types
+
         with self.assertRaisesRegex(
             TypeError,
             "unsupported type for second_linear argument in LinearLinearProduct",
diff --git a/ortools/math_opt/python/normalized_inequality_test.py b/ortools/math_opt/python/normalized_inequality_test.py
index 7b8c99eeaa..afaabe7ca1 100644
--- a/ortools/math_opt/python/normalized_inequality_test.py
+++ b/ortools/math_opt/python/normalized_inequality_test.py
@@ -130,9 +130,7 @@ class NormalizedLinearInequalityTest(absltest.TestCase):
 
     def test_bounded_expr_bad_type_raise_error(self) -> None:
         with self.assertRaisesRegex(TypeError, "bounded_expr has bad type"):
-            normalized_inequality.as_normalized_linear_inequality(
-                "dogdog"
-            )  # pytype: disable=wrong-arg-types
+            normalized_inequality.as_normalized_linear_inequality("dogdog")
 
     def test_bounded_expr_inner_expr_bad_type_raise_error(self) -> None:
         with self.assertRaisesRegex(
@@ -141,9 +139,7 @@ class NormalizedLinearInequalityTest(absltest.TestCase):
             bounded = bounded_expressions.BoundedExpression(
                 lower_bound=1.0, expression="dogdog", upper_bound=1.0
             )
-            normalized_inequality.as_normalized_linear_inequality(
-                bounded
-            )  # pytype: disable=wrong-arg-types
+            normalized_inequality.as_normalized_linear_inequality(bounded)
 
 
 def _quad_coef_dict(
@@ -196,7 +192,7 @@ class NormalizedQuadraticInequalityTest(absltest.TestCase):
         with self.assertRaises(TypeError):
             normalized_inequality.NormalizedQuadraticInequality(
                 lb=1.0, expr="dog", ub=2.0
-            )  # pytype: disable=wrong-arg-types
+            )
 
     def test_as_normalized_inequality_from_parts(self) -> None:
         mod = model.Model()
@@ -273,18 +269,14 @@ class NormalizedQuadraticInequalityTest(absltest.TestCase):
 
     def test_bounded_expr_bad_type_raise_error(self) -> None:
         with self.assertRaisesRegex(TypeError, "bounded_expr has bad type"):
-            normalized_inequality.as_normalized_quadratic_inequality(
-                "dogdog"
-            )  # pytype: disable=wrong-arg-types
+            normalized_inequality.as_normalized_quadratic_inequality("dogdog")
 
     def test_bounded_expr_inner_expr_bad_type_raise_error(self) -> None:
         with self.assertRaisesRegex(TypeError, "bounded_expr.expression has bad type"):
             bounded = bounded_expressions.BoundedExpression(
                 lower_bound=1.0, expression="dogdog", upper_bound=1.0
             )
-            normalized_inequality.as_normalized_quadratic_inequality(
-                bounded
-            )  # pytype: disable=wrong-arg-types
+            normalized_inequality.as_normalized_quadratic_inequality(bounded)
 
 
 if __name__ == "__main__":
diff --git a/ortools/math_opt/python/result_test.py b/ortools/math_opt/python/result_test.py
index af901b1a24..6388c009e4 100644
--- a/ortools/math_opt/python/result_test.py
+++ b/ortools/math_opt/python/result_test.py
@@ -293,7 +293,7 @@ class SolveResultAuxiliaryFunctionsTest(absltest.TestCase):
         with self.assertRaisesRegex(KeyError, ".*string"):
             res.reduced_costs([y, "string"])
         with self.assertRaisesRegex(TypeError, ".*int"):
-            res.reduced_costs(20)  # pytype: disable=wrong-arg-types
+            res.reduced_costs(20)
         # Dual values.
         self.assertDictEqual(res.dual_values(), {c: 3.0, d: 4.0})
         self.assertEqual(res.dual_values()[c], 3.0)
@@ -305,7 +305,7 @@ class SolveResultAuxiliaryFunctionsTest(absltest.TestCase):
         with self.assertRaisesRegex(KeyError, ".*string"):
             res.dual_values([d, "string"])
         with self.assertRaisesRegex(TypeError, ".*int"):
-            res.dual_values(20)  # pytype: disable=wrong-arg-types
+            res.dual_values(20)
 
     def test_dual_solution_no_feasible(self) -> None:
         mod = model.Model(name="test_model")
@@ -391,7 +391,7 @@ class SolveResultAuxiliaryFunctionsTest(absltest.TestCase):
         with self.assertRaisesRegex(KeyError, ".*string"):
             res.ray_variable_values([y, "string"])
         with self.assertRaisesRegex(TypeError, ".*int"):
-            res.ray_variable_values(20)  # pytype: disable=wrong-arg-types
+            res.ray_variable_values(20)
 
     def test_primal_ray_no_ray(self) -> None:
         res = result.SolveResult()
@@ -426,7 +426,7 @@ class SolveResultAuxiliaryFunctionsTest(absltest.TestCase):
         with self.assertRaisesRegex(KeyError, ".*string"):
             res.ray_reduced_costs([y, "string"])
         with self.assertRaisesRegex(TypeError, ".*int"):
-            res.ray_reduced_costs(20)  # pytype: disable=wrong-arg-types
+            res.ray_reduced_costs(20)
         # Dual values.
         self.assertDictEqual(res.ray_dual_values(), {c: 3.0, d: 4.0})
         self.assertEqual(res.ray_dual_values()[c], 3.0)
@@ -438,7 +438,7 @@ class SolveResultAuxiliaryFunctionsTest(absltest.TestCase):
         with self.assertRaisesRegex(KeyError, ".*string"):
             res.ray_dual_values([d, "string"])
         with self.assertRaisesRegex(TypeError, ".*int"):
-            res.ray_dual_values(20)  # pytype: disable=wrong-arg-types
+            res.ray_dual_values(20)
 
     def test_dual_ray_no_ray(self) -> None:
         res = result.SolveResult()
@@ -496,7 +496,7 @@ class SolveResultAuxiliaryFunctionsTest(absltest.TestCase):
         with self.assertRaisesRegex(KeyError, ".*string"):
             res.variable_status([y, "string"])
         with self.assertRaisesRegex(TypeError, ".*int"):
-            res.variable_status(20)  # pytype: disable=wrong-arg-types
+            res.variable_status(20)
         # Constraint status
         self.assertDictEqual(
             res.constraint_status(),
@@ -514,7 +514,7 @@ class SolveResultAuxiliaryFunctionsTest(absltest.TestCase):
         with self.assertRaisesRegex(KeyError, ".*string"):
             res.constraint_status([d, "string"])
         with self.assertRaisesRegex(TypeError, ".*int"):
-            res.constraint_status(20)  # pytype: disable=wrong-arg-types
+            res.constraint_status(20)
 
     def test_basis_no_basis_in_best_solution(self) -> None:
         mod = model.Model(name="test_model")
diff --git a/ortools/math_opt/samples/cpp/BUILD.bazel b/ortools/math_opt/samples/cpp/BUILD.bazel
index 2577871d64..b3568e048a 100644
--- a/ortools/math_opt/samples/cpp/BUILD.bazel
+++ b/ortools/math_opt/samples/cpp/BUILD.bazel
@@ -112,7 +112,6 @@ cc_binary(
         "//ortools/math_opt/cpp:math_opt",
         "//ortools/math_opt/solvers:glop_solver",
         "//ortools/math_opt/solvers:glpk_solver",
-        "//ortools/math_opt/solvers:gurobi_solver",
         "//ortools/math_opt/solvers:pdlp_solver",
         "//ortools/util:status_macros",
         "@abseil-cpp//absl/container:flat_hash_map",
@@ -157,7 +156,6 @@ cc_binary(
         "//ortools/base",
         "//ortools/base:status_macros",
         "//ortools/math_opt/cpp:math_opt",
-        "//ortools/math_opt/solvers:gurobi_solver",
         "//ortools/math_opt/solvers:pdlp_solver",
         "@abseil-cpp//absl/algorithm:container",
         "@abseil-cpp//absl/flags:flag",
@@ -181,7 +179,6 @@ cc_binary(
         "//ortools/math_opt/solvers:glop_solver",
         "//ortools/math_opt/solvers:glpk_solver",
         "//ortools/math_opt/solvers:gscip_solver",
-        "//ortools/math_opt/solvers:gurobi_solver",
         "//ortools/math_opt/solvers:highs_solver",
         "//ortools/math_opt/solvers:pdlp_solver",
     ],
@@ -196,7 +193,6 @@ cc_binary(
         "//ortools/base:status_macros",
         "//ortools/math_opt/cpp:math_opt",
         "//ortools/math_opt/solvers:gscip_solver",
-        "//ortools/math_opt/solvers:gurobi_solver",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/flags:flag",
         "@abseil-cpp//absl/log:check",
@@ -232,7 +228,6 @@ cc_binary(
         "//ortools/math_opt/cpp:math_opt",
         "//ortools/math_opt/solvers:cp_sat_solver",
         "//ortools/math_opt/solvers:gscip_solver",
-        "//ortools/math_opt/solvers:gurobi_solver",
         "@abseil-cpp//absl/algorithm:container",
         "@abseil-cpp//absl/flags:flag",
         "@abseil-cpp//absl/log",
diff --git a/ortools/math_opt/samples/cpp/CMakeLists.txt b/ortools/math_opt/samples/cpp/CMakeLists.txt
index d4137bf404..c116852e44 100644
--- a/ortools/math_opt/samples/cpp/CMakeLists.txt
+++ b/ortools/math_opt/samples/cpp/CMakeLists.txt
@@ -18,6 +18,7 @@ endif()
 if(BUILD_CXX_SAMPLES)
   file(GLOB CXX_SRCS "*.cc")
   list(FILTER CXX_SRCS EXCLUDE REGEX "area_socp.cc$")
+  list(FILTER CXX_SRCS EXCLUDE REGEX "coil_in_the_box.cc$") # missing base/context.h
 
   if(NOT USE_SCIP)
     list(FILTER CXX_SRCS EXCLUDE REGEX "cocktail_hour.cc$")
diff --git a/ortools/math_opt/samples/cpp/coil_in_the_box.cc b/ortools/math_opt/samples/cpp/coil_in_the_box.cc
new file mode 100644
index 0000000000..130ad14523
--- /dev/null
+++ b/ortools/math_opt/samples/cpp/coil_in_the_box.cc
@@ -0,0 +1,383 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Solves the coil in the box problem, a variant of the snake in the box
+// problem, see https://en.wikipedia.org/wiki/Snake-in-the-box.
+//
+// The problem is to find the longest cycle traversing a subset of the corners
+// of the n-dimensional hypercube, such that for each corner you visit, you
+// visit at most two adjacent corners. The cube has 2^n corners, giving an
+// upper bound on the longest cycle length. We use a prize collecting TSP
+// like MIP model to solve the problem below. We introduce the "Medusa cuts"
+// for this problem, linear constraints that improve the LP relaxation without
+// cutting off any integer points, that can be optionally included in the model.
+//
+// The best known solutions for coil in a box as a function of n are:
+//
+// n  | best solution | best bound
+// ---|---------------|------------
+// 2  | 4             | 4
+// 3  | 6             | 6
+// 4  | 8             | 8
+// 5  | 14            | 14
+// 6  | 26            | 26
+// 7  | 48            | 48
+// 8  | 96            | 96
+// 9  | 188           | ?
+// 10 | 366           | ?
+// 11 | 692           | ?
+// 12 | 1344          | ?
+//
+// Below, we show results with the Medusa cuts on (and --fix). We are optimal
+// up to n=6 (45s). All solves were run locally to avoid callback RPC overhead.
+//
+// clang-format off
+// n  | best solution | lp bound    | 20m bound     | logs
+// ---|---------------|-------------|--------------|-------
+// 6  | 26            | 30.8        | 26 (6.5s)    | https://paste.googleplex.com/5930768672751616
+// 7  | 46            | 59.6        | 57.1 (5m)    | https://paste.googleplex.com/6517880031805440
+// 8  | 78            | 116.2 (21s) | 114.9        | https://paste.googleplex.com/4818696077574144
+// 9  | 86            | 228.1 (6m)  | 227.7        | https://paste.googleplex.com/4856789015330816
+// clang-format on
+//
+// For n=9, the problem (post presolve) has ~3k columns, ~12k rows, and ~150k
+// nonzeros.
+//
+// clang-format off
+// Without the Medusa cuts, we better primal solutions but worse bounds.
+// n  | best solution | lp bound | 20m bound  | logs
+// ---|---------------|-----------------------------
+// 6  | 26 (<1s)      | 35.2     | 26 (17s)   | https://paste.googleplex.com/5421390584610816
+// 7  | 48 (1m)       | 70       | 63.7 (5m)  | https://paste.googleplex.com/4812751909945344
+// 8  | 88            | 140.8    | 134.5      | https://paste.googleplex.com/6498606298955776
+// 9  | 158           | 281      | 277        | https://paste.googleplex.com/5250122858102784
+// clang-format on
+//
+// Notes for someone trying to do better:
+//  * Using only 2-Medusa cuts (edit the code) has almost no effect (tiny
+//    improvement on the root LP relaxation).
+//  * The gurobi symmetry breaking does not seem to work, even when --fix=false
+//    and the "Symmetry" parameter is set to 2. The results are much worse
+//    whenever --fix=false.
+//  * For smaller instances, the remote callbacks are painful (182/200s in
+//    callback for n=6, medusa=false), but for large instances the RPC overhead
+//    does not matter.
+//  * With Medusa cuts, we have many more constraints than variables, and the LP
+//    becomes slow for large instances.
+//  * No attempt was made to optimize the parameters of QuickSeparate() below.
+//
+// Our MIP model is as follows.
+//
+// Data:
+//  * n: the dimension of the hypercube
+//  * G = (V, E): the hypercube as a graph, with vertices at the 2^n corners and
+//    edges between the corners differing in only one coordinate.
+//  * E(v) subset E: the edges where v is an endpoint.
+//  * N(v) subset V: the nodes neighboring v.
+//  * Cut(S) subset E: edges with exactly one endpoint in S.
+//
+// Variables:
+//   * y_e: do we use edge e in E
+//   * x_v: do we visit vertex v
+//
+// Model:
+//   max   sum_{e in E} y_e
+//   s.t.  sum_{e in E(v)} y_e = 2 x_v                  for all v in V
+//         x_v + x_w <= 1 + y_{v,w}                     for all (v, w) in E
+//         sum_{e in Cut(S)} y_e >= 2 (x_k + x_l - 1)   for all S subset N
+//                                                              3 < |S| < |N|
+//                                                              k in S,
+//                                                              l not in S
+//
+// The first constraint (the degree constraint) says to use exactly two edges if
+// we visit the node, and none otherwise. The second constraint enforces the
+// invalidation of adjacent corners that are not visited directly from a node,
+// it requires that we only visit two adjacent nodes if we include the edge
+// between them.
+//
+// The final constraint is the "cutset" constraint from the PC-TSP, which
+// ensures that all arcs selected form a single single, rather than multiple
+// cycles (if you select a node inside S and outside S, there must be 2 units of
+// flow over the cut). For more details on the implementation, see:
+//   * cs/ortools/math_opt/models/tsp/math_opt_circuit.h
+//   * cs/ortools/math_opt/models/tsp/circuit_constraint.h
+// In particular, when --fix is set (so we know the first node is visited),
+// there is a slightly simpler formulation of the constraint (see
+// math_opt_circuit.h).
+//
+// The cutset constraints are separated exactly on integer solutions by
+// traversing the selected arcs are looking for cycles. They are separated
+// approximately for fractional solutions by rounding the solution and then
+// checking each connected component.
+//
+// We can strengthen this constraint with the "Medusa cuts" as follows. Let
+// d_v = 2*x_v (don't create the variable, just use a linear expression) give
+// the degree of node v (we need this to make the constraints sparse). The cuts
+// are parameterized by a dimension d < n. Take all n choose d hypercubes of
+// size d that are a subset the n dimension hypercube. For each cube, take the
+// internal edges (Medusa's head) and the edges on the cut with one exactly
+// endpoint in the cube (Medusa's snakes). For d=2, we can use at most 4 of
+// these edges, and for d=3, we can use at most 6 of these edges (this was shown
+// by enumeration/cases, a clean proof would be an improvement). We can write
+// these constraints as:
+//   sum_{v in Head} d_v - sum_{e in Head} y_e <= UB(d)
+// Using O(2^d) nonzeros per cut.
+#include <cmath>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <utility>
+#include <vector>
+
+#include "absl/algorithm/container.h"
+#include "absl/flags/flag.h"
+#include "absl/status/status.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+#include "base/context.h"
+#include "ortools/base/init_google.h"
+#include "ortools/base/logging.h"
+#include "ortools/base/status_macros.h"
+#include "ortools/base/strong_int.h"
+#include "ortools/base/strong_vector.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+#include "ortools/math_opt/cpp/remote_solve.h"
+#include "ortools/math_opt/cpp/stubby_remote_streaming_solve.h"
+#include "ortools/math_opt/models/tsp/circuit_constraint.h"
+#include "ortools/math_opt/models/tsp/math_opt_circuit.h"
+#include "ortools/math_opt/rpc.stubby.h"
+
+ABSL_FLAG(int, dim, 4, "Dimension of the hyper cube to solve in.");
+ABSL_FLAG(bool, gurobi, false, "Use gurobi instead of SCIP.");
+ABSL_FLAG(std::optional<int>, threads, std::nullopt,
+          "How many threads, the solver default if unset.");
+ABSL_FLAG(bool, medusa, false, "Add medusa cuts to the formulation");
+ABSL_FLAG(bool, fix, false, "break symmetry by fixing variables");
+ABSL_FLAG(bool, remote, false, "Solve remotely with stubby");
+ABSL_FLAG(absl::Duration, time_limit, absl::Minutes(5),
+          "A limit on how long to run");
+
+namespace {
+
+namespace math_opt = ::operations_research::math_opt;
+namespace models = ::operations_research::models;
+using Node = models::CircuitConstraint::Node;
+using Edge = models::CircuitConstraint::Edge;
+using ::util_intops::MakeStrongIntRange;
+
+// The cube has 2**n nodes, represented by the integers [0..2**n). The binary
+// encoding of each node says which coordinates are zero and which are one. This
+// function flips the dth bit, getting a neighboring node.
+Node Neighbor(const Node v, int d) { return Node(v.value() ^ (1 << d)); }
+
+absl::StatusOr<math_opt::SolveResult> RunSolve(const math_opt::Model& model,
+                                               math_opt::SolverType solver_type,
+                                               math_opt::SolveArguments args) {
+  if (absl::GetFlag(FLAGS_remote)) {
+    args.message_callback = math_opt::PrinterMessageCallback();
+    const base::WithDeadline deadline(absl::Now() +
+                                      3 * absl::GetFlag(FLAGS_time_limit));
+    ASSIGN_OR_RETURN(const std::unique_ptr<math_opt::SolveService> stub,
+                     math_opt::SolveServerStub());
+    return math_opt::StubbyRemoteStreamingSolve(stub.get(), model, solver_type,
+                                                args);
+  }
+  return math_opt::Solve(model, solver_type, std::move(args));
+}
+
+absl::StatusOr<math_opt::CallbackResult> OnMipSolution(
+    const models::MathOptCircuit& circuit, const math_opt::CallbackData& data) {
+  CHECK(data.solution.has_value());
+  math_opt::CallbackResult result;
+
+  ASSIGN_OR_RETURN(const std::vector<models::MathOptCircuit::Cutset> cuts,
+                   circuit.ExactSeparateIntegerSolution(*data.solution));
+  for (const models::MathOptCircuit::Cutset& cutset : cuts) {
+    result.AddLazyConstraint(circuit.CreateCutsetConstraint(cutset));
+  }
+  return result;
+}
+
+absl::StatusOr<math_opt::CallbackResult> OnMipNode(
+    const models::MathOptCircuit& circuit, const math_opt::CallbackData& data) {
+  math_opt::CallbackResult result;
+  if (!data.solution.has_value()) {
+    return result;
+  }
+  // The values of edge_threshold and min_violation should be in (0, 1). They
+  // were not tuned for this problem, values that worked well on other problems
+  // were reused.
+  ASSIGN_OR_RETURN(const std::vector<models::MathOptCircuit::Cutset> cuts,
+                   circuit.QuickSeparate(*data.solution,
+                                         /*edge_threshold=*/0.5,
+                                         /*min_violation*/ 0.05));
+
+  for (const models::MathOptCircuit::Cutset& cutset : cuts) {
+    result.AddLazyConstraint(circuit.CreateCutsetConstraint(cutset));
+  }
+  return result;
+}
+
+absl::Status Main() {
+  int dim = absl::GetFlag(FLAGS_dim);
+  Node num_nodes{std::pow(2, dim)};
+  std::vector<Edge> edges;
+  for (Node v : MakeStrongIntRange(num_nodes)) {
+    for (int d = 0; d < dim; ++d) {
+      const Node w = Neighbor(v, d);
+      if (v < w) {
+        edges.push_back({v, w});
+      }
+    }
+  }
+  // All nodes are optional.
+  util_intops::StrongVector<Node, bool> must_be_visited(num_nodes);
+  // To break symmetry, we can fix a few variables.
+  if (absl::GetFlag(FLAGS_fix)) {
+    Node start{0};
+    Node one = Neighbor(start, 0);
+    Node two = Neighbor(one, 1);
+    must_be_visited[start] = true;
+    must_be_visited[one] = true;
+    must_be_visited[two] = true;
+  }
+  const models::CircuitConstraint circuit(must_be_visited, /*directed=*/false,
+                                          edges);
+
+  math_opt::Model model;
+  const models::MathOptCircuit math_circuit(circuit, &model);
+  // We can also fix some edges.
+  if (absl::GetFlag(FLAGS_fix)) {
+    Node start{0};
+    Node one = Neighbor(start, 0);
+    Node two = Neighbor(one, 1);
+    model.set_lower_bound(math_circuit.edge_var_or_die({start, one}), 1.0);
+    model.set_lower_bound(math_circuit.edge_var_or_die({one, two}), 1.0);
+  }
+  math_opt::LinearExpression nodes_hit;
+  for (Node v : MakeStrongIntRange(num_nodes)) {
+    nodes_hit += math_circuit.node(v);
+    for (int d = 0; d < dim; ++d) {
+      const Node w = Neighbor(v, d);
+      if (v < w) {
+        model.AddLinearConstraint(math_circuit.node(v) + math_circuit.node(w) <=
+                                  1 + math_circuit.edge_var_or_die({v, w}));
+      }
+    }
+  }
+  if (absl::GetFlag(FLAGS_medusa)) {
+    util_intops::StrongVector<Node, math_opt::LinearExpression> num_adj;
+    for (const Node n : MakeStrongIntRange(num_nodes)) {
+      num_adj.push_back(2 * math_circuit.node(n));
+    }
+    // 2-Medusa cuts
+    for (Node v1 : MakeStrongIntRange(num_nodes)) {
+      for (int i = 0; i < dim; ++i) {
+        for (int j = i + 1; j < dim; ++j) {
+          Node v2 = Neighbor(v1, i);
+          Node v3 = Neighbor(v1, j);
+          Node v4 = Neighbor(v2, j);
+          if (v1 > v2 && v1 > v3 && v1 > v4) {
+            math_opt::LinearExpression arcs =
+                num_adj[v1] + num_adj[v2] + num_adj[v3] + num_adj[v4];
+            for (const auto edge :
+                 std::vector<Edge>({{v1, v2}, {v1, v3}, {v2, v4}, {v3, v4}})) {
+              arcs -= math_circuit.edge_var_or_die(edge);
+            }
+            model.AddLinearConstraint(arcs <= 4.0);
+          }
+        }
+      }
+    }
+    // 3-Medusa cuts
+    for (Node flip_none : MakeStrongIntRange(num_nodes)) {
+      for (int i = 0; i < dim; ++i) {
+        for (int j = i + 1; j < dim; ++j) {
+          for (int j = i + 1; j < dim; ++j) {
+            for (int k = j + 1; k < dim; ++k) {
+              Node flip_i = Neighbor(flip_none, i);
+              Node flip_j = Neighbor(flip_none, j);
+              Node flip_k = Neighbor(flip_none, k);
+              Node flip_ij = Neighbor(flip_i, j);
+              Node flip_ik = Neighbor(flip_i, k);
+              Node flip_jk = Neighbor(flip_j, k);
+              Node flip_ijk = Neighbor(flip_ij, k);
+              const std::vector<Node> nodes = {flip_none, flip_i,  flip_j,
+                                               flip_k,    flip_ij, flip_ik,
+                                               flip_jk,   flip_ijk};
+              if (flip_none != *absl::c_max_element(nodes)) {
+                continue;
+              }
+              math_opt::LinearExpression arcs;
+              for (const Node n : nodes) {
+                arcs += num_adj[n];
+              }
+              std::vector<Edge> internal_edges = {
+                  {flip_none, flip_i}, {flip_none, flip_j},
+                  {flip_none, flip_k}, {flip_i, flip_ij},
+                  {flip_i, flip_ik},   {flip_j, flip_ij},
+                  {flip_j, flip_jk},   {flip_k, flip_ik},
+                  {flip_k, flip_jk},   {flip_ij, flip_ijk},
+                  {flip_jk, flip_ijk}, {flip_ik, flip_ijk}};
+
+              for (const auto edge : internal_edges) {
+                arcs -= math_circuit.edge_var_or_die(edge);
+              }
+              model.AddLinearConstraint(arcs <= 6.0);
+            }
+          }
+        }
+      }
+    }
+  }
+  model.Maximize(nodes_hit);
+  const math_opt::SolverType solver = absl::GetFlag(FLAGS_gurobi)
+                                          ? math_opt::SolverType::kGurobi
+                                          : math_opt::SolverType::kGscip;
+  math_opt::SolveArguments args;
+  args.callback_registration = {
+      .events = {math_opt::CallbackEvent::kMipNode,
+                 math_opt::CallbackEvent::kMipSolution},
+      .add_lazy_constraints = true};
+  args.parameters = {.enable_output = true,
+                     .time_limit = absl::GetFlag(FLAGS_time_limit),
+                     .threads = absl::GetFlag(FLAGS_threads)};
+  args.callback =
+      [&math_circuit](
+          const math_opt::CallbackData& data) -> math_opt::CallbackResult {
+    switch (data.event) {
+      case math_opt::CallbackEvent::kMipNode:
+        return OnMipNode(math_circuit, data).value();
+      case math_opt::CallbackEvent::kMipSolution:
+        return OnMipSolution(math_circuit, data).value();
+      default:
+        LOG(FATAL) << "unexpected event: " << data.event;
+    }
+  };
+  ASSIGN_OR_RETURN(const math_opt::SolveResult result,
+                   RunSolve(model, solver, std::move(args)));
+  RETURN_IF_ERROR(result.termination.EnsureIsOptimalOrFeasible());
+  std::cout << "Objective value: " << result.objective_value() << std::endl;
+  return absl::OkStatus();
+}
+}  // namespace
+
+int main(int argc, char** argv) {
+  InitGoogle(argv[0], &argc, &argv, true);
+  const absl::Status status = Main();
+  if (!status.ok()) {
+    LOG(QFATAL) << status;
+  }
+  return 0;
+}
diff --git a/ortools/math_opt/samples/python/BUILD.bazel b/ortools/math_opt/samples/python/BUILD.bazel
index a5ae3c7119..b85d3cfcc1 100644
--- a/ortools/math_opt/samples/python/BUILD.bazel
+++ b/ortools/math_opt/samples/python/BUILD.bazel
@@ -114,7 +114,6 @@ py_binary(
     deps = [
         requirement("absl-py"),
         "//ortools/math_opt/python:mathopt",
-        "//ortools/math_opt/solvers:highs_solver",
     ],
 )
 
diff --git a/ortools/math_opt/samples/python/linear_regression.py b/ortools/math_opt/samples/python/linear_regression.py
index b48367421d..b44f86c9ac 100644
--- a/ortools/math_opt/samples/python/linear_regression.py
+++ b/ortools/math_opt/samples/python/linear_regression.py
@@ -39,9 +39,6 @@ where noise is a command line flag.
 After solving the optimization problem above to recover values for beta, the
 in sample and out of sample loss (average squared prediction error) for the
 learned model are printed.
-
-For an advanced version, see:
-  ortools/math_opt/codelabs/regression/
 """
 from collections.abc import Sequence
 import dataclasses
diff --git a/ortools/math_opt/solver_tests/CMakeLists.txt b/ortools/math_opt/solver_tests/CMakeLists.txt
index 5bc081ca76..7e0fdfdb00 100644
--- a/ortools/math_opt/solver_tests/CMakeLists.txt
+++ b/ortools/math_opt/solver_tests/CMakeLists.txt
@@ -22,7 +22,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
   TESTING
 )
@@ -36,7 +36,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     absl::status
     absl::strings
@@ -56,7 +56,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
     ortools::math_opt_test_models
@@ -72,7 +72,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
     ortools::math_opt_base_solver_test
@@ -88,7 +88,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
     ortools::math_opt_test_models
@@ -104,7 +104,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_base_solver_test
   TESTING
@@ -118,7 +118,7 @@ ortools_cxx_library(
 #  SOURCES
 #    "unregistered_solver_test.cc"
 #  LINK_LIBRARIES
-#    GTest::gmock
+#    ortools::base_gmock
 #    GTest::gmock_main
 #)
 
@@ -131,7 +131,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     absl::status
     ortools::math_opt_matchers
@@ -148,7 +148,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
     ortools::math_opt_base_solver_test
@@ -164,7 +164,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::strings
     ortools::math_opt_matchers
   TESTING
@@ -179,7 +179,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
     ortools::math_opt_base_solver_test
@@ -195,7 +195,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     absl::status
     absl::strings
@@ -212,7 +212,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     absl::status
     ortools::math_opt_base_solver_test
@@ -228,7 +228,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
     ortools::math_opt_test_models
@@ -244,7 +244,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
   TESTING
@@ -259,7 +259,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
   TESTING
@@ -274,7 +274,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
   TESTING
@@ -289,7 +289,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
   TESTING
@@ -304,7 +304,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
   TESTING
@@ -331,7 +331,7 @@ ortools_cxx_test(
   SOURCES
     "test_models_test.cc"
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     GTest::gmock_main
     ortools::math_opt_test_models
     ortools::math_opt_matchers
@@ -347,7 +347,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     ortools::math_opt_matchers
     ortools::math_opt_test_models
@@ -363,7 +363,7 @@ ortools_cxx_library(
   TYPE
     STATIC
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     absl::log
     absl::status
     absl::strings
diff --git a/ortools/math_opt/solver_tests/invalid_input_tests.cc b/ortools/math_opt/solver_tests/invalid_input_tests.cc
index ac48389327..3c4ce8d073 100644
--- a/ortools/math_opt/solver_tests/invalid_input_tests.cc
+++ b/ortools/math_opt/solver_tests/invalid_input_tests.cc
@@ -23,7 +23,6 @@
 #include "absl/strings/str_join.h"
 #include "gtest/gtest.h"
 #include "ortools/base/gmock.h"
-#include "ortools/base/status-matchers.h"
 #include "ortools/math_opt/core/solver.h"
 #include "ortools/math_opt/cpp/math_opt.h"
 #include "ortools/math_opt/model.pb.h"
diff --git a/ortools/math_opt/solvers/BUILD.bazel b/ortools/math_opt/solvers/BUILD.bazel
index dd709bb88b..4afc38fe2d 100644
--- a/ortools/math_opt/solvers/BUILD.bazel
+++ b/ortools/math_opt/solvers/BUILD.bazel
@@ -72,39 +72,6 @@ cc_library(
     alwayslink = 1,
 )
 
-cc_test(
-    name = "gscip_solver_test",
-    size = "medium",
-    srcs = ["gscip_solver_test.cc"],
-    shard_count = 10,
-    deps = [
-        ":gscip_solver",
-        "//ortools/base:gmock",
-        "//ortools/base:gmock_main",
-        "//ortools/math_opt/cpp:matchers",
-        "//ortools/math_opt/cpp:math_opt",
-        "//ortools/math_opt/solver_tests:callback_tests",
-        "//ortools/math_opt/solver_tests:generic_tests",
-        "//ortools/math_opt/solver_tests:infeasible_subsystem_tests",
-        "//ortools/math_opt/solver_tests:invalid_input_tests",
-        "//ortools/math_opt/solver_tests:ip_model_solve_parameters_tests",
-        "//ortools/math_opt/solver_tests:ip_multiple_solutions_tests",
-        "//ortools/math_opt/solver_tests:ip_parameter_tests",
-        "//ortools/math_opt/solver_tests:logical_constraint_tests",
-        "//ortools/math_opt/solver_tests:mip_tests",
-        "//ortools/math_opt/solver_tests:multi_objective_tests",
-        "//ortools/math_opt/solver_tests:qc_tests",
-        "//ortools/math_opt/solver_tests:qp_tests",
-        "//ortools/math_opt/solver_tests:second_order_cone_tests",
-        "//ortools/math_opt/solver_tests:status_tests",
-        "//ortools/math_opt/solvers/gscip:gscip_parameters",
-        "//ortools/math_opt/testing:param_name",
-        "//ortools/port:scoped_std_stream_capture",
-        "@abseil-cpp//absl/status",
-        "@abseil-cpp//absl/status:statusor",
-    ],
-)
-
 cc_library(
     name = "gurobi_callback",
     srcs = ["gurobi_callback.cc"],
@@ -122,7 +89,6 @@ cc_library(
         "//ortools/math_opt/core:solver_interface",
         "//ortools/math_opt/core:sparse_vector_view",
         "//ortools/math_opt/solvers/gurobi:g_gurobi",
-        "//ortools/third_party_solvers:gurobi_environment",
         "//ortools/util:solve_interrupter",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/status",
@@ -172,7 +138,6 @@ cc_library(
         "//ortools/math_opt/solvers/gurobi:g_gurobi",
         "//ortools/math_opt/validators:callback_validator",
         "//ortools/port:proto_utils",
-        "//ortools/third_party_solvers:gurobi_environment",
         "//ortools/util:solve_interrupter",
         "//ortools/util:testing_utils",
         "@abseil-cpp//absl/algorithm:container",
@@ -316,7 +281,7 @@ cc_test(
     name = "cp_sat_solver_test",
     timeout = "eternal",
     srcs = ["cp_sat_solver_test.cc"],
-    shard_count = 10,
+    tags = ["manual"],
     deps = [
         ":cp_sat_solver",
         "//ortools/base:gmock_main",
@@ -394,7 +359,6 @@ cc_library(
         "pdlp_solver.cc",
         "pdlp_solver.h",
     ],
-    visibility = ["//visibility:public"],
     deps = [
         ":pdlp_bridge",
         "//ortools/base:protoutil",
@@ -433,7 +397,6 @@ cc_test(
     name = "pdlp_solver_test",
     size = "small",
     srcs = ["pdlp_solver_test.cc"],
-    shard_count = 10,
     deps = [
         ":pdlp_solver",
         "//ortools/base:gmock",
@@ -467,6 +430,11 @@ cc_library(
         "glpk_solver.cc",
         "glpk_solver.h",
     ],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     visibility = ["//visibility:public"],
     deps = [
         ":glpk_cc_proto",
@@ -515,6 +483,11 @@ cc_library(
 cc_test(
     name = "glpk_solver_test",
     srcs = ["glpk_solver_test.cc"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         ":glpk_solver",
         "//ortools/base:gmock_main",
@@ -608,7 +581,6 @@ cc_test(
     name = "highs_solver_test",
     srcs = ["highs_solver_test.cc"],
     flaky = 1,
-    shard_count = 10,
     # See note above ":highs_solver" rule.
     tags = ["nosan"],
     deps = [
diff --git a/ortools/math_opt/solvers/CMakeLists.txt b/ortools/math_opt/solvers/CMakeLists.txt
index be2c08b6fd..143207c13c 100644
--- a/ortools/math_opt/solvers/CMakeLists.txt
+++ b/ortools/math_opt/solvers/CMakeLists.txt
@@ -69,7 +69,7 @@ if(USE_SCIP)
     SOURCES
       "gscip_solver_test.cc"
     LINK_LIBRARIES
-      GTest::gmock
+      ortools::base_gmock
       GTest::gmock_main
       absl::status
       ortools::math_opt_matchers
@@ -88,6 +88,11 @@ if(USE_SCIP)
       "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_second_order_cone_tests>"
       "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_status_tests>"
   )
+  if(MSVC)
+    # Test fail on windows, to investigate.
+    set_tests_properties(cxx_math_opt_solvers_gscip_solver_test
+      PROPERTIES DISABLED TRUE)
+  endif()
 endif()
 
 if(USE_GLOP)
@@ -97,7 +102,7 @@ if(USE_GLOP)
     SOURCES
       "glop_solver_test.cc"
     LINK_LIBRARIES
-      GTest::gmock
+      ortools::base_gmock
       GTest::gmock_main
       absl::status
       ortools::math_opt_matchers
@@ -125,7 +130,7 @@ ortools_cxx_test(
   SOURCES
     "cp_sat_solver_test.cc"
   LINK_LIBRARIES
-    GTest::gmock
+    ortools::base_gmock
     GTest::gmock_main
     absl::status
     ortools::math_opt_matchers
@@ -144,6 +149,9 @@ ortools_cxx_test(
     "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_second_order_cone_tests>"
     "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_status_tests>"
 )
+# This test is too long so we currently disable it.
+set_tests_properties(cxx_math_opt_solvers_cp_sat_solver_test
+  PROPERTIES DISABLED TRUE)
 
 ortools_cxx_test(
   NAME
@@ -163,7 +171,7 @@ if(USE_PDLP)
     SOURCES
       "pdlp_solver_test.cc"
     LINK_LIBRARIES
-      GTest::gmock
+      ortools::base_gmock
       GTest::gmock_main
       absl::status
       "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_callback_tests>"
@@ -191,7 +199,7 @@ if(USE_GLPK)
     SOURCES
       "glpk_solver_test.cc"
     LINK_LIBRARIES
-      GTest::gmock
+      ortools::base_gmock
       GTest::gmock_main
       absl::status
       absl::time
@@ -223,7 +231,7 @@ if(USE_HIGHS)
     SOURCES
       "highs_solver_test.cc"
     LINK_LIBRARIES
-      GTest::gmock
+      ortools::base_gmock
       GTest::gmock_main
       absl::status
       ortools::math_opt_matchers
@@ -241,34 +249,40 @@ if(USE_HIGHS)
       "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_multi_objective_tests>"
       "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_status_tests>"
   )
+  if(MSVC)
+    # Test fail on windows, to investigate.
+    set_tests_properties(cxx_math_opt_solvers_highs_solver_test
+      PROPERTIES DISABLED TRUE)
+  endif()
 endif()
 
 if(USE_XPRESS)
   ortools_cxx_test(
-          NAME
-          math_opt_solvers_xpress_solver_test
-          SOURCES
-          "xpress_solver_test.cc"
-          LINK_LIBRARIES
-          GTest::gtest
-          absl::status
-          ortools::math_opt_matchers
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_callback_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_invalid_input_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_generic_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_infeasible_subsystem_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_ip_model_solve_parameters_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_ip_parameter_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_logical_constraint_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_incomplete_solve_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_model_solve_parameters_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_parameter_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_mip_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_multi_objective_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_status_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_qp_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_second_order_cone_tests>"
-          "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_qc_tests>"
+    NAME
+      math_opt_solvers_xpress_solver_test
+    SOURCES
+      "xpress_solver_test.cc"
+    LINK_LIBRARIES
+      ortools::base_gmock
+      GTest::gmock_main
+      absl::status
+      ortools::math_opt_matchers
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_callback_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_invalid_input_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_generic_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_infeasible_subsystem_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_ip_model_solve_parameters_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_ip_parameter_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_logical_constraint_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_incomplete_solve_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_model_solve_parameters_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_parameter_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_lp_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_mip_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_multi_objective_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_status_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_qp_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_second_order_cone_tests>"
+      "$<LINK_LIBRARY:WHOLE_ARCHIVE,ortools::math_opt_qc_tests>"
   )
 endif()
diff --git a/ortools/math_opt/solvers/glpk/BUILD.bazel b/ortools/math_opt/solvers/glpk/BUILD.bazel
index b96e5107a8..e11a2751a0 100644
--- a/ortools/math_opt/solvers/glpk/BUILD.bazel
+++ b/ortools/math_opt/solvers/glpk/BUILD.bazel
@@ -21,6 +21,11 @@ cc_library(
     name = "rays",
     srcs = ["rays.cc"],
     hdrs = ["rays.h"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         "//ortools/base:logging",
         "//ortools/base:status_macros",
@@ -38,6 +43,11 @@ cc_library(
     name = "glpk_sparse_vector",
     srcs = ["glpk_sparse_vector.cc"],
     hdrs = ["glpk_sparse_vector.h"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         "//ortools/base:logging",
         "@abseil-cpp//absl/log:check",
@@ -47,6 +57,11 @@ cc_library(
 cc_test(
     name = "glpk_sparse_vector_test",
     srcs = ["glpk_sparse_vector_test.cc"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         ":glpk_sparse_vector",
         "//ortools/base:gmock_main",
@@ -57,11 +72,21 @@ cc_library(
     name = "gap",
     srcs = ["gap.cc"],
     hdrs = ["gap.h"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
 )
 
 cc_test(
     name = "gap_test",
     srcs = ["gap_test.cc"],
+    target_compatible_with =
+        select({
+            "//ortools/linear_solver:use_glpk": [],
+            "//conditions:default": ["@platforms//:incompatible"],
+        }),
     deps = [
         ":gap",
         "//ortools/base:gmock_main",
diff --git a/ortools/math_opt/solvers/gscip/BUILD.bazel b/ortools/math_opt/solvers/gscip/BUILD.bazel
index f211e12694..01474cd389 100644
--- a/ortools/math_opt/solvers/gscip/BUILD.bazel
+++ b/ortools/math_opt/solvers/gscip/BUILD.bazel
@@ -39,7 +39,7 @@ cc_proto_library(
 )
 
 py_proto_library(
-    name = "gscip_proto_py_pb2",
+    name = "gscip_py_pb2",
     visibility = ["//visibility:public"],
     deps = [":gscip_proto"],
 )
@@ -123,33 +123,6 @@ cc_library(
     ],
 )
 
-cc_test(
-    name = "gscip_test",
-    size = "small",
-    srcs = ["gscip_test.cc"],
-    deps = [
-        ":gscip",
-        ":gscip_cc_proto",
-        ":gscip_parameters",
-        ":gscip_testing",
-        "//ortools/base:file",
-        "//ortools/base:gmock",
-        "//ortools/base:gmock_main",
-        "//ortools/base:logging",
-        "//ortools/base:temp_file",
-        "@abseil-cpp//absl/cleanup",
-        "@abseil-cpp//absl/container:flat_hash_map",
-        "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log:check",
-        "@abseil-cpp//absl/status",
-        "@abseil-cpp//absl/status:statusor",
-        "@abseil-cpp//absl/strings",
-        "@abseil-cpp//absl/synchronization",
-        "@abseil-cpp//absl/time",
-        "@scip",
-    ],
-)
-
 cc_test(
     name = "gscip_io_test",
     size = "medium",
@@ -235,21 +208,6 @@ cc_library(
     ],
 )
 
-cc_test(
-    name = "gscip_from_mp_model_proto_test",
-    srcs = ["gscip_from_mp_model_proto_test.cc"],
-    deps = [
-        ":gscip",
-        ":gscip_cc_proto",
-        ":gscip_from_mp_model_proto",
-        ":gscip_testing",
-        "//ortools/base:gmock",
-        "//ortools/base:gmock_main",
-        "//ortools/base:parse_test_proto",
-        "//ortools/linear_solver:linear_solver_cc_proto",
-    ],
-)
-
 cc_library(
     name = "gscip_message_handler",
     srcs = ["gscip_message_handler.cc"],
diff --git a/ortools/math_opt/solvers/gscip/gscip_event_handler_test.cc b/ortools/math_opt/solvers/gscip/gscip_event_handler_test.cc
index 963428c0e9..f3d485d874 100644
--- a/ortools/math_opt/solvers/gscip/gscip_event_handler_test.cc
+++ b/ortools/math_opt/solvers/gscip/gscip_event_handler_test.cc
@@ -219,7 +219,6 @@ TEST(GScipEventHandlerDeathTest, ErrorReturnedByInit) {
         ASSERT_OK(handler.Register(gscip.get()));
 
         const absl::Status status = gscip->Solve().status();
-        LOG(ERROR) << "status: " << status;
         if (!status.ok() &&
             absl::StrContains(status.message(), "SCIP error code -8")) {
           // Write the expected marker only if we see the expected error.
diff --git a/ortools/math_opt/solvers/highs_solver.cc b/ortools/math_opt/solvers/highs_solver.cc
index ac730f5115..0bf7506b27 100644
--- a/ortools/math_opt/solvers/highs_solver.cc
+++ b/ortools/math_opt/solvers/highs_solver.cc
@@ -219,7 +219,7 @@ absl::StatusOr<std::unique_ptr<HighsOptions>> MakeOptions(
   if (parameters.has_threads()) {
     // Do not assign result.threads = parameters.threads() here, this is
     // requires global synchronization. See
-    // cs/highs/src/lp_data/Highs.cpp:607
+    // highs/src/lp_data/Highs.cpp:607
     return util::InvalidArgumentErrorBuilder()
            << "threads not supported for HiGHS solver, this must be set using "
               "globals, see HiGHS documentation";
diff --git a/ortools/math_opt/solvers/message_callback_data.cc b/ortools/math_opt/solvers/message_callback_data.cc
index 7878963604..d37f5da7ae 100644
--- a/ortools/math_opt/solvers/message_callback_data.cc
+++ b/ortools/math_opt/solvers/message_callback_data.cc
@@ -72,7 +72,7 @@ void BufferedMessageCallback::OnMessage(absl::string_view message) {
   }
   std::vector<std::string> messages;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     messages = message_callback_data_.Parse(message);
   }
   // Do not hold lock during callback to user code.
@@ -87,7 +87,7 @@ void BufferedMessageCallback::Flush() {
   }
   std::vector<std::string> messages;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     messages = message_callback_data_.Flush();
   }
   // Do not hold lock during callback to user code.
diff --git a/ortools/math_opt/solvers/osqp.proto b/ortools/math_opt/solvers/osqp.proto
index 5103137746..f064d977c3 100644
--- a/ortools/math_opt/solvers/osqp.proto
+++ b/ortools/math_opt/solvers/osqp.proto
@@ -92,8 +92,8 @@ message OsqpSettingsProto {
 // LINT.ThenChange(osqp_solver.cc:merge_from_proto,
 // osqp_solver.cc:must_initialize, osqp_solver.cc:solve,
 // osqp_solver.cc:try_overwrite_with_current_values,
-// //depot/osqp_cpp/include/osqp++.h:osqp_settings,
-// //depot/osqp_cpp/src/osqp++.cc:settings_translation)
+// osqp_cpp/include/osqp++.h:osqp_settings,
+// osqp_cpp/src/osqp++.cc:settings_translation)
 
 // Solver-specific output for OSQP.
 message OsqpOutput {
diff --git a/ortools/math_opt/storage/update_trackers.h b/ortools/math_opt/storage/update_trackers.h
index 7e67c7e1c7..c2f0511e99 100644
--- a/ortools/math_opt/storage/update_trackers.h
+++ b/ortools/math_opt/storage/update_trackers.h
@@ -159,7 +159,7 @@ void UpdateTrackers<Data>::UpdateHasPendingActions() {
 template <typename Data>
 template <typename... Args>
 UpdateTrackerId UpdateTrackers<Data>::NewUpdateTracker(Args&&... args) {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
 
   const UpdateTrackerId update_tracker = next_update_tracker_;
   ++next_update_tracker_;
@@ -192,7 +192,7 @@ UpdateTrackers<Data>::FindTracker(const std::vector<IdDataPair>& v,
 template <typename Data>
 void UpdateTrackers<Data>::DeleteUpdateTracker(
     const UpdateTrackerId update_tracker) {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
 
   // The delete trackers may still be in pending_new_trackers_. We have to
   // remove it from there.
@@ -233,7 +233,7 @@ UpdateTrackers<Data>::GetUpdatedTrackers() {
   // Using a non-relaxed memory order has significant impact on performances
   // here.
   if (has_pending_actions_.load(std::memory_order_relaxed)) {
-    const absl::MutexLock lock(&mutex_);
+    const absl::MutexLock lock(mutex_);
 
     // Flush removed trackers.
     gtl::STLEraseAllFromSequenceIf(
@@ -262,7 +262,7 @@ UpdateTrackers<Data>::GetUpdatedTrackers() {
 
 template <typename Data>
 Data& UpdateTrackers<Data>::GetData(UpdateTrackerId update_tracker) {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
   // Note that here we could apply the pending actions. We don't do so to keep
   // the symmetry with the const overload below.
 
@@ -290,7 +290,7 @@ Data& UpdateTrackers<Data>::GetData(UpdateTrackerId update_tracker) {
 template <typename Data>
 const Data& UpdateTrackers<Data>::GetData(
     UpdateTrackerId update_tracker) const {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
   // The tracker may still be in pending_new_trackers_.
   {
     const auto found_new = FindTracker(pending_new_trackers_, update_tracker);
diff --git a/ortools/math_opt/testing/BUILD.bazel b/ortools/math_opt/testing/BUILD.bazel
index dc2bfcb7bb..ec32eaf17b 100644
--- a/ortools/math_opt/testing/BUILD.bazel
+++ b/ortools/math_opt/testing/BUILD.bazel
@@ -13,7 +13,7 @@
 
 load("@rules_cc//cc:cc_library.bzl", "cc_library")
 
-package(default_visibility = ["//ortools:__subpackages__"])
+package(default_visibility = ["//visibility:public"])
 
 cc_library(
     name = "param_name",
diff --git a/ortools/math_opt/validators/BUILD.bazel b/ortools/math_opt/validators/BUILD.bazel
index f9b4cb4ac4..0e6e5f4000 100644
--- a/ortools/math_opt/validators/BUILD.bazel
+++ b/ortools/math_opt/validators/BUILD.bazel
@@ -13,7 +13,7 @@
 
 load("@rules_cc//cc:cc_library.bzl", "cc_library")
 
-package(default_visibility = ["//ortools:__subpackages__"])
+package(default_visibility = ["//visibility:public"])
 
 cc_library(
     name = "ids_validator",
diff --git a/ortools/pdlp/BUILD.bazel b/ortools/pdlp/BUILD.bazel
index dcef03144e..91a0e872f4 100644
--- a/ortools/pdlp/BUILD.bazel
+++ b/ortools/pdlp/BUILD.bazel
@@ -36,9 +36,9 @@ cc_test(
     name = "scheduler_test",
     srcs = ["scheduler_test.cc"],
     deps = [
-        ":gtest_main",
         ":scheduler",
         ":solvers_cc_proto",
+        "//ortools/base:gmock_main",
         "@abseil-cpp//absl/functional:any_invocable",
     ],
 )
@@ -77,15 +77,6 @@ py_proto_library(
     ],
 )
 
-cc_library(
-    name = "gtest_main",
-    srcs = ["gtest_main.cc"],
-    deps = [
-        "//ortools/base",
-        "//ortools/base:gmock",
-    ],
-)
-
 cc_library(
     name = "iteration_stats",
     srcs = ["iteration_stats.cc"],
@@ -107,13 +98,13 @@ cc_test(
     name = "iteration_stats_test",
     srcs = ["iteration_stats_test.cc"],
     deps = [
-        ":gtest_main",
         ":iteration_stats",
         ":quadratic_program",
         ":sharded_quadratic_program",
         ":solve_log_cc_proto",
         ":solvers_cc_proto",
         ":test_util",
+        "//ortools/base:gmock_main",
         "//ortools/base:protobuf_util",
         "@eigen",
     ],
@@ -162,7 +153,6 @@ cc_test(
     srcs = ["primal_dual_hybrid_gradient_test.cc"],
     shard_count = 3,
     deps = [
-        ":gtest_main",
         ":iteration_stats",
         ":primal_dual_hybrid_gradient",
         ":quadratic_program",
@@ -173,6 +163,7 @@ cc_test(
         ":termination",
         ":test_util",
         "//ortools/base",
+        "//ortools/base:gmock_main",
         "//ortools/glop:parameters_cc_proto",
         "//ortools/linear_solver:linear_solver_cc_proto",
         "//ortools/lp_data",
@@ -204,9 +195,9 @@ cc_test(
     size = "small",
     srcs = ["quadratic_program_test.cc"],
     deps = [
-        ":gtest_main",
         ":quadratic_program",
         ":test_util",
+        "//ortools/base:gmock_main",
         "//ortools/base:protobuf_util",
         "//ortools/base:status_macros",
         "//ortools/linear_solver:linear_solver_cc_proto",
@@ -260,13 +251,13 @@ cc_test(
     size = "small",
     srcs = ["sharded_optimization_utils_test.cc"],
     deps = [
-        ":gtest_main",
         ":quadratic_program",
         ":sharded_optimization_utils",
         ":sharded_quadratic_program",
         ":sharder",
         ":solve_log_cc_proto",
         ":test_util",
+        "//ortools/base:gmock_main",
         "@eigen",
     ],
 )
@@ -292,11 +283,11 @@ cc_test(
     name = "sharded_quadratic_program_test",
     srcs = ["sharded_quadratic_program_test.cc"],
     deps = [
-        ":gtest_main",
         ":quadratic_program",
         ":sharded_quadratic_program",
         ":sharder",
         ":test_util",
+        "//ortools/base:gmock_main",
         "@eigen",
     ],
 )
@@ -324,11 +315,11 @@ cc_test(
     size = "small",
     srcs = ["sharder_test.cc"],
     deps = [
-        ":gtest_main",
         ":scheduler",
         ":sharder",
         ":solvers_cc_proto",
         "//ortools/base",
+        "//ortools/base:gmock_main",
         "//ortools/base:mathutil",
         "@abseil-cpp//absl/random:distributions",
         "@eigen",
@@ -351,9 +342,9 @@ cc_test(
     name = "solvers_proto_validation_test",
     srcs = ["solvers_proto_validation_test.cc"],
     deps = [
-        ":gtest_main",
         ":solvers_cc_proto",
         ":solvers_proto_validation",
+        "//ortools/base:gmock_main",
         "//ortools/base:protobuf_util",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
@@ -376,10 +367,10 @@ cc_test(
     size = "small",
     srcs = ["termination_test.cc"],
     deps = [
-        ":gtest_main",
         ":solve_log_cc_proto",
         ":solvers_cc_proto",
         ":termination",
+        "//ortools/base:gmock_main",
         "//ortools/base:protobuf_util",
     ],
 )
@@ -402,9 +393,9 @@ cc_test(
     name = "test_util_test",
     srcs = ["test_util_test.cc"],
     deps = [
-        ":gtest_main",
         ":test_util",
         "//ortools/base",
+        "//ortools/base:gmock_main",
         "@abseil-cpp//absl/types:span",
         "@eigen",
     ],
@@ -430,13 +421,13 @@ cc_test(
     name = "trust_region_test",
     srcs = ["trust_region_test.cc"],
     deps = [
-        ":gtest_main",
         ":quadratic_program",
         ":sharded_optimization_utils",
         ":sharded_quadratic_program",
         ":sharder",
         ":test_util",
         ":trust_region",
+        "//ortools/base:gmock_main",
         "@abseil-cpp//absl/strings",
         "@eigen",
     ],
diff --git a/ortools/pdlp/gtest_main.cc b/ortools/pdlp/gtest_main.cc
deleted file mode 100644
index 428d419f2f..0000000000
--- a/ortools/pdlp/gtest_main.cc
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2010-2025 Google LLC
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "gtest/gtest.h"
-#include "ortools/base/commandlineflags.h"
-#include "ortools/base/init_google.h"
-#include "ortools/base/logging.h"
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  google::InitGoogleLogging(argv[0]);
-  absl::ParseCommandLine(argc, argv);
-  return RUN_ALL_TESTS();
-}
diff --git a/ortools/pdlp/python/BUILD.bazel b/ortools/pdlp/python/BUILD.bazel
index 9b8f675819..423313a3f1 100644
--- a/ortools/pdlp/python/BUILD.bazel
+++ b/ortools/pdlp/python/BUILD.bazel
@@ -42,8 +42,6 @@ py_test(
     data = [
         ":pdlp.so",
     ],
-    python_version = "PY3",
-    srcs_version = "PY3",
     deps = [
         requirement("absl-py"),
         requirement("numpy"),
diff --git a/ortools/port/BUILD.bazel b/ortools/port/BUILD.bazel
index 6c5639dee5..5a619731a9 100644
--- a/ortools/port/BUILD.bazel
+++ b/ortools/port/BUILD.bazel
@@ -15,6 +15,11 @@ load("@rules_cc//cc:cc_library.bzl", "cc_library")
 
 package(default_visibility = ["//visibility:public"])
 
+cc_library(
+    name = "os",
+    hdrs = ["os.h"],
+)
+
 cc_library(
     name = "sysinfo",
     srcs = ["sysinfo.cc"],
diff --git a/ortools/port/os.h b/ortools/port/os.h
new file mode 100644
index 0000000000..a4827a4bc2
--- /dev/null
+++ b/ortools/port/os.h
@@ -0,0 +1,42 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Defines macros about target OS and whether it supports threads.
+#ifndef OR_TOOLS_PORT_OS_H_
+#define OR_TOOLS_PORT_OS_H_
+
+#if defined(__ANDROID__)
+#define ORTOOLS_TARGET_OS_IS_ANDROID
+#endif
+
+#if (defined(__apple__) || defined(__APPLE__) || defined(__MACH__))
+// From https://stackoverflow.com/a/49560690
+#include "TargetConditionals.h"
+#if TARGET_OS_IPHONE == 1
+#define ORTOOLS_TARGET_OS_IS_IOS
+#endif
+#endif
+
+#if defined(__EMSCRIPTEN__)
+#define ORTOOLS_TARGET_OS_IS_EMSCRIPTEN
+#endif
+
+#if defined(ORTOOLS_TARGET_OS_IS_ANDROID) || \
+    defined(ORTOOLS_TARGET_OS_IS_IOS) ||     \
+    defined(ORTOOLS_TARGET_OS_IS_EMSCRIPTEN)
+#define ORTOOLS_TARGET_OS_SUPPORTS_THREADS 0
+#else
+#define ORTOOLS_TARGET_OS_SUPPORTS_THREADS 1
+#endif
+
+#endif  // OR_TOOLS_PORT_OS_H_
diff --git a/ortools/python/setup.py.in b/ortools/python/setup.py.in
index 67abcc54b6..b778bff4b1 100644
--- a/ortools/python/setup.py.in
+++ b/ortools/python/setup.py.in
@@ -46,7 +46,7 @@ setup(
         'absl-py >= 2.0.0',
         'numpy >= 2.0.2',
         'pandas >= 2.0.0',
-        'protobuf >= 6.31.1,<6.32',
+        'protobuf >= 6.32.0,<6.33',
         'typing-extensions >= 4.12',
         'immutabledict >= 3.0.0',
     ],
diff --git a/ortools/sat/2d_distances_propagator.cc b/ortools/sat/2d_distances_propagator.cc
index a5e614e921..f8972599df 100644
--- a/ortools/sat/2d_distances_propagator.cc
+++ b/ortools/sat/2d_distances_propagator.cc
@@ -164,6 +164,7 @@ IntegerValue Precedences2DPropagator::UpperBound(
 }
 
 bool Precedences2DPropagator::Propagate() {
+  if (!helper_.IsEnforced()) return true;
   if (last_helper_inprocessing_count_ != helper_.InProcessingCount()) {
     if (!helper_.SynchronizeAndSetDirection()) return false;
     last_helper_inprocessing_count_ = helper_.InProcessingCount();
@@ -176,9 +177,6 @@ bool Precedences2DPropagator::Propagate() {
 
   num_calls_++;
 
-  SchedulingConstraintHelper* helpers[2] = {&helper_.x_helper(),
-                                            &helper_.y_helper()};
-
   for (const PairData& pair_data : pair_data_) {
     if (!absl::c_all_of(pair_data.pair_presence_literals,
                         [this](const Literal& literal) {
@@ -206,24 +204,14 @@ bool Precedences2DPropagator::Propagate() {
 
     const int box1 = pair_data.box1;
     const int box2 = pair_data.box2;
-    helper_.ClearReason();
+    helper_.ResetReason();
     num_conflicts_++;
 
-    for (int dim = 0; dim < 2; dim++) {
-      SchedulingConstraintHelper* helper = helpers[dim];
-      for (int j = 0; j < 2; j++) {
-        int b1 = box1;
-        int b2 = box2;
-        if (j == 1) {
-          std::swap(b1, b2);
-        }
-        const auto [expr, ub] = EncodeDifferenceLowerThan(
-            helper->Starts()[b1], helper->Ends()[b2], -1);
-        linear2_bounds_->AddReasonForUpperBoundLowerThan(
-            expr, ub, helper_.x_helper().MutableLiteralReason(),
-            helper_.x_helper().MutableIntegerReason());
-      }
-    }
+    helper_.x_helper().AddReasonForBeingBeforeAssumingNoOverlap(box1, box2);
+    helper_.x_helper().AddReasonForBeingBeforeAssumingNoOverlap(box2, box1);
+    helper_.y_helper().AddReasonForBeingBeforeAssumingNoOverlap(box1, box2);
+    helper_.y_helper().AddReasonForBeingBeforeAssumingNoOverlap(box2, box1);
+
     helper_.AddPresenceReason(box1);
     helper_.AddPresenceReason(box2);
     return helper_.ReportConflict();
diff --git a/ortools/sat/2d_mandatory_overlap_propagator.cc b/ortools/sat/2d_mandatory_overlap_propagator.cc
index 6974d67f35..63aeb26db6 100644
--- a/ortools/sat/2d_mandatory_overlap_propagator.cc
+++ b/ortools/sat/2d_mandatory_overlap_propagator.cc
@@ -51,6 +51,7 @@ MandatoryOverlapPropagator::~MandatoryOverlapPropagator() {
 }
 
 bool MandatoryOverlapPropagator::Propagate() {
+  if (!helper_.IsEnforced()) return true;
   if (!helper_.SynchronizeAndSetDirection()) return false;
 
   mandatory_regions_.clear();
diff --git a/ortools/sat/2d_try_edge_propagator.cc b/ortools/sat/2d_try_edge_propagator.cc
index c8616d9fda..fb9b6366a4 100644
--- a/ortools/sat/2d_try_edge_propagator.cc
+++ b/ortools/sat/2d_try_edge_propagator.cc
@@ -136,6 +136,7 @@ bool TryEdgeRectanglePropagator::CanPlace(
 }
 
 bool TryEdgeRectanglePropagator::Propagate() {
+  if (!helper_.IsEnforced()) return true;
   if (!helper_.SynchronizeAndSetDirection(
           x_is_forward_after_swap_, y_is_forward_after_swap_, swap_x_and_y_)) {
     return false;
@@ -368,7 +369,7 @@ bool TryEdgeRectanglePropagator::ExplainAndPropagate(
         found_propagations) {
   for (const auto& [box_index, new_x_min] : found_propagations) {
     const RectangleInRange& box = active_box_ranges_[box_index];
-    helper_.ClearReason();
+    helper_.ResetReason();
 
     const std::vector<int> minimum_problem_with_propagator =
         GetMinimumProblemWithPropagation(
diff --git a/ortools/sat/2d_try_edge_propagator_test.cc b/ortools/sat/2d_try_edge_propagator_test.cc
index 1dfe81e8e0..7b7734d122 100644
--- a/ortools/sat/2d_try_edge_propagator_test.cc
+++ b/ortools/sat/2d_try_edge_propagator_test.cc
@@ -158,7 +158,7 @@ NoOverlap2DConstraintHelper* CreateHelper(
     y_intervals.push_back(y_interval);
   }
   return model->GetOrCreate<IntervalsRepository>()->GetOrCreate2DHelper(
-      x_intervals, y_intervals);
+      /*enforcement_literals=*/{}, x_intervals, y_intervals);
 }
 
 TEST(TryEdgeRectanglePropagatorTest, Simple) {
diff --git a/ortools/sat/BUILD.bazel b/ortools/sat/BUILD.bazel
index bc5c0039e8..8333f1ebee 100644
--- a/ortools/sat/BUILD.bazel
+++ b/ortools/sat/BUILD.bazel
@@ -28,6 +28,7 @@ cc_library(
     name = "cp_model",
     srcs = ["cp_model.cc"],
     hdrs = ["cp_model.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_solver",
@@ -55,9 +56,9 @@ cc_test(
         ":cp_model_solver",
         ":model",
         ":sat_parameters_cc_proto",
-        "//ortools/base",
         "//ortools/base:container_logging",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/base:parse_test_proto",
         "//ortools/util:sorted_interval_list",
         "@abseil-cpp//absl/types:span",
@@ -67,6 +68,7 @@ cc_test(
 cc_library(
     name = "model",
     hdrs = ["model.h"],
+    visibility = ["//visibility:public"],
     deps = [
         "//ortools/base",
         "//ortools/base:typeid",
@@ -89,20 +91,24 @@ cc_test(
 proto_library(
     name = "sat_parameters_proto",
     srcs = ["sat_parameters.proto"],
+    visibility = ["//visibility:public"],
 )
 
 cc_proto_library(
     name = "sat_parameters_cc_proto",
+    visibility = ["//visibility:public"],
     deps = [":sat_parameters_proto"],
 )
 
 py_proto_library(
     name = "sat_parameters_py_pb2",
+    visibility = ["//visibility:public"],
     deps = [":sat_parameters_proto"],
 )
 
 java_proto_library(
     name = "sat_parameters_java_proto",
+    visibility = ["//visibility:public"],
     deps = [":sat_parameters_proto"],
 )
 
@@ -110,11 +116,13 @@ go_proto_library(
     name = "sat_parameters_go_proto",
     importpath = "github.com/google/or-tools/ortools/sat/proto/satparameters",
     protos = [":sat_parameters_proto"],
+    visibility = ["//visibility:public"],
 )
 
 proto_library(
     name = "cp_model_proto",
     srcs = ["cp_model.proto"],
+    visibility = ["//visibility:public"],
 )
 
 cc_library(
@@ -170,9 +178,10 @@ cc_library(
         ":cp_model_utils",
         ":presolve_context",
         ":sat_parameters_cc_proto",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:protobuf_util",
         "//ortools/util:sorted_interval_list",
+        "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/log:check",
@@ -236,7 +245,7 @@ cc_library(
         ":sat_base",
         ":sat_solver",
         ":synchronization",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:stl_util",
         "//ortools/base:strong_vector",
         "//ortools/util:bitset",
@@ -250,18 +259,44 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "container",
+    hdrs = ["container.h"],
+    deps = [
+        ":sat_base",
+        "//ortools/base:stl_util",
+        "@abseil-cpp//absl/base",
+        "@abseil-cpp//absl/container:inlined_vector",
+        "@abseil-cpp//absl/log:check",
+        "@abseil-cpp//absl/types:span",
+    ],
+)
+
+cc_test(
+    name = "container_test",
+    srcs = ["container_test.cc"],
+    deps = [
+        ":container",
+        ":sat_base",
+        "//ortools/base:gmock_main",
+    ],
+)
+
 cc_proto_library(
     name = "cp_model_cc_proto",
+    visibility = ["//visibility:public"],
     deps = [":cp_model_proto"],
 )
 
 py_proto_library(
     name = "cp_model_py_pb2",
+    visibility = ["//visibility:public"],
     deps = [":cp_model_proto"],
 )
 
 java_proto_library(
     name = "cp_model_java_proto",
+    visibility = ["//visibility:public"],
     deps = [":cp_model_proto"],
 )
 
@@ -269,12 +304,14 @@ go_proto_library(
     name = "cp_model_go_proto",
     importpath = "github.com/google/or-tools/ortools/sat/proto/cpmodel",
     protos = [":cp_model_proto"],
+    visibility = ["//visibility:public"],
 )
 
 cc_library(
     name = "cp_model_utils",
     srcs = ["cp_model_utils.cc"],
     hdrs = ["cp_model_utils.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":sat_base",
@@ -314,6 +351,7 @@ cc_library(
     name = "synchronization",
     srcs = ["synchronization.cc"],
     hdrs = ["synchronization.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_utils",
@@ -380,6 +418,7 @@ cc_library(
     name = "cp_model_checker",
     srcs = ["cp_model_checker.cc"],
     hdrs = ["cp_model_checker.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_utils",
@@ -420,6 +459,7 @@ cc_library(
     name = "constraint_violation",
     srcs = ["constraint_violation.cc"],
     hdrs = ["constraint_violation.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_utils",
@@ -450,9 +490,9 @@ cc_test(
         ":constraint_violation",
         ":cp_model_cc_proto",
         ":cp_model_utils",
-        "//ortools/base",
         "//ortools/base:dump_vars",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/base:parse_test_proto",
         "//ortools/util:sorted_interval_list",
         "//ortools/util:time_limit",
@@ -464,6 +504,7 @@ cc_library(
     name = "feasibility_jump",
     srcs = ["feasibility_jump.cc"],
     hdrs = ["feasibility_jump.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":combine_solutions",
         ":constraint_violation",
@@ -510,6 +551,7 @@ cc_library(
     name = "linear_model",
     srcs = ["linear_model.cc"],
     hdrs = ["linear_model.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_utils",
@@ -538,6 +580,7 @@ cc_library(
     name = "parameters_validation",
     srcs = ["parameters_validation.cc"],
     hdrs = ["parameters_validation.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_search",
         ":sat_parameters_cc_proto",
@@ -609,6 +652,7 @@ cc_library(
     name = "cp_model_solver_helpers",
     srcs = ["cp_model_solver_helpers.cc"],
     hdrs = ["cp_model_solver_helpers.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":circuit",
         ":clause",
@@ -660,6 +704,7 @@ cc_library(
         "//ortools/base",
         "//ortools/base:status_macros",
         "//ortools/base:strong_vector",
+        "//ortools/base:threadpool",
         "//ortools/base:timer",
         "//ortools/base:types",
         "//ortools/graph:connected_components",
@@ -697,6 +742,7 @@ cc_library(
     name = "shaving_solver",
     srcs = ["shaving_solver.cc"],
     hdrs = ["shaving_solver.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_copy",
@@ -729,6 +775,7 @@ cc_library(
     name = "cp_model_solver",
     srcs = ["cp_model_solver.cc"],
     hdrs = ["cp_model_solver.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":circuit",
         ":clause",
@@ -791,6 +838,7 @@ cc_library(
         "//ortools/base:types",
         "//ortools/graph:connected_components",
         "//ortools/linear_solver:linear_solver_cc_proto",
+        "//ortools/port:os",
         "//ortools/port:proto_utils",
         "//ortools/util:logging",
         "//ortools/util:random_engine",
@@ -836,7 +884,9 @@ cc_test(
         "//ortools/base:gmock_main",
         "//ortools/base:parse_test_proto",
         "//ortools/linear_solver:linear_solver_cc_proto",
+        "//ortools/port:os",
         "//ortools/util:logging",
+        "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/strings",
     ],
@@ -845,6 +895,7 @@ cc_test(
 cc_library(
     name = "cp_model_mapping",
     hdrs = ["cp_model_mapping.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_utils",
@@ -864,6 +915,7 @@ cc_library(
     name = "cp_model_loader",
     srcs = ["cp_model_loader.cc"],
     hdrs = ["cp_model_loader.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":2d_distances_propagator",
         ":all_different",
@@ -935,6 +987,10 @@ proto_library(
 
 cc_proto_library(
     name = "boolean_problem_cc_proto",
+    visibility = [
+        "//ortools/bop:__pkg__",
+        "//visibility:public",
+    ],
     deps = [":boolean_problem_proto"],
 )
 
@@ -1005,7 +1061,7 @@ cc_library(
         ":sat_solver",
         ":solution_crush",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/port:proto_utils",
         "//ortools/util:affine_relation",
         "//ortools/util:bitset",
@@ -1021,7 +1077,6 @@ cc_library(
         "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/log:vlog_is_on",
-        "@abseil-cpp//absl/meta:type_traits",
         "@abseil-cpp//absl/numeric:int128",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/types:span",
@@ -1214,9 +1269,9 @@ cc_test(
         ":cp_model_solver",
         ":cp_model_utils",
         ":sat_parameters_cc_proto",
-        "//ortools/base",
         "//ortools/base:file",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/base:path",
         "//ortools/util:sorted_interval_list",
         "@abseil-cpp//absl/flags:flag",
@@ -1273,7 +1328,7 @@ cc_library(
         ":sat_parameters_cc_proto",
         ":solution_crush",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:stl_util",
         "//ortools/port:proto_utils",
         "//ortools/util:logging",
@@ -1308,6 +1363,7 @@ cc_test(
         "//ortools/base:container_logging",
         "//ortools/base:gmock_main",
         "//ortools/base:parse_test_proto",
+        "//ortools/base:parse_text_proto",
         "//ortools/util:sorted_interval_list",
         "@abseil-cpp//absl/container:btree",
         "@abseil-cpp//absl/strings",
@@ -1356,6 +1412,7 @@ cc_library(
     deps = [
         ":clause",
         ":drat_proof_handler",
+        ":enforcement",
         ":model",
         ":pb_constraint",
         ":restart",
@@ -1395,7 +1452,7 @@ cc_library(
         ":model",
         ":sat_decision",
         ":sat_parameters_cc_proto",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/port:proto_utils",
         "//ortools/util:bitset",
         "//ortools/util:running_stat",
@@ -1559,6 +1616,7 @@ cc_library(
     srcs = ["clause.cc"],
     hdrs = ["clause.h"],
     deps = [
+        ":container",
         ":drat_proof_handler",
         ":inclusion",
         ":model",
@@ -1742,7 +1800,8 @@ cc_library(
         ":solution_crush",
         ":util",
         "//ortools/algorithms:dynamic_partition",
-        "//ortools/base",
+        "//ortools/base:hash",
+        "//ortools/base:logging",
         "//ortools/base:mathutil",
         "//ortools/base:stl_util",
         "//ortools/base:strong_vector",
@@ -1780,6 +1839,7 @@ cc_library(
     name = "integer_base",
     srcs = ["integer_base.cc"],
     hdrs = ["integer_base.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":sat_base",
         "//ortools/base",
@@ -1810,6 +1870,7 @@ cc_library(
     name = "integer",
     srcs = ["integer.cc"],
     hdrs = ["integer.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":integer_base",
         ":model",
@@ -1863,7 +1924,7 @@ cc_library(
         ":scheduling_helpers",
         ":synchronization",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/util:strong_integers",
         "//ortools/util:time_limit",
         "@abseil-cpp//absl/container:flat_hash_set",
@@ -1889,8 +1950,8 @@ cc_test(
         ":integer_search",
         ":model",
         ":sat_parameters_cc_proto",
-        "//ortools/base",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/util:random_engine",
         "@abseil-cpp//absl/container:flat_hash_set",
     ],
@@ -1915,7 +1976,7 @@ cc_library(
         ":sat_solver",
         ":synchronization",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:strong_vector",
         "//ortools/glop:variables_info",
         "//ortools/util:strong_integers",
@@ -1956,7 +2017,7 @@ cc_library(
         ":sat_base",
         ":sat_parameters_cc_proto",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:strong_vector",
         "//ortools/util:strong_integers",
         "@abseil-cpp//absl/log:check",
@@ -2026,6 +2087,8 @@ cc_library(
     srcs = ["scheduling_helpers.cc"],
     hdrs = ["scheduling_helpers.h"],
     deps = [
+        ":enforcement",
+        ":enforcement_helper",
         ":implied_bounds",
         ":integer",
         ":integer_base",
@@ -2035,7 +2098,7 @@ cc_library(
         ":precedences",
         ":sat_base",
         ":sat_solver",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/util:bitset",
         "//ortools/util:sort",
         "//ortools/util:strong_integers",
@@ -2053,6 +2116,8 @@ cc_library(
     deps = [
         ":2d_rectangle_presolve",
         ":diffn_util",
+        ":enforcement",
+        ":enforcement_helper",
         ":integer",
         ":integer_base",
         ":model",
@@ -2087,6 +2152,7 @@ cc_library(
     name = "precedences",
     srcs = ["precedences.cc"],
     hdrs = ["precedences.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":clause",
         ":cp_constraints",
@@ -2152,8 +2218,8 @@ cc_test(
         ":model",
         ":sat_base",
         ":sat_solver",
-        "//ortools/base",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/util:sorted_interval_list",
         "//ortools/util:strong_integers",
         "@abseil-cpp//absl/log:check",
@@ -2166,8 +2232,11 @@ cc_library(
     name = "integer_expr",
     srcs = ["integer_expr.cc"],
     hdrs = ["integer_expr.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_constraints",
+        ":enforcement",
+        ":enforcement_helper",
         ":integer",
         ":integer_base",
         ":linear_constraint",
@@ -2207,9 +2276,10 @@ cc_test(
         ":sat_base",
         ":sat_parameters_cc_proto",
         ":sat_solver",
-        "//ortools/base",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/base:parse_test_proto",
+        "//ortools/base:parse_text_proto",
         "//ortools/port:proto_utils",
         "//ortools/util:saturated_arithmetic",
         "//ortools/util:sorted_interval_list",
@@ -2228,7 +2298,8 @@ cc_library(
     srcs = ["linear_propagation.cc"],
     hdrs = ["linear_propagation.h"],
     deps = [
-        ":cp_constraints",
+        ":enforcement",
+        ":enforcement_helper",
         ":integer",
         ":integer_base",
         ":model",
@@ -2244,6 +2315,7 @@ cc_library(
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/base:log_severity",
         "@abseil-cpp//absl/cleanup",
+        "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/container:inlined_vector",
         "@abseil-cpp//absl/log",
@@ -2278,7 +2350,8 @@ cc_library(
     srcs = ["all_different.cc"],
     hdrs = ["all_different.h"],
     deps = [
-        ":cp_constraints",
+        ":enforcement",
+        ":enforcement_helper",
         ":integer",
         ":integer_base",
         ":model",
@@ -2307,6 +2380,7 @@ cc_test(
         ":integer_base",
         ":integer_search",
         ":model",
+        ":sat_base",
         ":sat_solver",
         "//ortools/base",
         "//ortools/base:gmock_main",
@@ -2329,13 +2403,16 @@ cc_library(
         ":precedences",
         ":sat_base",
         ":sat_parameters_cc_proto",
+        ":scheduling_helpers",
         ":synchronization",
         ":timetable",
         ":util",
         "//ortools/util:scheduling",
         "//ortools/util:sort",
         "//ortools/util:strong_integers",
+        "//ortools/util:time_limit",
         "@abseil-cpp//absl/algorithm:container",
+        "@abseil-cpp//absl/base:log_severity",
         "@abseil-cpp//absl/cleanup",
         "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/log:check",
@@ -2376,9 +2453,10 @@ cc_library(
     srcs = ["timetable.cc"],
     hdrs = ["timetable.h"],
     deps = [
+        ":enforcement",
+        ":enforcement_helper",
         ":integer",
         ":integer_base",
-        ":intervals",
         ":model",
         ":sat_base",
         ":scheduling_helpers",
@@ -2448,6 +2526,7 @@ cc_library(
         ":sat_base",
         ":sat_parameters_cc_proto",
         ":sat_solver",
+        ":scheduling_helpers",
         ":timetable",
         ":timetable_edgefinding",
         "//ortools/base",
@@ -2462,7 +2541,6 @@ cc_test(
     name = "cumulative_test",
     size = "large",
     srcs = ["cumulative_test.cc"],
-    shard_count = 32,
     deps = [
         ":cumulative",
         ":integer",
@@ -2603,7 +2681,7 @@ cc_library(
         ":scheduling_cuts",
         ":scheduling_helpers",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:mathutil",
         "//ortools/base:stl_util",
         "//ortools/base:strong_vector",
@@ -2635,6 +2713,7 @@ cc_test(
         ":linear_relaxation",
         ":model",
         ":sat_base",
+        ":scheduling_helpers",
         "//ortools/base:gmock_main",
         "//ortools/base:parse_test_proto",
         "//ortools/util:sorted_interval_list",
@@ -2647,6 +2726,7 @@ cc_library(
     name = "linear_constraint",
     srcs = ["linear_constraint.cc"],
     hdrs = ["linear_constraint.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":integer",
         ":integer_base",
@@ -2766,8 +2846,8 @@ cc_library(
         ":sat_parameters_cc_proto",
         ":synchronization",
         ":util",
-        "//ortools/base",
         "//ortools/base:hash",
+        "//ortools/base:logging",
         "//ortools/base:strong_vector",
         "//ortools/glop:variables_info",
         "//ortools/lp_data:base",
@@ -2866,10 +2946,12 @@ cc_test(
 proto_library(
     name = "routes_support_graph_proto",
     srcs = ["routes_support_graph.proto"],
+    visibility = ["//visibility:public"],
 )
 
 cc_proto_library(
     name = "routes_support_graph_cc_proto",
+    visibility = ["//visibility:public"],
     deps = [":routes_support_graph_proto"],
 )
 
@@ -3039,7 +3121,7 @@ cc_library(
     deps = [
         ":integer_base",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/lp_data:base",
         "//ortools/util:strong_integers",
         "@abseil-cpp//absl/log:check",
@@ -3199,6 +3281,7 @@ cc_library(
         ":sat_base",
         ":sat_parameters_cc_proto",
         "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:mathutil",
         "//ortools/base:stl_util",
         "//ortools/util:random_engine",
@@ -3234,8 +3317,8 @@ cc_test(
         ":sat_base",
         ":sat_parameters_cc_proto",
         ":util",
-        "//ortools/base",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/base:mathutil",
         "//ortools/base:stl_util",
         "//ortools/util:random_engine",
@@ -3301,9 +3384,9 @@ cc_test(
         ":sat_parameters_cc_proto",
         ":sat_solver",
         ":table",
-        "//ortools/base",
         "//ortools/base:container_logging",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "//ortools/base:parse_test_proto",
         "@abseil-cpp//absl/container:btree",
         "@abseil-cpp//absl/types:span",
@@ -3314,18 +3397,16 @@ cc_library(
     name = "cp_constraints",
     srcs = ["cp_constraints.cc"],
     hdrs = ["cp_constraints.h"],
+    visibility = ["//visibility:public"],
     deps = [
+        ":enforcement",
+        ":enforcement_helper",
         ":integer",
         ":integer_base",
         ":model",
         ":sat_base",
-        ":sat_solver",
         "//ortools/base",
-        "//ortools/base:stl_util",
-        "//ortools/base:strong_vector",
         "//ortools/util:strong_integers",
-        "@abseil-cpp//absl/base:core_headers",
-        "@abseil-cpp//absl/container:inlined_vector",
         "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/types:span",
     ],
@@ -3343,8 +3424,61 @@ cc_test(
         ":precedences",
         ":sat_base",
         ":sat_solver",
-        "//ortools/base",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
+        "@abseil-cpp//absl/types:span",
+    ],
+)
+
+cc_library(
+    name = "enforcement",
+    srcs = ["enforcement.cc"],
+    hdrs = ["enforcement.h"],
+    deps = [
+        ":model",
+        ":sat_base",
+        "//ortools/base:stl_util",
+        "//ortools/base:strong_vector",
+        "//ortools/util:rev",
+        "//ortools/util:strong_integers",
+        "@abseil-cpp//absl/container:inlined_vector",
+        "@abseil-cpp//absl/log:check",
+        "@abseil-cpp//absl/types:span",
+    ],
+)
+
+cc_test(
+    name = "enforcement_test",
+    srcs = ["enforcement_test.cc"],
+    deps = [
+        ":enforcement",
+        ":model",
+        ":sat_base",
+        ":sat_solver",
+        "//ortools/base:gmock_main",
+        "//ortools/base:logging",
+        "@abseil-cpp//absl/log:check",
+        "@abseil-cpp//absl/types:span",
+    ],
+)
+
+cc_library(
+    name = "enforcement_helper",
+    srcs = ["enforcement_helper.cc"],
+    hdrs = ["enforcement_helper.h"],
+    deps = [
+        ":enforcement",
+        ":integer",
+        ":integer_base",
+        ":model",
+        ":sat_base",
+        ":sat_solver",
+        "//ortools/base:stl_util",
+        "//ortools/base:strong_vector",
+        "//ortools/util:strong_integers",
+        "@abseil-cpp//absl/base:core_headers",
+        "@abseil-cpp//absl/container:inlined_vector",
+        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/types:span",
     ],
 )
@@ -3357,7 +3491,7 @@ cc_library(
         ":integer_base",
         ":scheduling_helpers",
         ":util",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:stl_util",
         "//ortools/base:strong_vector",
         "//ortools/graph:connected_components",
@@ -3573,8 +3707,8 @@ cc_test(
         ":diffn_util",
         ":integer_base",
         ":util",
-        "//ortools/base",
         "//ortools/base:gmock",
+        "//ortools/base:logging",
         "//ortools/graph:connected_components",
         "//ortools/graph:strongly_connected_components",
         "//ortools/util:saturated_arithmetic",
@@ -3650,8 +3784,8 @@ cc_test(
         ":sat_base",
         ":sat_parameters_cc_proto",
         ":sat_solver",
-        "//ortools/base",
         "//ortools/base:gmock_main",
+        "//ortools/base:logging",
         "@abseil-cpp//absl/strings",
     ],
 )
@@ -3663,6 +3797,8 @@ cc_library(
     deps = [
         ":all_different",
         ":clause",
+        ":enforcement",
+        ":enforcement_helper",
         ":integer",
         ":model",
         ":sat_base",
@@ -3676,7 +3812,6 @@ cc_library(
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/log:check",
-        "@abseil-cpp//absl/meta:type_traits",
         "@abseil-cpp//absl/types:span",
     ],
 )
@@ -3738,6 +3873,7 @@ cc_library(
     name = "cp_model_lns",
     srcs = ["cp_model_lns.cc"],
     hdrs = ["cp_model_lns.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_copy",
@@ -3816,6 +3952,7 @@ cc_library(
     name = "feasibility_pump",
     srcs = ["feasibility_pump.cc"],
     hdrs = ["feasibility_pump.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_mapping",
         ":integer",
@@ -3869,6 +4006,7 @@ cc_library(
     name = "rins",
     srcs = ["rins.cc"],
     hdrs = ["rins.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":cp_model_mapping",
         ":integer_base",
@@ -3905,6 +4043,7 @@ cc_library(
     name = "subsolver",
     srcs = ["subsolver.cc"],
     hdrs = ["subsolver.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":util",
         "//ortools/base",
@@ -3959,8 +4098,8 @@ cc_library(
     hdrs = ["drat_checker.h"],
     deps = [
         ":sat_base",
-        "//ortools/base",
         "//ortools/base:hash",
+        "//ortools/base:logging",
         "//ortools/base:strong_vector",
         "//ortools/util:strong_integers",
         "//ortools/util:time_limit",
@@ -4007,7 +4146,7 @@ cc_library(
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_utils",
-        "//ortools/base",
+        "//ortools/base:logging",
         "//ortools/base:stl_util",
         "//ortools/util:filelineiter",
         "@abseil-cpp//absl/base:core_headers",
@@ -4082,6 +4221,7 @@ cc_binary(
 cc_library(
     name = "sat_cnf_reader",
     hdrs = ["sat_cnf_reader.h"],
+    visibility = ["//visibility:public"],
     deps = [
         ":boolean_problem_cc_proto",
         ":cp_model_cc_proto",
@@ -4134,8 +4274,8 @@ cc_library(
         "//ortools/algorithms:binary_search",
         "//ortools/algorithms:find_graph_symmetries",
         "//ortools/algorithms:sparse_permutation",
-        "//ortools/base",
         "//ortools/base:hash",
+        "//ortools/base:logging",
         "//ortools/graph",
         "//ortools/util:affine_relation",
         "//ortools/util:logging",
@@ -4178,6 +4318,10 @@ cc_library(
     name = "swig_helper",
     srcs = ["swig_helper.cc"],
     hdrs = ["swig_helper.h"],
+    visibility = [
+        "//ortools/sat/java:__pkg__",
+        "//ortools/sat/python:__pkg__",
+    ],
     deps = [
         ":cp_model_cc_proto",
         ":cp_model_checker",
diff --git a/ortools/sat/all_different.cc b/ortools/sat/all_different.cc
index 6b47c5d96f..aab63a6551 100644
--- a/ortools/sat/all_different.cc
+++ b/ortools/sat/all_different.cc
@@ -14,9 +14,7 @@
 #include "ortools/sat/all_different.h"
 
 #include <algorithm>
-#include <cstdint>
 #include <functional>
-#include <limits>
 #include <utility>
 #include <vector>
 
@@ -27,6 +25,7 @@
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
 #include "ortools/graph/strongly_connected_components.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
@@ -74,14 +73,13 @@ std::function<void(Model*)> AllDifferentBinary(
 }
 
 std::function<void(Model*)> AllDifferentOnBounds(
+    absl::Span<const Literal> enforcement_literals,
     absl::Span<const AffineExpression> expressions) {
   return [=, expressions = std::vector<AffineExpression>(
                  expressions.begin(), expressions.end())](Model* model) {
     if (expressions.empty()) return;
-    auto* constraint = new AllDifferentBoundsPropagator(
-        expressions, model->GetOrCreate<IntegerTrail>());
-    constraint->RegisterWith(model->GetOrCreate<GenericLiteralWatcher>());
-    model->TakeOwnership(constraint);
+    model->TakeOwnership(new AllDifferentBoundsPropagator(enforcement_literals,
+                                                          expressions, model));
   };
 }
 
@@ -95,10 +93,8 @@ std::function<void(Model*)> AllDifferentOnBounds(
     for (const IntegerVariable var : vars) {
       expressions.push_back(AffineExpression(var));
     }
-    auto* constraint = new AllDifferentBoundsPropagator(
-        expressions, model->GetOrCreate<IntegerTrail>());
-    constraint->RegisterWith(model->GetOrCreate<GenericLiteralWatcher>());
-    model->TakeOwnership(constraint);
+    model->TakeOwnership(new AllDifferentBoundsPropagator(
+        /*enforcement_literals=*/{}, expressions, model));
   };
 }
 
@@ -417,8 +413,10 @@ bool AllDifferentConstraint::Propagate() {
 }
 
 AllDifferentBoundsPropagator::AllDifferentBoundsPropagator(
-    absl::Span<const AffineExpression> expressions, IntegerTrail* integer_trail)
-    : integer_trail_(integer_trail) {
+    absl::Span<const Literal> enforcement_literals,
+    absl::Span<const AffineExpression> expressions, Model* model)
+    : integer_trail_(*model->GetOrCreate<IntegerTrail>()),
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   CHECK(!expressions.empty());
 
   // We need +2 for sentinels.
@@ -432,9 +430,18 @@ AllDifferentBoundsPropagator::AllDifferentBoundsPropagator(
     bounds_.push_back({expressions[i]});
     negated_bounds_.push_back({expressions[i].Negated()});
   }
+
+  GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
 }
 
 bool AllDifferentBoundsPropagator::Propagate() {
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status != EnforcementStatus::IS_ENFORCED &&
+      status != EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT) {
+    return true;
+  }
   if (!PropagateLowerBounds()) return false;
 
   // Note that it is not required to swap back bounds_ and negated_bounds_.
@@ -478,8 +485,8 @@ int AllDifferentBoundsPropagator::FindStartIndexAndCompressPath(int index) {
 bool AllDifferentBoundsPropagator::PropagateLowerBounds() {
   // Start by filling the cached bounds and sorting by increasing lb.
   for (CachedBounds& entry : bounds_) {
-    entry.lb = integer_trail_->LowerBound(entry.expr);
-    entry.ub = integer_trail_->UpperBound(entry.expr);
+    entry.lb = integer_trail_.LowerBound(entry.expr);
+    entry.ub = integer_trail_.UpperBound(entry.expr);
   }
   IncrementalSort(bounds_.begin(), bounds_.end(),
                   [](CachedBounds a, CachedBounds b) { return a.lb < b.lb; });
@@ -561,9 +568,17 @@ bool AllDifferentBoundsPropagator::PropagateLowerBoundsInternal(
         const IntegerValue he = hall_ends_[hall_index];
         FillHallReason(hs, he);
         integer_reason_.push_back(expr.GreaterOrEqual(hs));
-        if (!integer_trail_->SafeEnqueue(expr.GreaterOrEqual(he + 1),
-                                         integer_reason_)) {
-          return false;
+        if (enforcement_helper_.Status(enforcement_id_) ==
+            EnforcementStatus::IS_ENFORCED) {
+          if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                               expr.GreaterOrEqual(he + 1),
+                                               integer_reason_)) {
+            return false;
+          }
+        } else if (he >= entry.ub) {
+          integer_reason_.push_back(expr.LowerOrEqual(entry.ub));
+          return enforcement_helper_.PropagateWhenFalse(
+              enforcement_id_, /*literal_reason=*/{}, integer_reason_);
         }
       }
     }
@@ -607,7 +622,7 @@ bool AllDifferentBoundsPropagator::PropagateLowerBoundsInternal(
     // we abort so that the conflict reason will be better on the next call to
     // the propagator.
     const IntegerValue end = GetValue(end_index);
-    if (end > integer_trail_->UpperBound(expr)) return true;
+    if (end > integer_trail_.UpperBound(expr)) return true;
 
     // If we have a new Hall interval, add it to the set. Note that it will
     // always be last, and if it overlaps some previous Hall intervals, it
@@ -630,13 +645,13 @@ bool AllDifferentBoundsPropagator::PropagateLowerBoundsInternal(
   return true;
 }
 
-void AllDifferentBoundsPropagator::RegisterWith(
-    GenericLiteralWatcher* watcher) {
+int AllDifferentBoundsPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
   const int id = watcher->Register(this);
   for (const CachedBounds& entry : bounds_) {
     watcher->WatchAffineExpression(entry.expr, id);
   }
   watcher->NotifyThatPropagatorMayNotReachFixedPointInOnePass(id);
+  return id;
 }
 
 }  // namespace sat
diff --git a/ortools/sat/all_different.h b/ortools/sat/all_different.h
index 4b202720f9..1d54a305ce 100644
--- a/ortools/sat/all_different.h
+++ b/ortools/sat/all_different.h
@@ -22,10 +22,13 @@
 #include "absl/log/check.h"
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/sat_base.h"
+#include "ortools/sat/util.h"
 #include "ortools/util/bitset.h"
 #include "ortools/util/strong_integers.h"
 
@@ -49,6 +52,7 @@ std::function<void(Model*)> AllDifferentBinary(
 std::function<void(Model*)> AllDifferentOnBounds(
     absl::Span<const IntegerVariable> vars);
 std::function<void(Model*)> AllDifferentOnBounds(
+    absl::Span<const Literal> enforcement_literals,
     absl::Span<const AffineExpression> expressions);
 
 // This constraint forces all variables to take different values. This is meant
@@ -141,10 +145,10 @@ class AllDifferentConstraint : PropagatorInterface {
 // Implements the all different bound consistent propagator with explanation.
 // That is, given n affine expressions that must take different values, this
 // propagates the bounds of each expression as much as possible. The key is to
-// detect the so called Hall interval which are interval of size k that contains
-// the domain of k expressinos. Because all the variables must take different
-// values, we can deduce that the domain of the other variables cannot contains
-// such Hall interval.
+// detect the so called Hall intervals which are intervals of size k that
+// contain the domain of k expressions. Because all the variables must take
+// different values, we can deduce that the domain of the other variables cannot
+// contain such Hall interval.
 //
 // We use a "fast" O(n log n) algorithm.
 //
@@ -153,8 +157,9 @@ class AllDifferentConstraint : PropagatorInterface {
 // https://cs.uwaterloo.ca/~vanbeek/Publications/ijcai03_TR.pdf
 class AllDifferentBoundsPropagator : public PropagatorInterface {
  public:
-  AllDifferentBoundsPropagator(absl::Span<const AffineExpression> expressions,
-                               IntegerTrail* integer_trail);
+  AllDifferentBoundsPropagator(absl::Span<const Literal> enforcement_literals,
+                               absl::Span<const AffineExpression> expressions,
+                               Model* model);
 
   // This type is neither copyable nor movable.
   AllDifferentBoundsPropagator(const AllDifferentBoundsPropagator&) = delete;
@@ -162,7 +167,6 @@ class AllDifferentBoundsPropagator : public PropagatorInterface {
       delete;
 
   bool Propagate() final;
-  void RegisterWith(GenericLiteralWatcher* watcher);
 
  private:
   // We locally cache the lb/ub for faster sorting and to guarantee some
@@ -173,6 +177,8 @@ class AllDifferentBoundsPropagator : public PropagatorInterface {
     IntegerValue ub;
   };
 
+  int RegisterWith(GenericLiteralWatcher* watcher);
+
   // Fills integer_reason_ with the reason why we have the given hall interval.
   void FillHallReason(IntegerValue hall_lb, IntegerValue hall_ub);
 
@@ -208,13 +214,15 @@ class AllDifferentBoundsPropagator : public PropagatorInterface {
 
   IntegerValue GetValue(int index) const { return base_ + IntegerValue(index); }
 
-  IntegerTrail* integer_trail_;
+  const IntegerTrail& integer_trail_;
+  EnforcementHelper& enforcement_helper_;
+  EnforcementId enforcement_id_;
 
   // These vector will be either sorted by lb or by -ub.
   std::vector<CachedBounds> bounds_;
   std::vector<CachedBounds> negated_bounds_;
 
-  // The list of Hall intervalls detected so far, sorted.
+  // The list of Hall intervals detected so far, sorted.
   std::vector<IntegerValue> hall_starts_;
   std::vector<IntegerValue> hall_ends_;
 
diff --git a/ortools/sat/all_different_test.cc b/ortools/sat/all_different_test.cc
index a69afc5eb7..fe8db965cc 100644
--- a/ortools/sat/all_different_test.cc
+++ b/ortools/sat/all_different_test.cc
@@ -27,6 +27,7 @@
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/integer_search.h"
 #include "ortools/sat/model.h"
+#include "ortools/sat/sat_base.h"
 #include "ortools/sat/sat_solver.h"
 #include "ortools/util/sorted_interval_list.h"
 
@@ -156,6 +157,39 @@ TEST_P(AllDifferentTest, EnumerateAllInjections) {
   EXPECT_EQ(num_solutions, Factorial(m) / Factorial(m - n));
 }
 
+TEST(AllDifferentOnBoundsTest, AlwaysFalseWithUnassignedEnforcementLiteral) {
+  Model model;
+  std::vector<IntegerVariable> vars{model.Add(NewIntegerVariable(1, 2)),
+                                    model.Add(NewIntegerVariable(0, 1)),
+                                    model.Add(NewIntegerVariable(1, 2))};
+  const Literal b = Literal(model.Add(NewBooleanVariable()), true);
+  IntegerTrail* integer_trail = model.GetOrCreate<IntegerTrail>();
+  integer_trail->UpdateInitialDomain(vars[0], Domain::FromValues({1, 1}));
+  integer_trail->UpdateInitialDomain(vars[1], Domain::FromValues({0, 0}));
+  // b => all_diff(x, y+1, 2-z), x=y=1 (always false if enforced).
+  model.Add(AllDifferentOnBounds(
+      {b}, {AffineExpression(vars[0], 1), AffineExpression(vars[1], 1, 1),
+            AffineExpression(vars[2], -1, 3)}));
+  EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
+  EXPECT_TRUE(model.GetOrCreate<Trail>()->Assignment().LiteralIsFalse(b));
+  EXPECT_EQ(model.GetOrCreate<IntegerTrail>()->num_enqueues(), 0);
+}
+
+TEST(AllDifferentOnBoundsTest, NotAlwaysFalseWithUnassignedEnforcementLiteral) {
+  Model model;
+  std::vector<IntegerVariable> vars{model.Add(NewIntegerVariable(1, 3)),
+                                    model.Add(NewIntegerVariable(0, 2)),
+                                    model.Add(NewIntegerVariable(1, 3))};
+  const Literal b = Literal(model.Add(NewBooleanVariable()), true);
+  // b => all_diff(x, y+1, 2-z), x,y+1,3-z in [1, 3].
+  model.Add(AllDifferentOnBounds(
+      {b}, {AffineExpression(vars[0], 1), AffineExpression(vars[1], 1, 1),
+            AffineExpression(vars[2], -1, 3)}));
+  EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
+  EXPECT_FALSE(model.GetOrCreate<Trail>()->Assignment().LiteralIsAssigned(b));
+  EXPECT_EQ(model.GetOrCreate<IntegerTrail>()->num_enqueues(), 0);
+}
+
 }  // namespace
 }  // namespace sat
 }  // namespace operations_research
diff --git a/ortools/sat/boolean_problem.cc b/ortools/sat/boolean_problem.cc
index e9b37bc923..958b89b8a2 100644
--- a/ortools/sat/boolean_problem.cc
+++ b/ortools/sat/boolean_problem.cc
@@ -26,7 +26,6 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/flags/flag.h"
 #include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -845,8 +844,8 @@ void ProbeAndSimplifyProblem(SatPostsolver* postsolver,
     }
 
     util_intops::StrongVector<LiteralIndex, LiteralIndex> equiv_map;
-    ProbeAndFindEquivalentLiteral(&solver, postsolver, /*drat_writer=*/nullptr,
-                                  &equiv_map);
+    ProbeAndFindEquivalentLiteral(&solver, postsolver,
+                                  /*drat_proof_handler=*/nullptr, &equiv_map);
 
     // We can abort if no information is learned.
     if (equiv_map.empty() && solver.LiteralTrail().Index() == 0) break;
diff --git a/ortools/sat/circuit.cc b/ortools/sat/circuit.cc
index 8ae427ce78..a21b41efc6 100644
--- a/ortools/sat/circuit.cc
+++ b/ortools/sat/circuit.cc
@@ -20,12 +20,12 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
 #include "ortools/graph/strongly_connected_components.h"
 #include "ortools/sat/all_different.h"
 #include "ortools/sat/clause.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/sat_base.h"
@@ -35,15 +35,15 @@
 namespace operations_research {
 namespace sat {
 
-CircuitPropagator::CircuitPropagator(const int num_nodes,
-                                     absl::Span<const int> tails,
-                                     absl::Span<const int> heads,
-                                     absl::Span<const Literal> literals,
-                                     Options options, Model* model)
+CircuitPropagator::CircuitPropagator(
+    const int num_nodes, absl::Span<const int> tails,
+    absl::Span<const int> heads, absl::Span<const Literal> enforcement_literals,
+    absl::Span<const Literal> literals, Options options, Model* model)
     : num_nodes_(num_nodes),
       options_(options),
-      trail_(model->GetOrCreate<Trail>()),
-      assignment_(trail_->Assignment()) {
+      trail_(*model->GetOrCreate<Trail>()),
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()),
+      assignment_(trail_.Assignment()) {
   CHECK(!tails.empty()) << "Empty constraint, shouldn't be constructed!";
   next_.resize(num_nodes_, -1);
   prev_.resize(num_nodes_, -1);
@@ -60,6 +60,7 @@ CircuitPropagator::CircuitPropagator(const int num_nodes,
 
   graph_.reserve(num_arcs);
   self_arcs_.resize(num_nodes_, kFalseLiteralIndex);
+  enabled_ = true;
   for (int arc = 0; arc < num_arcs; ++arc) {
     const int head = heads[arc];
     const int tail = tails[arc];
@@ -74,9 +75,19 @@ CircuitPropagator::CircuitPropagator(const int num_nodes,
 
     if (assignment_.LiteralIsTrue(literal)) {
       if (next_[tail] != -1 || prev_[head] != -1) {
-        VLOG(1) << "Trivially UNSAT or duplicate arcs while adding " << tail
-                << " -> " << head;
-        model->GetOrCreate<SatSolver>()->NotifyThatModelIsUnsat();
+        SatSolver* sat_solver = model->GetOrCreate<SatSolver>();
+        if (enforcement_literals.empty()) {
+          VLOG(1) << "Trivially UNSAT or duplicate arcs while adding " << tail
+                  << " -> " << head;
+          sat_solver->NotifyThatModelIsUnsat();
+        } else {
+          std::vector<Literal> negated_enforcement_literals;
+          for (const Literal literal : enforcement_literals) {
+            negated_enforcement_literals.push_back(literal.Negated());
+          }
+          sat_solver->AddProblemClause(negated_enforcement_literals);
+          enabled_ = false;
+        }
         return;
       }
       AddArc(tail, head, kNoLiteralIndex);
@@ -108,9 +119,13 @@ CircuitPropagator::CircuitPropagator(const int num_nodes,
       }
     }
   }
+
+  GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
 }
 
-void CircuitPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
+int CircuitPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
   const int id = watcher->Register(this);
   for (int w = 0; w < watch_index_to_literal_.size(); ++w) {
     watcher->WatchLiteral(watch_index_to_literal_[w], id, w);
@@ -123,9 +138,11 @@ void CircuitPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
   //
   // TODO(user): come up with a test that fail when this is not here.
   watcher->NotifyThatPropagatorMayNotReachFixedPointInOnePass(id);
+  return id;
 }
 
 void CircuitPropagator::SetLevel(int level) {
+  if (!enabled_) return;
   if (level == level_ends_.size()) return;
   if (level > level_ends_.size()) {
     while (level > level_ends_.size()) {
@@ -158,6 +175,19 @@ void CircuitPropagator::FillReasonForPath(int start_node,
   }
 }
 
+bool CircuitPropagator::ReportConflictOrPropagateEnforcement(
+    std::vector<Literal>* reason) {
+  if (enforcement_helper_.Status(enforcement_id_) ==
+      EnforcementStatus::IS_ENFORCED) {
+    enforcement_helper_.AddEnforcementReason(enforcement_id_, reason);
+    trail_.MutableConflict()->assign(reason->begin(), reason->end());
+    return false;
+  } else {
+    return enforcement_helper_.PropagateWhenFalse(enforcement_id_, *reason,
+                                                  /*integer_reason=*/{});
+  }
+}
+
 // If multiple_subcircuit_through_zero is true, we never fill next_[0] and
 // prev_[0].
 void CircuitPropagator::AddArc(int tail, int head, LiteralIndex literal_index) {
@@ -172,6 +202,13 @@ void CircuitPropagator::AddArc(int tail, int head, LiteralIndex literal_index) {
 
 bool CircuitPropagator::IncrementalPropagate(
     const std::vector<int>& watch_indices) {
+  if (!enabled_) return true;
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status != EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT &&
+      status != EnforcementStatus::IS_ENFORCED) {
+    return true;
+  }
+
   for (const int w : watch_indices) {
     const Literal literal = watch_index_to_literal_[w];
     for (const Arc arc : watch_index_to_arcs_[w]) {
@@ -184,24 +221,22 @@ bool CircuitPropagator::IncrementalPropagate(
       // Get rid of the trivial conflicts: At most one incoming and one outgoing
       // arc for each nodes.
       if (next_[arc.tail] != -1) {
-        std::vector<Literal>* conflict = trail_->MutableConflict();
         if (next_literal_[arc.tail] != kNoLiteralIndex) {
-          *conflict = {Literal(next_literal_[arc.tail]).Negated(),
-                       literal.Negated()};
+          temp_reason_ = {Literal(next_literal_[arc.tail]).Negated(),
+                          literal.Negated()};
         } else {
-          *conflict = {literal.Negated()};
+          temp_reason_ = {literal.Negated()};
         }
-        return false;
+        return ReportConflictOrPropagateEnforcement(&temp_reason_);
       }
       if (prev_[arc.head] != -1) {
-        std::vector<Literal>* conflict = trail_->MutableConflict();
         if (next_literal_[prev_[arc.head]] != kNoLiteralIndex) {
-          *conflict = {Literal(next_literal_[prev_[arc.head]]).Negated(),
-                       literal.Negated()};
+          temp_reason_ = {Literal(next_literal_[prev_[arc.head]]).Negated(),
+                          literal.Negated()};
         } else {
-          *conflict = {literal.Negated()};
+          temp_reason_ = {literal.Negated()};
         }
-        return false;
+        return ReportConflictOrPropagateEnforcement(&temp_reason_);
       }
 
       // Add the arc.
@@ -215,6 +250,13 @@ bool CircuitPropagator::IncrementalPropagate(
 // This function assumes that next_, prev_, next_literal_ and must_be_in_cycle_
 // are all up to date.
 bool CircuitPropagator::Propagate() {
+  if (!enabled_) return true;
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status != EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT &&
+      status != EnforcementStatus::IS_ENFORCED) {
+    return true;
+  }
+
   processed_.assign(num_nodes_, false);
   for (int n = 0; n < num_nodes_; ++n) {
     if (processed_[n]) continue;
@@ -249,21 +291,23 @@ bool CircuitPropagator::Propagate() {
     if (options_.multiple_subcircuit_through_zero) {
       // Any cycle must contain zero.
       if (start_node == end_node && !in_current_path_[0]) {
-        FillReasonForPath(start_node, trail_->MutableConflict());
-        return false;
+        FillReasonForPath(start_node, &temp_reason_);
+        return ReportConflictOrPropagateEnforcement(&temp_reason_);
       }
 
       // An incomplete path cannot be closed except if one of the end-points
       // is zero.
-      if (start_node != end_node && start_node != 0 && end_node != 0) {
+      if (start_node != end_node && start_node != 0 && end_node != 0 &&
+          status == EnforcementStatus::IS_ENFORCED) {
         const auto it = graph_.find({end_node, start_node});
         if (it == graph_.end()) continue;
         const Literal literal = it->second;
         if (assignment_.LiteralIsFalse(literal)) continue;
 
-        std::vector<Literal>* reason = trail_->GetEmptyVectorToStoreReason();
+        std::vector<Literal>* reason = trail_.GetEmptyVectorToStoreReason();
         FillReasonForPath(start_node, reason);
-        if (!trail_->EnqueueWithStoredReason(literal.Negated())) {
+        enforcement_helper_.AddEnforcementReason(enforcement_id_, reason);
+        if (!trail_.EnqueueWithStoredReason(literal.Negated())) {
           return false;
         }
       }
@@ -291,27 +335,28 @@ bool CircuitPropagator::Propagate() {
     if (miss_some_nodes) {
       // A circuit that miss a mandatory node is a conflict.
       if (start_node == end_node) {
-        FillReasonForPath(start_node, trail_->MutableConflict());
+        FillReasonForPath(start_node, &temp_reason_);
         if (extra_reason != kFalseLiteralIndex) {
-          trail_->MutableConflict()->push_back(Literal(extra_reason));
+          temp_reason_.push_back(Literal(extra_reason));
         }
-        return false;
+        return ReportConflictOrPropagateEnforcement(&temp_reason_);
       }
 
       // We have an unclosed path. Propagate the fact that it cannot
       // be closed into a cycle, i.e. not(end_node -> start_node).
-      if (start_node != end_node) {
+      if (start_node != end_node && status == EnforcementStatus::IS_ENFORCED) {
         const auto it = graph_.find({end_node, start_node});
         if (it == graph_.end()) continue;
         const Literal literal = it->second;
         if (assignment_.LiteralIsFalse(literal)) continue;
 
-        std::vector<Literal>* reason = trail_->GetEmptyVectorToStoreReason();
+        std::vector<Literal>* reason = trail_.GetEmptyVectorToStoreReason();
         FillReasonForPath(start_node, reason);
+        enforcement_helper_.AddEnforcementReason(enforcement_id_, reason);
         if (extra_reason != kFalseLiteralIndex) {
           reason->push_back(Literal(extra_reason));
         }
-        const bool ok = trail_->EnqueueWithStoredReason(literal.Negated());
+        const bool ok = trail_.EnqueueWithStoredReason(literal.Negated());
         if (!ok) return false;
         continue;
       }
@@ -337,22 +382,26 @@ bool CircuitPropagator::Propagate() {
       // many arcs, and we just propagated it here.
       if (self_arcs_[node] == kFalseLiteralIndex ||
           assignment_.LiteralIsFalse(Literal(self_arcs_[node]))) {
-        FillReasonForPath(start_node, trail_->MutableConflict());
+        FillReasonForPath(start_node, &temp_reason_);
         if (self_arcs_[node] != kFalseLiteralIndex) {
-          trail_->MutableConflict()->push_back(Literal(self_arcs_[node]));
+          temp_reason_.push_back(Literal(self_arcs_[node]));
         }
-        return false;
+        return ReportConflictOrPropagateEnforcement(&temp_reason_);
       }
 
       // Propagate.
-      const Literal literal(self_arcs_[node]);
-      if (variable_with_same_reason == kNoBooleanVariable) {
-        variable_with_same_reason = literal.Variable();
-        FillReasonForPath(start_node, trail_->GetEmptyVectorToStoreReason());
-        const bool ok = trail_->EnqueueWithStoredReason(literal);
-        if (!ok) return false;
-      } else {
-        trail_->EnqueueWithSameReasonAs(literal, variable_with_same_reason);
+      if (status == EnforcementStatus::IS_ENFORCED) {
+        const Literal literal(self_arcs_[node]);
+        if (variable_with_same_reason == kNoBooleanVariable) {
+          variable_with_same_reason = literal.Variable();
+          std::vector<Literal>* reason = trail_.GetEmptyVectorToStoreReason();
+          FillReasonForPath(start_node, reason);
+          enforcement_helper_.AddEnforcementReason(enforcement_id_, reason);
+          const bool ok = trail_.EnqueueWithStoredReason(literal);
+          if (!ok) return false;
+        } else {
+          trail_.EnqueueWithSameReasonAs(literal, variable_with_same_reason);
+        }
       }
     }
   }
@@ -649,6 +698,7 @@ std::function<void(Model*)> ExactlyOnePerRowAndPerColumn(
 
 void LoadSubcircuitConstraint(int num_nodes, absl::Span<const int> tails,
                               absl::Span<const int> heads,
+                              absl::Span<const Literal> enforcement_literals,
                               absl::Span<const Literal> literals, Model* model,
                               bool multiple_subcircuit_through_zero) {
   const int num_arcs = tails.size();
@@ -661,44 +711,50 @@ void LoadSubcircuitConstraint(int num_nodes, absl::Span<const int> tails,
   auto sat_solver = model->GetOrCreate<SatSolver>();
   auto implications = model->GetOrCreate<BinaryImplicationGraph>();
 
-  std::vector<std::vector<Literal>> exactly_one_incoming(num_nodes);
-  std::vector<std::vector<Literal>> exactly_one_outgoing(num_nodes);
-  for (int arc = 0; arc < num_arcs; arc++) {
-    const int tail = tails[arc];
-    const int head = heads[arc];
-    exactly_one_outgoing[tail].push_back(literals[arc]);
-    exactly_one_incoming[head].push_back(literals[arc]);
-  }
-  for (int i = 0; i < exactly_one_incoming.size(); ++i) {
-    if (i == 0 && multiple_subcircuit_through_zero) continue;
-    if (!implications->AddAtMostOne(exactly_one_incoming[i])) {
-      sat_solver->NotifyThatModelIsUnsat();
-      return;
+  if (enforcement_literals.empty()) {
+    // TODO(user): how to generalize this to support enforcement literals?
+    // (we can easily add the negated enforcement literals to AddProblemClause()
+    // calls, but the AddAtMostOne() calls are trickier). For now this is done
+    // with additional constraints added by ExpandCircuit() during expansion.
+    std::vector<std::vector<Literal>> exactly_one_incoming(num_nodes);
+    std::vector<std::vector<Literal>> exactly_one_outgoing(num_nodes);
+    for (int arc = 0; arc < num_arcs; arc++) {
+      const int tail = tails[arc];
+      const int head = heads[arc];
+      exactly_one_outgoing[tail].push_back(literals[arc]);
+      exactly_one_incoming[head].push_back(literals[arc]);
     }
-    sat_solver->AddProblemClause(exactly_one_incoming[i]);
-    if (sat_solver->ModelIsUnsat()) return;
-  }
-  for (int i = 0; i < exactly_one_outgoing.size(); ++i) {
-    if (i == 0 && multiple_subcircuit_through_zero) continue;
-    if (!implications->AddAtMostOne(exactly_one_outgoing[i])) {
-      sat_solver->NotifyThatModelIsUnsat();
-      return;
+    for (int i = 0; i < exactly_one_incoming.size(); ++i) {
+      if (i == 0 && multiple_subcircuit_through_zero) continue;
+      if (!implications->AddAtMostOne(exactly_one_incoming[i])) {
+        sat_solver->NotifyThatModelIsUnsat();
+        return;
+      }
+      sat_solver->AddProblemClause(exactly_one_incoming[i]);
+      if (sat_solver->ModelIsUnsat()) return;
+    }
+    for (int i = 0; i < exactly_one_outgoing.size(); ++i) {
+      if (i == 0 && multiple_subcircuit_through_zero) continue;
+      if (!implications->AddAtMostOne(exactly_one_outgoing[i])) {
+        sat_solver->NotifyThatModelIsUnsat();
+        return;
+      }
+      sat_solver->AddProblemClause(exactly_one_outgoing[i]);
+      if (sat_solver->ModelIsUnsat()) return;
     }
-    sat_solver->AddProblemClause(exactly_one_outgoing[i]);
-    if (sat_solver->ModelIsUnsat()) return;
   }
 
   CircuitPropagator::Options options;
   options.multiple_subcircuit_through_zero = multiple_subcircuit_through_zero;
-  CircuitPropagator* constraint =
-      new CircuitPropagator(num_nodes, tails, heads, literals, options, model);
-  constraint->RegisterWith(model->GetOrCreate<GenericLiteralWatcher>());
-  model->TakeOwnership(constraint);
+  model->TakeOwnership(new CircuitPropagator(
+      num_nodes, tails, heads, enforcement_literals, literals, options, model));
 
   // TODO(user): Just ignore node zero if multiple_subcircuit_through_zero is
   // true.
+  // TODO(user): add support for enforcement literals in
+  // AllDifferentConstraint?
   if (model->GetOrCreate<SatParameters>()->use_all_different_for_circuit() &&
-      !multiple_subcircuit_through_zero) {
+      enforcement_literals.empty() && !multiple_subcircuit_through_zero) {
     AllDifferentConstraint* constraint =
         new AllDifferentConstraint(num_nodes, tails, heads, literals, model);
     constraint->RegisterWith(model->GetOrCreate<GenericLiteralWatcher>());
diff --git a/ortools/sat/circuit.h b/ortools/sat/circuit.h
index 97443a562c..efdee48c3c 100644
--- a/ortools/sat/circuit.h
+++ b/ortools/sat/circuit.h
@@ -22,6 +22,8 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/types/span.h"
 #include "ortools/graph/strongly_connected_components.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/sat_base.h"
@@ -53,6 +55,7 @@ class CircuitPropagator : PropagatorInterface, ReversibleInterface {
   // being present when the given literal is true.
   CircuitPropagator(int num_nodes, absl::Span<const int> tails,
                     absl::Span<const int> heads,
+                    absl::Span<const Literal> enforcement_literals,
                     absl::Span<const Literal> literals, Options options,
                     Model* model);
 
@@ -63,9 +66,10 @@ class CircuitPropagator : PropagatorInterface, ReversibleInterface {
   void SetLevel(int level) final;
   bool Propagate() final;
   bool IncrementalPropagate(const std::vector<int>& watch_indices) final;
-  void RegisterWith(GenericLiteralWatcher* watcher);
 
  private:
+  int RegisterWith(GenericLiteralWatcher* watcher);
+
   // Updates the structures when the given arc is added to the paths.
   void AddArc(int tail, int head, LiteralIndex literal_index);
 
@@ -74,10 +78,17 @@ class CircuitPropagator : PropagatorInterface, ReversibleInterface {
   // start (not like a rho shape).
   void FillReasonForPath(int start_node, std::vector<Literal>* reason) const;
 
+  // Reports a conflict if the constraint is enforced, or propagates the unique
+  // unassigned enforcement literal otherwise.
+  bool ReportConflictOrPropagateEnforcement(std::vector<Literal>* reason);
+
   const int num_nodes_;
   const Options options_;
-  Trail* trail_;
+  Trail& trail_;
+  EnforcementHelper& enforcement_helper_;
+  EnforcementId enforcement_id_;
   const VariablesAssignment& assignment_;
+  bool enabled_;
 
   // We use this to query in O(1) for an arc existence. The self-arcs are
   // accessed often, so we use a more efficient std::vector<> for them. Note
@@ -114,6 +125,7 @@ class CircuitPropagator : PropagatorInterface, ReversibleInterface {
   // Temporary vectors.
   std::vector<bool> processed_;
   std::vector<bool> in_current_path_;
+  std::vector<Literal> temp_reason_;
 };
 
 // Enforce the fact that there is no cycle in the given directed graph.
@@ -246,6 +258,7 @@ int ReindexArcs(IntContainer* tails, IntContainer* heads,
 // problem to be UNSAT. One can call ReindexArcs() first to ignore such nodes.
 void LoadSubcircuitConstraint(int num_nodes, absl::Span<const int> tails,
                               absl::Span<const int> heads,
+                              absl::Span<const Literal> enforcement_literals,
                               absl::Span<const Literal> literals, Model* model,
                               bool multiple_subcircuit_through_zero = false);
 
diff --git a/ortools/sat/circuit_test.cc b/ortools/sat/circuit_test.cc
index afd3c1ff6d..ce75fad149 100644
--- a/ortools/sat/circuit_test.cc
+++ b/ortools/sat/circuit_test.cc
@@ -49,7 +49,8 @@ std::function<void(Model*)> DenseCircuitConstraint(
         literals.push_back(Literal(model->Add(NewBooleanVariable()), true));
       }
     }
-    LoadSubcircuitConstraint(num_nodes, tails, heads, literals, model,
+    LoadSubcircuitConstraint(num_nodes, tails, heads,
+                             /*enforcement_literals=*/{}, literals, model,
                              allow_multiple_subcircuit_through_zero);
   };
 }
@@ -110,7 +111,8 @@ TEST(CircuitConstraintTest, NodeWithNoArcsIsUnsat) {
   tails.push_back(0);
   heads.push_back(1);
   literals.push_back(Literal(model.Add(NewBooleanVariable()), true));
-  LoadSubcircuitConstraint(kNumNodes, tails, heads, literals, &model);
+  LoadSubcircuitConstraint(kNumNodes, tails, heads, /*enforcement_literals=*/{},
+                           literals, &model);
   EXPECT_TRUE(model.GetOrCreate<SatSolver>()->ModelIsUnsat());
 }
 
@@ -217,14 +219,15 @@ TEST(CircuitConstraintTest, InfeasibleBecauseOfMissingArcs) {
     heads.push_back(arcs.second);
     literals.push_back(Literal(model.Add(NewBooleanVariable()), true));
   }
-  LoadSubcircuitConstraint(3, tails, heads, literals, &model, false);
+  LoadSubcircuitConstraint(3, tails, heads, /*enforcement_literals=*/{},
+                           literals, &model, false);
   const SatSolver::Status status = SolveIntegerProblemWithLazyEncoding(&model);
   EXPECT_EQ(status, SatSolver::Status::INFEASIBLE);
 }
 
 // The graph look like this with a self-loop at 2. If 2 is not selected
 // (self-loop) then there is one solution (0,1,3,0) and (0,3,5,0). Otherwise,
-// there is 2 more solutions with 2 inserteed in one of the two routes.
+// there is 2 more solutions with 2 inserted in one of the two routes.
 //
 //   0  ---> 1 ---> 4 -------------
 //   |       |      ^             |
@@ -253,7 +256,8 @@ TEST(CircuitConstraintTest, RouteConstraint) {
     heads.push_back(arcs.second);
     literals.push_back(Literal(model.Add(NewBooleanVariable()), true));
   }
-  LoadSubcircuitConstraint(6, tails, heads, literals, &model, true);
+  LoadSubcircuitConstraint(6, tails, heads, /*enforcement_literals=*/{},
+                           literals, &model, true);
   const int64_t num_solutions = CountSolutions(&model);
   EXPECT_EQ(num_solutions, 3);
 }
diff --git a/ortools/sat/clause.cc b/ortools/sat/clause.cc
index 612b507ccf..5e36480b76 100644
--- a/ortools/sat/clause.cc
+++ b/ortools/sat/clause.cc
@@ -18,7 +18,6 @@
 #include <algorithm>
 #include <cstdint>
 #include <deque>
-#include <new>
 #include <queue>
 #include <string>
 #include <utility>
@@ -26,7 +25,6 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/container/inlined_vector.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/log/vlog_is_on.h"
@@ -38,6 +36,7 @@
 #include "ortools/base/strong_vector.h"
 #include "ortools/base/timer.h"
 #include "ortools/graph/strongly_connected_components.h"
+#include "ortools/sat/container.h"
 #include "ortools/sat/drat_proof_handler.h"
 #include "ortools/sat/inclusion.h"
 #include "ortools/sat/model.h"
@@ -540,14 +539,15 @@ SatClause* ClauseManager::NextClauseToProbe() {
 
 void BinaryImplicationGraph::Resize(int num_variables) {
   SCOPED_TIME_STAT(&stats_);
-  bfs_stack_.resize(num_variables << 1);
-  implications_.resize(num_variables << 1);
-  implies_something_.resize(num_variables << 1);
-  might_have_dups_.resize(num_variables << 1);
-  is_redundant_.resize(implications_.size());
-  is_removed_.resize(implications_.size(), false);
-  estimated_sizes_.resize(implications_.size(), 0);
-  in_direct_implications_.resize(implications_.size(), false);
+  const int num_literals = 2 * num_variables;
+  bfs_stack_.resize(num_literals);
+  implications_and_amos_.resize(num_literals);
+  implies_something_.resize(num_literals);
+  might_have_dups_.resize(num_literals);
+  is_redundant_.resize(num_literals);
+  is_removed_.resize(num_literals, false);
+  estimated_sizes_.resize(num_literals, 0);
+  in_direct_implications_.resize(num_literals, false);
   reasons_.resize(num_variables);
 }
 
@@ -560,7 +560,7 @@ void BinaryImplicationGraph::NotifyPossibleDuplicate(Literal a) {
 void BinaryImplicationGraph::RemoveDuplicates() {
   for (const Literal l : to_clean_) {
     might_have_dups_[l.Index()] = false;
-    gtl::STLSortAndRemoveDuplicates(&implications_[l.Index()]);
+    implications_and_amos_[l.Index()].SortLiteralsAndRemoveDuplicates();
   }
   to_clean_.clear();
 }
@@ -594,8 +594,8 @@ bool BinaryImplicationGraph::AddBinaryClause(Literal a, Literal b) {
   DCHECK(!is_removed_[b]);
   estimated_sizes_[a.NegatedIndex()]++;
   estimated_sizes_[b.NegatedIndex()]++;
-  implications_[a.NegatedIndex()].push_back(b);
-  implications_[b.NegatedIndex()].push_back(a);
+  implications_and_amos_[a.NegatedIndex()].PushBackLiteral(b);
+  implications_and_amos_[b.NegatedIndex()].PushBackLiteral(a);
   implies_something_.Set(a.NegatedIndex());
   implies_something_.Set(b.NegatedIndex());
   NotifyPossibleDuplicate(a);
@@ -787,7 +787,7 @@ bool BinaryImplicationGraph::CleanUpAndAddAtMostOnes(int base_index) {
       for (const Literal a : at_most_one) {
         for (const Literal b : at_most_one) {
           if (a == b) continue;
-          implications_[a].push_back(b.Negated());
+          implications_and_amos_[a].PushBackLiteral(b.Negated());
           implies_something_.Set(a);
           NotifyPossibleDuplicate(a);
         }
@@ -800,11 +800,9 @@ bool BinaryImplicationGraph::CleanUpAndAddAtMostOnes(int base_index) {
 
     // Index the new at most one.
     for (const Literal l : at_most_one) {
-      if (l.Index() >= at_most_ones_.size()) {
-        at_most_ones_.resize(l.Index().value() + 1);
-      }
+      DCHECK_LT(l.Index(), implications_and_amos_.size());
       DCHECK(!is_redundant_[l]);
-      at_most_ones_[l].push_back(local_start);
+      implications_and_amos_[l].InsertOffset(local_start);
       implies_something_.Set(l);
     }
   }
@@ -824,7 +822,7 @@ bool BinaryImplicationGraph::Propagate(Trail* trail) {
 
   const auto assignment = AssignmentView(trail->Assignment());
   const auto implies_something = implies_something_.view();
-  auto* implications = implications_.data();
+  auto* implications = implications_and_amos_.data();
 
   while (propagation_trail_index_ < trail->Index()) {
     const Literal true_literal = (*trail)[propagation_trail_index_++];
@@ -834,8 +832,7 @@ bool BinaryImplicationGraph::Propagate(Trail* trail) {
     // Note(user): This update is not exactly correct because in case of
     // conflict we don't inspect that much clauses. But doing ++num_inspections_
     // inside the loop does slow down the code by a few percent.
-    const absl::Span<const Literal> implied =
-        implications[true_literal.Index().value()];
+    const auto implied = implications[true_literal.Index().value()].literals();
     num_inspections_ += implied.size();
     for (const Literal literal : implied) {
       if (assignment.LiteralIsTrue(literal)) {
@@ -860,31 +857,30 @@ bool BinaryImplicationGraph::Propagate(Trail* trail) {
     }
 
     // Propagate the at_most_one constraints.
-    if (true_literal.Index() < at_most_ones_.size()) {
-      for (const int start : at_most_ones_[true_literal]) {
-        bool seen = false;
-        for (const Literal literal : AtMostOne(start)) {
-          ++num_inspections_;
-          if (literal == true_literal) {
-            if (DEBUG_MODE) {
-              DCHECK(!seen);
-              seen = true;
-            }
-            continue;
+    for (const int start :
+         implications[true_literal.Index().value()].offsets()) {
+      bool seen = false;
+      for (const Literal literal : AtMostOne(start)) {
+        ++num_inspections_;
+        if (literal == true_literal) {
+          if (DEBUG_MODE) {
+            DCHECK(!seen);
+            seen = true;
           }
-          if (assignment.LiteralIsFalse(literal)) continue;
+          continue;
+        }
+        if (assignment.LiteralIsFalse(literal)) continue;
 
-          ++num_propagations_;
-          if (assignment.LiteralIsTrue(literal)) {
-            // Conflict.
-            *(trail->MutableConflict()) = {true_literal.Negated(),
-                                           literal.Negated()};
-            return false;
-          } else {
-            // Propagation.
-            reasons_[trail->Index()] = true_literal.Negated();
-            trail->FastEnqueue(literal.Negated());
-          }
+        ++num_propagations_;
+        if (assignment.LiteralIsTrue(literal)) {
+          // Conflict.
+          *(trail->MutableConflict()) = {true_literal.Negated(),
+                                         literal.Negated()};
+          return false;
+        } else {
+          // Propagation.
+          reasons_[trail->Index()] = true_literal.Negated();
+          trail->FastEnqueue(literal.Negated());
         }
       }
     }
@@ -913,7 +909,7 @@ void BinaryImplicationGraph::MinimizeConflictWithReachability(
   // Compute the reachability from the literal "not(conflict->front())" using
   // an iterative dfs.
   const LiteralIndex root_literal_index = conflict->front().NegatedIndex();
-  is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+  is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
   is_marked_.Set(root_literal_index);
 
   // TODO(user): This sounds like a good idea, but somehow it seems better not
@@ -927,7 +923,8 @@ void BinaryImplicationGraph::MinimizeConflictWithReachability(
 
   // We treat the direct implications differently so we can also remove the
   // redundant implications from this list at the same time.
-  auto& direct_implications = implications_[root_literal_index];
+  auto direct_implications =
+      implications_and_amos_[root_literal_index].literals();
   for (const Literal l : direct_implications) {
     if (is_marked_[l]) continue;
     dfs_stack_.push_back(l);
@@ -936,7 +933,7 @@ void BinaryImplicationGraph::MinimizeConflictWithReachability(
       dfs_stack_.pop_back();
       if (!is_marked_[index]) {
         is_marked_.Set(index);
-        for (const Literal implied : implications_[index]) {
+        for (const Literal implied : implications_and_amos_[index].literals()) {
           if (!is_marked_[implied]) dfs_stack_.push_back(implied);
         }
       }
@@ -971,7 +968,7 @@ void BinaryImplicationGraph::MinimizeConflictWithReachability(
     }
     if (new_size < direct_implications.size()) {
       num_redundant_implications_ += direct_implications.size() - new_size;
-      direct_implications.resize(new_size);
+      implications_and_amos_[root_literal_index].ResizeLiterals(new_size);
     }
   }
 
@@ -987,7 +984,7 @@ void BinaryImplicationGraph::MinimizeConflictFirst(
     SparseBitset<BooleanVariable>* marked) {
   SCOPED_TIME_STAT(&stats_);
   DCHECK(!conflict->empty());
-  is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+  is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
   MarkDescendants(conflict->front().Negated());
   for (const LiteralIndex i : is_marked_.PositionsSetAtLeastOnce()) {
     // TODO(user): if this is false, then we actually have a conflict of size 2.
@@ -1009,11 +1006,12 @@ void BinaryImplicationGraph::MinimizeConflictFirstWithTransitiveReduction(
     absl::BitGenRef random) {
   SCOPED_TIME_STAT(&stats_);
   const LiteralIndex root_literal_index = conflict->front().NegatedIndex();
-  is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+  is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
   is_marked_.Set(root_literal_index);
 
   int new_size = 0;
-  auto& direct_implications = implications_[root_literal_index];
+  auto direct_implications =
+      implications_and_amos_[root_literal_index].literals();
 
   // The randomization allow to find more redundant implication since to find
   // a => b and remove b, a must be before b in direct_implications. Note that
@@ -1035,7 +1033,7 @@ void BinaryImplicationGraph::MinimizeConflictFirstWithTransitiveReduction(
       dfs_stack_.pop_back();
       if (!is_marked_[index]) {
         is_marked_.Set(index);
-        for (const Literal implied : implications_[index]) {
+        for (const Literal implied : implications_and_amos_[index].literals()) {
           if (!is_marked_[implied]) dfs_stack_.push_back(implied);
         }
       }
@@ -1043,7 +1041,7 @@ void BinaryImplicationGraph::MinimizeConflictFirstWithTransitiveReduction(
   }
   if (new_size < direct_implications.size()) {
     num_redundant_implications_ += direct_implications.size() - new_size;
-    direct_implications.resize(new_size);
+    implications_and_amos_[root_literal_index].ResizeLiterals(new_size);
   }
   RemoveRedundantLiterals(conflict);
 }
@@ -1069,8 +1067,8 @@ void BinaryImplicationGraph::RemoveRedundantLiterals(
 void BinaryImplicationGraph::MinimizeConflictExperimental(
     const Trail& trail, std::vector<Literal>* conflict) {
   SCOPED_TIME_STAT(&stats_);
-  is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
-  is_simplified_.ClearAndResize(LiteralIndex(implications_.size()));
+  is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
+  is_simplified_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
   for (const Literal lit : *conflict) {
     is_marked_.Set(lit);
   }
@@ -1092,7 +1090,7 @@ void BinaryImplicationGraph::MinimizeConflictExperimental(
     const Literal lit = (*conflict)[i];
     const int lit_level = trail.Info(lit.Variable()).level;
     bool keep_literal = true;
-    for (const Literal implied : implications_[lit]) {
+    for (const Literal implied : implications_and_amos_[lit].literals()) {
       if (is_marked_[implied]) {
         DCHECK_LE(lit_level, trail.Info(implied.Variable()).level);
         if (lit_level == trail.Info(implied.Variable()).level &&
@@ -1128,14 +1126,15 @@ void BinaryImplicationGraph::RemoveFixedVariables() {
   if (num_processed_fixed_variables_ == new_num_fixed) return;
 
   const VariablesAssignment& assignment = trail_->Assignment();
-  is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+  is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
   for (; num_processed_fixed_variables_ < new_num_fixed;
        ++num_processed_fixed_variables_) {
     const Literal true_literal = (*trail_)[num_processed_fixed_variables_];
     if (DEBUG_MODE) {
       // The code assumes that everything is already propagated.
       // Otherwise we will remove implications that didn't propagate yet!
-      for (const Literal lit : implications_[true_literal]) {
+      for (const Literal lit :
+           implications_and_amos_[true_literal].literals()) {
         DCHECK(trail_->Assignment().LiteralIsTrue(lit));
       }
     }
@@ -1148,7 +1147,8 @@ void BinaryImplicationGraph::RemoveFixedVariables() {
     // transitive reduction and the process was aborted due to the computation
     // limit. I think it will be good to maintain that invariant though,
     // otherwise fixed literals might never be removed from these lists...
-    for (const Literal lit : implications_[true_literal.NegatedIndex()]) {
+    for (const Literal lit :
+         implications_and_amos_[true_literal.NegatedIndex()].literals()) {
       if (lit.NegatedIndex() < representative_of_.size() &&
           representative_of_[lit.Negated()] != kNoLiteralIndex) {
         // We mark its representative instead.
@@ -1157,112 +1157,104 @@ void BinaryImplicationGraph::RemoveFixedVariables() {
         is_marked_.Set(lit.NegatedIndex());
       }
     }
-    gtl::STLClearObject(&(implications_[true_literal]));
-    gtl::STLClearObject(&(implications_[true_literal.NegatedIndex()]));
-
-    if (true_literal.Index() < at_most_ones_.size()) {
-      gtl::STLClearObject(&(at_most_ones_[true_literal]));
-    }
-    if (true_literal.NegatedIndex() < at_most_ones_.size()) {
-      gtl::STLClearObject(&(at_most_ones_[true_literal.NegatedIndex()]));
-    }
+    implications_and_amos_[true_literal].Clear(true);
+    implications_and_amos_[true_literal.NegatedIndex()].Clear(true);
   }
   for (const LiteralIndex i : is_marked_.PositionsSetAtLeastOnce()) {
-    RemoveIf(&implications_[i], [&assignment](const Literal& lit) {
-      return assignment.LiteralIsTrue(lit);
-    });
+    implications_and_amos_[i].RemoveLiteralsIf(
+        [&assignment](const Literal lit) {
+          return assignment.LiteralIsTrue(lit);
+        });
   }
 
   // TODO(user): This might be a bit slow. Do not call all the time if needed,
   // this shouldn't change the correctness of the code.
-  at_most_ones_.clear();
+  for (auto& v : implications_and_amos_) {
+    v.ClearOffsets();
+  }
   CHECK(CleanUpAndAddAtMostOnes(/*base_index=*/0));
   DCHECK(InvariantsAreOk());
 }
 
 class SccGraph {
  public:
-  using Implications =
-      util_intops::StrongVector<LiteralIndex, absl::InlinedVector<Literal, 6>>;
-  using AtMostOnes =
-      util_intops::StrongVector<LiteralIndex, absl::InlinedVector<int32_t, 6>>;
   using SccFinder =
       StronglyConnectedComponentsFinder<int32_t, SccGraph,
                                         CompactVectorVector<int32_t, int32_t>>;
 
-  explicit SccGraph(SccFinder* finder, Implications* graph,
-                    AtMostOnes* at_most_ones,
+  explicit SccGraph(SccFinder* finder,
+                    util_intops::StrongVector<LiteralIndex, LiteralsOrOffsets>*
+                        implications_and_offsets,
                     std::vector<Literal>* at_most_one_buffer)
       : finder_(*finder),
-        implications_(*graph),
-        at_most_ones_(*at_most_ones),
+        implications_and_offsets_(*implications_and_offsets),
         at_most_one_buffer_(*at_most_one_buffer) {}
 
   const std::vector<int32_t>& operator[](int32_t node) const {
     tmp_.clear();
-    for (const Literal l : implications_[LiteralIndex(node)]) {
+    for (const Literal l :
+         implications_and_offsets_[LiteralIndex(node)].literals()) {
       tmp_.push_back(l.Index().value());
       if (finder_.NodeIsInCurrentDfsPath(l.NegatedIndex().value())) {
         to_fix_.push_back(l);
       }
     }
-    if (node < at_most_ones_.size()) {
-      for (const int start : at_most_ones_[LiteralIndex(node)]) {
-        if (start >= at_most_one_already_explored_.size()) {
-          at_most_one_already_explored_.resize(start + 1, false);
-          previous_node_to_explore_at_most_one_.resize(start + 1);
-        }
+    for (const int start :
+         implications_and_offsets_[LiteralIndex(node)].offsets()) {
+      if (start >= at_most_one_already_explored_.size()) {
+        at_most_one_already_explored_.resize(start + 1, false);
+        previous_node_to_explore_at_most_one_.resize(start + 1);
+      }
 
-        // In the presence of at_most_ones_ constraints, expanding them
-        // implicitly to implications in the SCC computation can result in a
-        // quadratic complexity rather than a linear one in term of the input
-        // data structure size. So this test here is critical on problem with
-        // large at_most ones like the "ivu06-big.mps.gz" where without it, the
-        // full FindStronglyConnectedComponents() take more than on hour instead
-        // of less than a second!
-        if (at_most_one_already_explored_[start]) {
-          // We never expand a node twice.
-          const int first_node = previous_node_to_explore_at_most_one_[start];
-          DCHECK_NE(node, first_node);
+      // In the presence of at_most_ones_ constraints, expanding them
+      // implicitly to implications in the SCC computation can result in a
+      // quadratic complexity rather than a linear one in term of the input
+      // data structure size. So this test here is critical on problem with
+      // large at_most ones like the "ivu06-big.mps.gz" where without it, the
+      // full FindStronglyConnectedComponents() take more than on hour instead
+      // of less than a second!
+      if (at_most_one_already_explored_[start]) {
+        // We never expand a node twice.
+        const int first_node = previous_node_to_explore_at_most_one_[start];
+        DCHECK_NE(node, first_node);
 
-          if (finder_.NodeIsInCurrentDfsPath(first_node)) {
-            // If the first node is not settled, then we do explore the
-            // at_most_one constraint again. In "Mixed-Integer-Programming:
-            // Analyzing 12 years of progress", Tobias Achterberg and Roland
-            // Wunderling explains that an at most one need to be looped over at
-            // most twice. I am not sure exactly how that works, so for now we
-            // are not fully linear, but on actual instances, we only rarely
-            // run into this case.
-            //
-            // Note that we change the previous node to explore at most one
-            // since the current node will be settled before the old ones.
-            //
-            // TODO(user): avoid looping more than twice on the same at most one
-            // constraints? Note that the second time we loop we have x => y =>
-            // not(x), so we can already detect that x must be false which we
-            // detect below.
-            previous_node_to_explore_at_most_one_[start] = node;
-          } else {
-            // The first node is already settled and so are all its child. Only
-            // not(first_node) might still need exploring.
-            tmp_.push_back(
-                Literal(LiteralIndex(first_node)).NegatedIndex().value());
-            continue;
-          }
-        } else {
-          at_most_one_already_explored_[start] = true;
+        if (finder_.NodeIsInCurrentDfsPath(first_node)) {
+          // If the first node is not settled, then we do explore the
+          // at_most_one constraint again. In "Mixed-Integer-Programming:
+          // Analyzing 12 years of progress", Tobias Achterberg and Roland
+          // Wunderling explains that an at most one need to be looped over at
+          // most twice. I am not sure exactly how that works, so for now we
+          // are not fully linear, but on actual instances, we only rarely
+          // run into this case.
+          //
+          // Note that we change the previous node to explore at most one
+          // since the current node will be settled before the old ones.
+          //
+          // TODO(user): avoid looping more than twice on the same at most one
+          // constraints? Note that the second time we loop we have x => y =>
+          // not(x), so we can already detect that x must be false which we
+          // detect below.
           previous_node_to_explore_at_most_one_[start] = node;
+        } else {
+          // The first node is already settled and so are all its child. Only
+          // not(first_node) might still need exploring.
+          tmp_.push_back(
+              Literal(LiteralIndex(first_node)).NegatedIndex().value());
+          continue;
         }
+      } else {
+        at_most_one_already_explored_[start] = true;
+        previous_node_to_explore_at_most_one_[start] = node;
+      }
 
-        const absl::Span<const Literal> amo =
-            absl::MakeSpan(&at_most_one_buffer_[start + 1],
-                           at_most_one_buffer_[start].Index().value());
-        for (const Literal l : amo) {
-          if (l.Index() == node) continue;
-          tmp_.push_back(l.NegatedIndex().value());
-          if (finder_.NodeIsInCurrentDfsPath(l.Index().value())) {
-            to_fix_.push_back(l.Negated());
-          }
+      const absl::Span<const Literal> amo =
+          absl::MakeSpan(&at_most_one_buffer_[start + 1],
+                         at_most_one_buffer_[start].Index().value());
+      for (const Literal l : amo) {
+        if (l.Index() == node) continue;
+        tmp_.push_back(l.NegatedIndex().value());
+        if (finder_.NodeIsInCurrentDfsPath(l.Index().value())) {
+          to_fix_.push_back(l.Negated());
         }
       }
     }
@@ -1278,8 +1270,8 @@ class SccGraph {
 
  private:
   const SccFinder& finder_;
-  const Implications& implications_;
-  const AtMostOnes& at_most_ones_;
+  const util_intops::StrongVector<LiteralIndex, LiteralsOrOffsets>&
+      implications_and_offsets_;
   const std::vector<Literal>& at_most_one_buffer_;
 
   mutable std::vector<int32_t> tmp_;
@@ -1304,14 +1296,13 @@ bool BinaryImplicationGraph::DetectEquivalences(bool log_info) {
   DCHECK(InvariantsAreOk());
 
   // TODO(user): We could just do it directly though.
-  const int32_t size(implications_.size());
+  const int32_t size(implications_and_amos_.size());
   CompactVectorVector<int32_t, int32_t> scc;
   scc.reserve(size);
   double dtime = 0.0;
   {
     SccGraph::SccFinder finder;
-    SccGraph graph(&finder, &implications_, &at_most_ones_,
-                   &at_most_one_buffer_);
+    SccGraph graph(&finder, &implications_and_amos_, &at_most_one_buffer_);
     finder.FindStronglyConnectedComponents(size, graph, &scc);
     dtime += 4e-8 * graph.work_done_;
 
@@ -1385,14 +1376,14 @@ bool BinaryImplicationGraph::DetectEquivalences(bool log_info) {
       // Note that because we process list in reverse topological order, this
       // is only needed if there is any equivalence before this point.
       if (num_equivalences > 0) {
-        auto& representative_list = implications_[representative];
-        for (Literal& ref : representative_list) {
+        auto& representative_list = implications_and_amos_[representative];
+        for (Literal& ref : representative_list.literals()) {
           const LiteralIndex rep = representative_of_[ref];
           if (rep == representative) continue;
           if (rep == kNoLiteralIndex) continue;
           ref = Literal(rep);
         }
-        gtl::STLSortAndRemoveDuplicates(&representative_list);
+        representative_list.SortLiteralsAndRemoveDuplicates();
       }
       continue;
     }
@@ -1413,36 +1404,36 @@ bool BinaryImplicationGraph::DetectEquivalences(bool log_info) {
         return false;
       }
     }
-
-    // Merge all the lists in implications_[representative].
+    // Merge all the lists in implications_and_offsets_[representative].
     // Note that we do not want representative in its own list.
-    auto& representative_list = implications_[representative];
+    auto& representative_list = implications_and_amos_[representative];
     int new_size = 0;
-    for (const Literal l : representative_list) {
+    for (const Literal l : representative_list.literals()) {
       const Literal rep = RepresentativeOf(l);
       if (rep.Index() == representative) continue;
-      representative_list[new_size++] = rep;
+      representative_list.literals()[new_size++] = rep;
     }
-    representative_list.resize(new_size);
+    representative_list.ResizeLiterals(new_size);
     for (int i = 1; i < component.size(); ++i) {
       const Literal literal = Literal(LiteralIndex(component[i]));
-      auto& ref = implications_[literal];
-      for (const Literal l : ref) {
+      auto& ref = implications_and_amos_[literal];
+      for (const Literal l : ref.literals()) {
         const Literal rep = RepresentativeOf(l);
-        if (rep.Index() != representative) representative_list.push_back(rep);
+        if (rep.Index() != representative)
+          representative_list.PushBackLiteral(rep);
       }
-      dtime += 1e-8 * static_cast<double>(ref.size());
+      dtime += 1e-8 * static_cast<double>(ref.num_literals());
 
       // Add representative <=> literal.
       //
       // Remark: this relation do not need to be added to a DRAT proof since
       // the redundant variables should never be used again for a pure SAT
       // problem.
-      representative_list.push_back(literal);
-      ref.clear();
-      ref.push_back(Literal(representative));
+      representative_list.PushBackLiteral(literal);
+      ref.ClearLiterals(false);
+      ref.PushBackLiteral(Literal(representative));
     }
-    gtl::STLSortAndRemoveDuplicates(&representative_list);
+    representative_list.SortLiteralsAndRemoveDuplicates();
     num_equivalences += component.size() - 1;
   }
 
@@ -1451,7 +1442,9 @@ bool BinaryImplicationGraph::DetectEquivalences(bool log_info) {
     // Remap all at most ones. Remove fixed variables, process duplicates. Note
     // that this might result in more implications when we expand small at most
     // one.
-    at_most_ones_.clear();
+    for (auto& v : implications_and_amos_) {
+      v.ClearOffsets();
+    }
     int saved_trail_index = propagation_trail_index_;
     if (!CleanUpAndAddAtMostOnes(/*base_index=*/0)) return false;
 
@@ -1475,8 +1468,8 @@ bool BinaryImplicationGraph::DetectEquivalences(bool log_info) {
                          << " redundant equivalent literals. "
                          << num_fixed_during_scc << " fixed. "
                          << ComputeNumImplicationsForLog()
-                         << " implications left. " << implications_.size()
-                         << " literals."
+                         << " implications left. "
+                         << implications_and_amos_.size() << " literals."
                          << " size of at_most_one buffer = "
                          << at_most_one_buffer_.size() << "."
                          << " dtime: " << dtime
@@ -1528,7 +1521,7 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
   // TODO(user): Can we exploit the fact that the implication graph is a
   // skew-symmetric graph (isomorphic to its transposed) so that we do less
   // work?
-  const LiteralIndex size(implications_.size());
+  const LiteralIndex size(implications_and_amos_.size());
   LiteralIndex previous = kNoLiteralIndex;
   for (const LiteralIndex root : reverse_topological_order_) {
     // In most situation reverse_topological_order_ contains no redundant, fixed
@@ -1538,8 +1531,8 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
     if (is_redundant_[root]) continue;
     if (trail_->Assignment().LiteralIsAssigned(Literal(root))) continue;
 
-    auto& direct_implications = implications_[root];
-    if (direct_implications.empty()) continue;
+    auto& direct_implications = implications_and_amos_[root];
+    if (direct_implications.literals().empty()) continue;
 
     // This is a "poor" version of the tree look stuff, but it does show good
     // improvement. If we just processed one of the child of root, we don't
@@ -1549,7 +1542,7 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
     // any node with a reverse topo order smaller or equal to the min of the
     // ones in this list.
     bool clear_previous_reachability = true;
-    for (const Literal direct_child : direct_implications) {
+    for (const Literal direct_child : direct_implications.literals()) {
       if (direct_child.Index() == previous) {
         clear_previous_reachability = false;
         is_marked_.Clear(previous);
@@ -1562,7 +1555,7 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
     }
     previous = root;
 
-    for (const Literal direct_child : direct_implications) {
+    for (const Literal direct_child : direct_implications.literals()) {
       if (is_redundant_[direct_child]) continue;
       if (is_marked_[direct_child]) continue;
 
@@ -1587,9 +1580,9 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
     is_marked_.Set(root);
 
     // Also mark all the ones reachable through the root AMOs.
-    if (root < at_most_ones_.size()) {
+    {
       auto is_marked = is_marked_.BitsetView();
-      for (const int start : at_most_ones_[root]) {
+      for (const int start : implications_and_amos_[root].offsets()) {
         for (const Literal l : AtMostOne(start)) {
           if (l.Index() == root) continue;
           if (!is_marked[l.Negated()] && !is_redundant_[l.Negated()]) {
@@ -1628,17 +1621,17 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
     // marked). We mark root to remove it in the corner case where it was
     // there.
     int new_size = 0;
-    for (const Literal l : direct_implications) {
+    for (const Literal l : direct_implications.literals()) {
       if (!is_marked_[l]) {
-        direct_implications[new_size++] = l;
+        direct_implications.literals()[new_size++] = l;
       } else {
         tmp_removed_.push_back({Literal(root), l});
         DCHECK(!is_redundant_[l]);
       }
     }
-    const int diff = direct_implications.size() - new_size;
-    direct_implications.resize(new_size);
-    direct_implications.shrink_to_fit();
+    const int diff = direct_implications.num_literals() - new_size;
+    direct_implications.ResizeLiterals(new_size);
+    // FIXME: direct_implications.shrink_to_fit();
     num_new_redundant_implications += diff;
 
     // Abort if the computation involved is too big.
@@ -1658,15 +1651,15 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
     for (const auto [a, b] : tmp_removed_) {
       removed.insert({a.Index(), b.Index()});
     }
-    for (LiteralIndex i(0); i < implications_.size(); ++i) {
+    for (LiteralIndex i(0); i < implications_and_amos_.size(); ++i) {
       int new_size = 0;
       const LiteralIndex negated_i = Literal(i).NegatedIndex();
-      auto& implication = implications_[i];
-      for (const Literal l : implication) {
+      auto& implication = implications_and_amos_[i];
+      for (const Literal l : implication.literals()) {
         if (removed.contains({l.NegatedIndex(), negated_i})) continue;
-        implication[new_size++] = l;
+        implication.literals()[new_size++] = l;
       }
-      implication.resize(new_size);
+      implication.ResizeLiterals(new_size);
     }
   }
   if (num_fixed > 0) {
@@ -1682,8 +1675,9 @@ bool BinaryImplicationGraph::ComputeTransitiveReduction(bool log_info) {
                          << num_new_redundant_implications << " literals. "
                          << num_fixed << " fixed. "
                          << ComputeNumImplicationsForLog()
-                         << " implications left. " << implications_.size()
-                         << " literals." << " dtime: " << dtime
+                         << " implications left. "
+                         << implications_and_amos_.size() << " literals."
+                         << " dtime: " << dtime
                          << " wtime: " << wall_timer.Get()
                          << (aborted ? " Aborted." : "");
   return true;
@@ -1778,7 +1772,7 @@ bool BinaryImplicationGraph::TransformIntoMaxCliques(
 
   std::vector<int> dense_index_to_index;
   util_intops::StrongVector<LiteralIndex, std::vector<int>>
-      max_cliques_containing(implications_.size());
+      max_cliques_containing(implications_and_amos_.size());
 
   const std::vector<std::pair<int, int>> index_size_vector =
       FilterAndSortAtMostOnes(absl::MakeSpan(*at_most_ones));
@@ -1907,7 +1901,7 @@ bool BinaryImplicationGraph::MergeAtMostOnes(
     int clique_i = 0;
     int next_index_to_try = 0;
     intersection.clear();
-    tmp_bitset_.ClearAndResize(LiteralIndex(implications_.size()));
+    tmp_bitset_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
     for (const Literal l : clique) {
       intersection.push_back(l.Index().value());
       tmp_bitset_.Set(l);
@@ -1928,7 +1922,7 @@ bool BinaryImplicationGraph::MergeAtMostOnes(
       for (; clique_i < clique.size(); ++clique_i) {
         const Literal l = clique[clique_i];
 
-        is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+        is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
         MarkDescendants(l);
 
         if (clique_i == 0) {
@@ -2024,7 +2018,7 @@ std::vector<Literal> BinaryImplicationGraph::ExpandAtMostOneWithWeight(
     // Do not spend too much time here.
     if (work_done_in_mark_descendants_ - old_work > 1e8) break;
 
-    is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+    is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
     MarkDescendants(clique[i]);
     if (i == 0) {
       for (const LiteralIndex index : is_marked_.PositionsSetAtLeastOnce()) {
@@ -2098,7 +2092,7 @@ BinaryImplicationGraph::GenerateAtMostOnesWithLargeWeight(
     absl::Span<const Literal> literals, absl::Span<const double> lp_values,
     absl::Span<const double> reduced_costs) {
   // We only want to generate a cut with literals from the LP, not extra ones.
-  const int num_literals = implications_.size();
+  const int num_literals = implications_and_amos_.size();
   util_intops::StrongVector<LiteralIndex, bool> can_be_included(num_literals,
                                                                 false);
   util_intops::StrongVector<LiteralIndex, double> expanded_lp_values(
@@ -2167,7 +2161,7 @@ BinaryImplicationGraph::GenerateAtMostOnesWithLargeWeight(
     // We consider only one candidate for each current_literal.
     LiteralIndex best = kNoLiteralIndex;
     double best_value = 0.0;
-    for (const Literal l : implications_[current_literal]) {
+    for (const Literal l : implications_and_amos_[current_literal].literals()) {
       if (!can_be_included[l]) continue;
       const double activity =
           current_value + expanded_lp_values[l.NegatedIndex()];
@@ -2217,7 +2211,7 @@ BinaryImplicationGraph::GenerateAtMostOnesWithLargeWeight(
 
     // Prepare a dense mapping.
     int i = 0;
-    tmp_mapping_.resize(implications_.size(), -1);
+    tmp_mapping_.resize(implications_and_amos_.size(), -1);
     for (const Literal l : fractional_literals) {
       bron_kerbosch_.SetWeight(i, expanded_lp_values[l]);
       tmp_mapping_[l] = i++;
@@ -2300,7 +2294,7 @@ BinaryImplicationGraph::HeuristicAmoPartition(std::vector<Literal>* literals) {
   std::vector<absl::Span<const Literal>> result;
 
   util_intops::StrongVector<LiteralIndex, bool> to_consider(
-      implications_.size(), false);
+      implications_and_amos_.size(), false);
   for (const Literal l : *literals) to_consider[l] = true;
 
   // Priority queue of (intersection_size, start_of_amo).
@@ -2312,8 +2306,7 @@ BinaryImplicationGraph::HeuristicAmoPartition(std::vector<Literal>* literals) {
   // This is in O(num_literal in amo).
   absl::flat_hash_set<int> explored_amo;
   for (const Literal l : *literals) {
-    if (l.Index() >= at_most_ones_.size()) continue;
-    for (const int start : at_most_ones_[l]) {
+    for (const int start : implications_and_amos_[l].offsets()) {
       const auto [_, inserted] = explored_amo.insert(start);
       if (!inserted) continue;
 
@@ -2370,7 +2363,7 @@ BinaryImplicationGraph::HeuristicAmoPartition(std::vector<Literal>* literals) {
 
 absl::Span<const Literal> BinaryImplicationGraph::GetAllImpliedLiterals(
     Literal root) {
-  is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+  is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
   return MarkDescendants(root);
 }
 
@@ -2384,22 +2377,21 @@ absl::Span<const Literal> BinaryImplicationGraph::MarkDescendants(
   stack[0] = root;
   if (is_redundant[root]) return absl::MakeSpan(stack, 1);
   is_marked_.Set(root);
-  const int amo_size = static_cast<int>(at_most_ones_.size());
   auto implies_something = implies_something_.const_view();
   for (int j = 0; j < stack_size; ++j) {
     const Literal current = stack[j];
     if (!implies_something[current]) continue;
 
-    work_done_in_mark_descendants_ += implications_[current].size();
-    for (const Literal l : implications_[current]) {
+    work_done_in_mark_descendants_ +=
+        implications_and_amos_[current].num_literals();
+    for (const Literal l : implications_and_amos_[current].literals()) {
       if (!is_marked[l] && !is_redundant[l]) {
         is_marked_.SetUnsafe(is_marked, l);
         stack[stack_size++] = l;
       }
     }
 
-    if (current.Index() >= amo_size) continue;
-    for (const int start : at_most_ones_[current]) {
+    for (const int start : implications_and_amos_[current].offsets()) {
       work_done_in_mark_descendants_ += AtMostOne(start).size();
       for (const Literal l : AtMostOne(start)) {
         if (l == current) continue;
@@ -2432,7 +2424,7 @@ std::vector<Literal> BinaryImplicationGraph::ExpandAtMostOne(
   std::vector<LiteralIndex> intersection;
   for (int i = 0; i < clique.size(); ++i) {
     if (work_done_in_mark_descendants_ > max_num_explored_nodes) break;
-    is_marked_.ClearAndResize(LiteralIndex(implications_.size()));
+    is_marked_.ClearAndResize(LiteralIndex(implications_and_amos_.size()));
     MarkDescendants(clique[i]);
 
     if (i == 0) {
@@ -2476,7 +2468,7 @@ const std::vector<Literal>& BinaryImplicationGraph::DirectImplications(
   // Fill new state.
   const VariablesAssignment& assignment = trail_->Assignment();
   DCHECK(!assignment.LiteralIsAssigned(literal));
-  for (const Literal l : implications_[literal]) {
+  for (const Literal l : implications_and_amos_[literal].literals()) {
     if (l == literal) continue;
     if (assignment.LiteralIsAssigned(l)) continue;
     if (!is_removed_[l] && !in_direct_implications_[l]) {
@@ -2484,18 +2476,16 @@ const std::vector<Literal>& BinaryImplicationGraph::DirectImplications(
       direct_implications_.push_back(l);
     }
   }
-  if (literal.Index() < at_most_ones_.size()) {
-    if (is_redundant_[literal]) {
-      DCHECK(at_most_ones_[literal].empty());
-    }
-    for (const int start : at_most_ones_[literal]) {
-      for (const Literal l : AtMostOne(start)) {
-        if (l == literal) continue;
-        if (assignment.LiteralIsAssigned(l)) continue;
-        if (!is_removed_[l] && !in_direct_implications_[l.NegatedIndex()]) {
-          in_direct_implications_[l.NegatedIndex()] = true;
-          direct_implications_.push_back(l.Negated());
-        }
+  if (is_redundant_[literal]) {
+    DCHECK(implications_and_amos_[literal].offsets().empty());
+  }
+  for (const int start : implications_and_amos_[literal].offsets()) {
+    for (const Literal l : AtMostOne(start)) {
+      if (l == literal) continue;
+      if (assignment.LiteralIsAssigned(l)) continue;
+      if (!is_removed_[l] && !in_direct_implications_[l.NegatedIndex()]) {
+        in_direct_implications_[l.NegatedIndex()] = true;
+        direct_implications_.push_back(l.Negated());
       }
     }
   }
@@ -2509,18 +2499,17 @@ absl::Span<const Literal> BinaryImplicationGraph::AtMostOne(int start) const {
 }
 
 LiteralIndex BinaryImplicationGraph::RandomImpliedLiteral(Literal lhs) {
-  const int size1 = implications_[lhs].size();
-  const int size2 =
-      lhs.Index() < at_most_ones_.size() ? at_most_ones_[lhs].size() : 0;
+  const int size1 = implications_and_amos_[lhs].num_literals();
+  const int size2 = implications_and_amos_[lhs].num_offsets();
   if (size1 + size2 == 0) return kNoLiteralIndex;
 
   const int choice = absl::Uniform<int>(*random_, 0, size1 + size2);
   if (choice < size1) {
-    return implications_[lhs][choice].Index();
+    return implications_and_amos_[lhs].literals()[choice].Index();
   }
 
   const absl::Span<const Literal> amo =
-      AtMostOne(at_most_ones_[lhs][choice - size1]);
+      AtMostOne(implications_and_amos_[lhs].offsets()[choice - size1]);
   CHECK_GE(amo.size(), 2);
   const int first_choice = absl::Uniform<int>(*random_, 0, amo.size());
   const Literal lit = amo[first_choice];
@@ -2623,7 +2612,7 @@ void BinaryImplicationGraph::RemoveBooleanVariable(
   // be delayed to the CleanupAllRemovedVariables() call.
   for (const LiteralIndex index : {literal.Index(), literal.NegatedIndex()}) {
     is_removed_[index] = true;
-    implications_[index].clear();
+    implications_and_amos_[index].ClearLiterals(false);
     if (!is_redundant_[index]) {
       ++num_redundant_literals_;
       is_redundant_.Set(index);
@@ -2633,54 +2622,56 @@ void BinaryImplicationGraph::RemoveBooleanVariable(
 
 void BinaryImplicationGraph::RemoveAllRedundantVariables(
     std::deque<std::vector<Literal>>* postsolve_clauses) {
-  for (LiteralIndex a(0); a < implications_.size(); ++a) {
+  for (LiteralIndex a(0); a < implications_and_amos_.size(); ++a) {
     if (is_redundant_[a] && !is_removed_[a]) {
       postsolve_clauses->push_back(
           {Literal(a), Literal(RepresentativeOf(Literal(a))).Negated()});
       is_removed_[a] = true;
-      gtl::STLClearObject(&(implications_[a]));
+      implications_and_amos_[a].ClearLiterals(true);
       continue;
     }
 
     int new_size = 0;
-    auto& implication = implications_[a];
-    for (const Literal l : implication) {
+    auto& implication = implications_and_amos_[a];
+    for (const Literal l : implication.literals()) {
       if (!is_redundant_[l]) {
-        implication[new_size++] = l;
+        implication.literals()[new_size++] = l;
       }
     }
-    implication.resize(new_size);
+    implication.ResizeLiterals(new_size);
   }
 }
 
 void BinaryImplicationGraph::CleanupAllRemovedAndFixedVariables() {
   const VariablesAssignment& assignment = trail_->Assignment();
-  for (LiteralIndex a(0); a < implications_.size(); ++a) {
+  for (LiteralIndex a(0); a < implications_and_amos_.size(); ++a) {
     if (is_removed_[a] || assignment.LiteralIsAssigned(Literal(a))) {
       if (DEBUG_MODE && assignment.LiteralIsTrue(Literal(a))) {
         // The code assumes that everything is already propagated.
         // Otherwise we will remove implications that didn't propagate yet!
-        for (const Literal lit : implications_[a]) {
+        for (const Literal lit : implications_and_amos_[a].literals()) {
           DCHECK(trail_->Assignment().LiteralIsTrue(lit));
         }
       }
 
-      gtl::STLClearObject(&(implications_[a]));
+      implications_and_amos_[a].ClearLiterals(true);
       continue;
     }
 
     int new_size = 0;
-    auto& implication = implications_[a];
-    for (const Literal l : implication) {
+    auto& implication = implications_and_amos_[a];
+    for (const Literal l : implication.literals()) {
       if (!is_removed_[l] && !assignment.LiteralIsTrue(l)) {
-        implication[new_size++] = l;
+        implication.literals()[new_size++] = l;
       }
     }
-    implication.resize(new_size);
+    implication.ResizeLiterals(new_size);
   }
 
   // Clean-up at most ones.
-  at_most_ones_.clear();
+  for (auto& v : implications_and_amos_) {
+    v.ClearOffsets();
+  }
   CHECK(CleanUpAndAddAtMostOnes(/*base_index=*/0));
 
   // Note that to please the invariant() we also removed fixed literal above.
@@ -2694,18 +2685,19 @@ bool BinaryImplicationGraph::InvariantsAreOk() {
   int num_redundant = 0;
   int num_fixed = 0;
   TimeLimitCheckEveryNCalls time_limit_check(100, time_limit_);
-  for (LiteralIndex a_index(0); a_index < implications_.size(); ++a_index) {
+  for (LiteralIndex a_index(0); a_index < implications_and_amos_.size();
+       ++a_index) {
     if (time_limit_check.LimitReached()) return true;
     if (trail_->Assignment().LiteralIsAssigned(Literal(a_index))) {
       ++num_fixed;
-      if (!implications_[a_index].empty()) {
+      if (!implications_and_amos_[a_index].literals().empty()) {
         LOG(ERROR) << "Fixed literal has non-cleared implications";
         return false;
       }
       continue;
     }
     if (is_removed_[a_index]) {
-      if (!implications_[a_index].empty()) {
+      if (!implications_and_amos_[a_index].literals().empty()) {
         LOG(ERROR) << "Removed literal has non-cleared implications";
         return false;
       }
@@ -2713,14 +2705,15 @@ bool BinaryImplicationGraph::InvariantsAreOk() {
     }
     if (is_redundant_[a_index]) {
       ++num_redundant;
-      if (implications_[a_index].size() != 1) {
+      if (implications_and_amos_[a_index].num_literals() != 1) {
         LOG(ERROR)
             << "Redundant literal should only point to its representative "
-            << Literal(a_index) << " => " << implications_[a_index];
+            << Literal(a_index) << " => "
+            << implications_and_amos_[a_index].literals();
         return false;
       }
     }
-    for (const Literal b : implications_[a_index]) {
+    for (const Literal b : implications_and_amos_[a_index].literals()) {
       seen.insert({a_index, b.Index()});
     }
   }
@@ -2728,7 +2721,7 @@ bool BinaryImplicationGraph::InvariantsAreOk() {
   // Check that reverse topo order is correct.
   util_intops::StrongVector<LiteralIndex, int> lit_to_order;
   if (is_dag_) {
-    lit_to_order.assign(implications_.size(), -1);
+    lit_to_order.assign(implications_and_amos_.size(), -1);
     for (int i = 0; i < reverse_topological_order_.size(); ++i) {
       lit_to_order[reverse_topological_order_[i]] = i;
     }
@@ -2736,10 +2729,11 @@ bool BinaryImplicationGraph::InvariantsAreOk() {
 
   VLOG(2) << "num_redundant " << num_redundant;
   VLOG(2) << "num_fixed " << num_fixed;
-  for (LiteralIndex a_index(0); a_index < implications_.size(); ++a_index) {
+  for (LiteralIndex a_index(0); a_index < implications_and_amos_.size();
+       ++a_index) {
     if (time_limit_check.LimitReached()) return true;
     const LiteralIndex not_a_index = Literal(a_index).NegatedIndex();
-    for (const Literal b : implications_[a_index]) {
+    for (const Literal b : implications_and_amos_[a_index].literals()) {
       if (is_removed_[b]) {
         LOG(ERROR) << "A removed literal still appear! " << Literal(a_index)
                    << " => " << b;
@@ -2770,8 +2764,8 @@ bool BinaryImplicationGraph::InvariantsAreOk() {
 
   // Check the at-most ones.
   absl::flat_hash_set<std::pair<LiteralIndex, int>> lit_to_start;
-  for (LiteralIndex i(0); i < at_most_ones_.size(); ++i) {
-    for (const int start : at_most_ones_[i]) {
+  for (LiteralIndex i(0); i < implications_and_amos_.size(); ++i) {
+    for (const int start : implications_and_amos_[i].offsets()) {
       lit_to_start.insert({i, start});
     }
   }
diff --git a/ortools/sat/clause.h b/ortools/sat/clause.h
index 3020920acb..a5f1dbed99 100644
--- a/ortools/sat/clause.h
+++ b/ortools/sat/clause.h
@@ -22,6 +22,7 @@
 #include <functional>
 #include <new>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -35,6 +36,7 @@
 #include "absl/types/span.h"
 #include "ortools/base/strong_vector.h"
 #include "ortools/graph/cliques.h"
+#include "ortools/sat/container.h"
 #include "ortools/sat/drat_proof_handler.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/sat_base.h"
@@ -522,7 +524,7 @@ class BinaryImplicationGraph : public SatPropagator {
 
   // Returns the "size" of this class, that is 2 * num_boolean_variables as
   // updated by the larger Resize() call.
-  int64_t literal_size() const { return implications_.size(); }
+  int64_t literal_size() const { return implications_and_amos_.size(); }
 
   // Returns true if no constraints where ever added to this class.
   bool IsEmpty() const final { return no_constraint_ever_added_; }
@@ -616,8 +618,8 @@ class BinaryImplicationGraph : public SatPropagator {
 
   // Returns the list of literal "directly" implied by l. Beware that this can
   // easily change behind your back if you modify the solver state.
-  const absl::InlinedVector<Literal, 6>& Implications(Literal l) const {
-    return implications_[l];
+  absl::Span<const Literal> Implications(Literal l) const {
+    return implications_and_amos_[l].literals();
   }
 
   // Returns the representative of the equivalence class of l (or l itself if it
@@ -726,7 +728,9 @@ class BinaryImplicationGraph : public SatPropagator {
   // thing is half this number. This should only be used in logs.
   int64_t ComputeNumImplicationsForLog() const {
     int64_t result = 0;
-    for (const auto& list : implications_) result += list.size();
+    for (const auto& list : implications_and_amos_) {
+      result += list.num_literals();
+    }
     return result;
   }
 
@@ -744,9 +748,9 @@ class BinaryImplicationGraph : public SatPropagator {
     // twice.
     absl::flat_hash_set<std::pair<LiteralIndex, LiteralIndex>>
         duplicate_detection;
-    for (LiteralIndex i(0); i < implications_.size(); ++i) {
+    for (LiteralIndex i(0); i < implications_and_amos_.size(); ++i) {
       const Literal a = Literal(i).Negated();
-      for (const Literal b : implications_[i]) {
+      for (const Literal b : implications_and_amos_[i].literals()) {
         // Note(user): We almost always have both a => b and not(b) => not(a) in
         // our implications_ database. Except if ComputeTransitiveReduction()
         // was aborted early, but in this case, if only one is present, the
@@ -840,8 +844,7 @@ class BinaryImplicationGraph : public SatPropagator {
   // used to detect that two literals are in the same AMO (i.e. if they share
   // the same index).
   absl::Span<const int> AtMostOneIndices(Literal lit) const {
-    if (lit.Index() >= at_most_ones_.size()) return {};
-    return at_most_ones_[lit];
+    return implications_and_amos_[lit].offsets();
   }
 
  private:
@@ -901,42 +904,25 @@ class BinaryImplicationGraph : public SatPropagator {
   // elements of this array and this can dynamically change size.
   std::deque<Literal> reasons_;
 
-  // This is indexed by the Index() of a literal. Each list stores the
-  // literals that are implied if the index literal becomes true.
-  //
-  // Using InlinedVector helps quite a bit because on many problems, a literal
-  // only implies a few others. Note that on a 64 bits computer we get exactly
-  // 6 inlined int32_t elements without extra space, and the size of the inlined
-  // vector is 4 times 64 bits.
-  //
-  // TODO(user): We could be even more efficient since a size of int32_t is
-  // enough for us and we could store in common the inlined/not-inlined size.
-  util_intops::StrongVector<LiteralIndex, absl::InlinedVector<Literal, 6>>
-      implications_;
+  // This is indexed by the Index() of a literal. Each entry stores two lists:
+  //  - A list of literals that are implied if the index literal becomes true.
+  //  - A set of offsets that point to the starts of AMO constraints in
+  //    at_most_one_buffer_. When LiteralIndex is true, then all entry in the at
+  //    most one constraint must be false except the one referring to
+  //    LiteralIndex.
+  util_intops::StrongVector<LiteralIndex, LiteralsOrOffsets>
+      implications_and_amos_;
 
   // Used by RemoveDuplicates() and NotifyPossibleDuplicate().
   util_intops::StrongVector<LiteralIndex, bool> might_have_dups_;
   std::vector<Literal> to_clean_;
 
-  // Internal representation of at_most_one constraints. Each entry point to the
-  // start of a constraint in the buffer.
-  //
-  // TRICKY: The first literal is actually the size of the at_most_one.
-  // Most users should just use AtMostOne(start).
-  //
-  // When LiteralIndex is true, then all entry in the at most one
-  // constraint must be false except the one referring to LiteralIndex.
-  //
-  // TODO(user): We could be more cache efficient by combining this with
-  // implications_ in some way. Do some propagation speed benchmark.
-  util_intops::StrongVector<LiteralIndex, absl::InlinedVector<int32_t, 6>>
-      at_most_ones_;
   std::vector<Literal> at_most_one_buffer_;
   const int at_most_one_max_expansion_size_;
   int at_most_one_iterator_ = 0;
 
-  // Invariant: implies_something_[l] should be true iff implications_[l] or
-  // at_most_ones_[l] might be non-empty.
+  // Invariant: implies_something_[l] should be true iff
+  // implications_and_amos_[l] might be non-empty.
   //
   // For problems with a large number of variables and sparse implications_ or
   // at_most_ones_ entries, checking this is way faster during
diff --git a/ortools/sat/colab/cp_sat.ipynb b/ortools/sat/colab/cp_sat.ipynb
index 474fb8e3a3..0835236f2d 100644
--- a/ortools/sat/colab/cp_sat.ipynb
+++ b/ortools/sat/colab/cp_sat.ipynb
@@ -1,3 +1,17 @@
+#!/usr/bin/env python3
+# Copyright 2010-2025 Google LLC
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 {
   "cells": [
     {
diff --git a/ortools/sat/combine_solutions.cc b/ortools/sat/combine_solutions.cc
index 872a9e4b4f..763c642c2a 100644
--- a/ortools/sat/combine_solutions.cc
+++ b/ortools/sat/combine_solutions.cc
@@ -22,6 +22,7 @@
 
 #include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "ortools/sat/cp_model_checker.h"
 #include "ortools/sat/model.h"
@@ -80,7 +81,7 @@ std::optional<std::vector<int64_t>> FindCombinedSolution(
 
 PushedSolutionPointers PushAndMaybeCombineSolution(
     SharedResponseManager* response_manager, const CpModelProto& model_proto,
-    absl::Span<const int64_t> new_solution, const std::string& solution_info,
+    absl::Span<const int64_t> new_solution, absl::string_view solution_info,
     std::shared_ptr<const SharedSolutionRepository<int64_t>::Solution>
         base_solution) {
   PushedSolutionPointers result = {nullptr, nullptr};
@@ -88,7 +89,7 @@ PushedSolutionPointers PushAndMaybeCombineSolution(
       new_solution, solution_info, nullptr,
       base_solution == nullptr ? -1 : base_solution->source_id);
   if (base_solution != nullptr) {
-    std::string combined_solution_info = solution_info;
+    std::string combined_solution_info(solution_info);
     std::optional<std::vector<int64_t>> combined_solution =
         FindCombinedSolution(model_proto, new_solution,
                              base_solution->variable_values, response_manager,
diff --git a/ortools/sat/combine_solutions.h b/ortools/sat/combine_solutions.h
index 259e1cbca9..486b0ee6b9 100644
--- a/ortools/sat/combine_solutions.h
+++ b/ortools/sat/combine_solutions.h
@@ -20,6 +20,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/model.h"
@@ -48,7 +49,7 @@ struct PushedSolutionPointers {
 };
 PushedSolutionPointers PushAndMaybeCombineSolution(
     SharedResponseManager* response_manager, const CpModelProto& model_proto,
-    absl::Span<const int64_t> new_solution, const std::string& solution_info,
+    absl::Span<const int64_t> new_solution, absl::string_view solution_info,
     std::shared_ptr<const SharedSolutionRepository<int64_t>::Solution>
         base_solution);
 
diff --git a/ortools/sat/constraint_violation.cc b/ortools/sat/constraint_violation.cc
index ec971d59fd..5982505084 100644
--- a/ortools/sat/constraint_violation.cc
+++ b/ortools/sat/constraint_violation.cc
@@ -1702,6 +1702,10 @@ void LsEvaluator::CompileOneConstraint(const ConstraintProto& ct) {
         // The violation will be the area above the capacity.
         LinearExpressionProto one;
         one.set_offset(1);
+        std::vector<int> enforcement_literals;
+        for (const int lit : ct.enforcement_literal()) {
+          enforcement_literals.push_back(lit);
+        }
         std::vector<std::optional<int>> is_active;
         std::vector<LinearExpressionProto> times;
         std::vector<LinearExpressionProto> demands;
@@ -1725,8 +1729,8 @@ void LsEvaluator::CompileOneConstraint(const ConstraintProto& ct) {
           demands.push_back(NegatedLinearExpression(one));
         }
         constraints_.emplace_back(new CompiledReservoirConstraint(
-            std::move(one), std::move(is_active), std::move(times),
-            std::move(demands)));
+            std::move(enforcement_literals), std::move(one),
+            std::move(is_active), std::move(times), std::move(demands)));
       } else {
         // We expand the no_overlap constraints into a quadratic number of
         // disjunctions.
@@ -1745,16 +1749,17 @@ void LsEvaluator::CompileOneConstraint(const ConstraintProto& ct) {
             if (min_start_i >= max_end_j || min_start_j >= max_end_i) continue;
 
             const bool has_enforcement =
+                !ct.enforcement_literal().empty() ||
                 !proto_i.enforcement_literal().empty() ||
                 !proto_j.enforcement_literal().empty();
             if (has_enforcement) {
               constraints_.emplace_back(
-                  new CompiledNoOverlapWithTwoIntervals<true>(proto_i,
-                                                              proto_j));
+                  new CompiledNoOverlapWithTwoIntervals<true>(
+                      ct.enforcement_literal(), proto_i, proto_j));
             } else {
               constraints_.emplace_back(
-                  new CompiledNoOverlapWithTwoIntervals<false>(proto_i,
-                                                               proto_j));
+                  new CompiledNoOverlapWithTwoIntervals<false>(
+                      /*enforcement_literals=*/{}, proto_i, proto_j));
             }
           }
         }
@@ -1763,6 +1768,10 @@ void LsEvaluator::CompileOneConstraint(const ConstraintProto& ct) {
     }
     case ConstraintProto::ConstraintCase::kCumulative: {
       LinearExpressionProto capacity = ct.cumulative().capacity();
+      std::vector<int> enforcement_literals;
+      for (const int lit : ct.enforcement_literal()) {
+        enforcement_literals.push_back(lit);
+      }
       std::vector<std::optional<int>> is_active;
       std::vector<LinearExpressionProto> times;
       std::vector<LinearExpressionProto> demands;
@@ -1797,8 +1806,8 @@ void LsEvaluator::CompileOneConstraint(const ConstraintProto& ct) {
       }
 
       constraints_.emplace_back(new CompiledReservoirConstraint(
-          std::move(capacity), std::move(is_active), std::move(times),
-          std::move(demands)));
+          std::move(enforcement_literals), std::move(capacity),
+          std::move(is_active), std::move(times), std::move(demands)));
       break;
     }
     case ConstraintProto::ConstraintCase::kNoOverlap2D: {
@@ -1844,17 +1853,20 @@ void LsEvaluator::CompileOneConstraint(const ConstraintProto& ct) {
           }
 
           const bool has_enforcement =
+              !ct.enforcement_literal().empty() ||
               !x_proto_i.enforcement_literal().empty() ||
               !x_proto_j.enforcement_literal().empty() ||
               !y_proto_i.enforcement_literal().empty() ||
               !y_proto_j.enforcement_literal().empty();
           if (has_enforcement) {
             constraints_.emplace_back(new CompiledNoOverlap2dWithTwoBoxes<true>(
-                x_proto_i, y_proto_i, x_proto_j, y_proto_j));
+                ct.enforcement_literal(), x_proto_i, y_proto_i, x_proto_j,
+                y_proto_j));
           } else {
             constraints_.emplace_back(
                 new CompiledNoOverlap2dWithTwoBoxes<false>(
-                    x_proto_i, y_proto_i, x_proto_j, y_proto_j));
+                    /*enforcement_literals=*/{}, x_proto_i, y_proto_i,
+                    x_proto_j, y_proto_j));
           }
         }
       }
@@ -2120,6 +2132,21 @@ void LsEvaluator::UpdateViolatedList(const int c) {
   }
 }
 
+// Note that since we have our own ViolationDelta() implementation this is
+// only used for initialization and our PerformMove(). It is why we set
+// violations_ here.
+int64_t CompiledReservoirConstraint::ComputeViolation(
+    absl::Span<const int64_t> solution) {
+  for (const int lit : enforcement_literals_) {
+    if (!LiteralValue(lit, solution)) {
+      violation_ = 0;
+      return 0;
+    }
+  }
+  violation_ = BuildProfileAndReturnViolation(solution);
+  return violation_;
+}
+
 int64_t CompiledReservoirConstraint::BuildProfileAndReturnViolation(
     absl::Span<const int64_t> solution) {
   // Starts by filling the cache and profile_.
@@ -2174,6 +2201,11 @@ int64_t CompiledReservoirConstraint::BuildProfileAndReturnViolation(
 
 int64_t CompiledReservoirConstraint::IncrementalViolation(
     int var, absl::Span<const int64_t> solution) {
+  for (const int lit : enforcement_literals_) {
+    if (!LiteralValue(lit, solution)) {
+      return 0;
+    }
+  }
   const int64_t capacity = ExprValue(capacity_, solution);
   profile_delta_.clear();
   CHECK(RefIsPositive(var));
diff --git a/ortools/sat/constraint_violation.h b/ortools/sat/constraint_violation.h
index 6284cf924a..8eeaa98cc5 100644
--- a/ortools/sat/constraint_violation.h
+++ b/ortools/sat/constraint_violation.h
@@ -588,7 +588,7 @@ struct ViewOfAffineLinearExpressionProto {
 };
 
 // Special constraint for no overlap between two intervals.
-// We usually expand small no-overlap in n^2 such constraint, so we want to
+// We usually expand small no-overlap in n^2 such constraints, so we want to
 // be compact and efficient here.
 template <bool has_enforcement = true>
 class CompiledNoOverlapWithTwoIntervals : public CompiledConstraint {
@@ -600,11 +600,15 @@ class CompiledNoOverlapWithTwoIntervals : public CompiledConstraint {
     ViewOfAffineLinearExpressionProto end;
   };
 
-  CompiledNoOverlapWithTwoIntervals(const ConstraintProto& x1,
+  CompiledNoOverlapWithTwoIntervals(absl::Span<const int> enforcement_literals,
+                                    const ConstraintProto& x1,
                                     const ConstraintProto& x2)
       : interval1_(x1), interval2_(x2) {
     if (has_enforcement) {
-      enforcements_.assign(x1.enforcement_literal().begin(),
+      enforcements_.assign(enforcement_literals.begin(),
+                           enforcement_literals.end());
+      enforcements_.insert(enforcements_.end(),
+                           x1.enforcement_literal().begin(),
                            x1.enforcement_literal().end());
       enforcements_.insert(enforcements_.end(),
                            x2.enforcement_literal().begin(),
@@ -664,13 +668,17 @@ class CompiledNoOverlap2dWithTwoBoxes : public CompiledConstraint {
     ViewOfAffineLinearExpressionProto y_max;
   };
 
-  CompiledNoOverlap2dWithTwoBoxes(const ConstraintProto& x1,
+  CompiledNoOverlap2dWithTwoBoxes(absl::Span<const int> enforcement_literals,
+                                  const ConstraintProto& x1,
                                   const ConstraintProto& y1,
                                   const ConstraintProto& x2,
                                   const ConstraintProto& y2)
       : box1_(x1, y1), box2_(x2, y2) {
     if (has_enforcement) {
-      enforcements_.assign(x1.enforcement_literal().begin(),
+      enforcements_.assign(enforcement_literals.begin(),
+                           enforcement_literals.end());
+      enforcements_.insert(enforcements_.end(),
+                           x1.enforcement_literal().begin(),
                            x1.enforcement_literal().end());
       enforcements_.insert(enforcements_.end(),
                            y1.enforcement_literal().begin(),
@@ -720,11 +728,13 @@ class CompiledNoOverlap2dWithTwoBoxes : public CompiledConstraint {
 // ViolationDelta().
 class CompiledReservoirConstraint : public CompiledConstraint {
  public:
-  CompiledReservoirConstraint(LinearExpressionProto capacity,
+  CompiledReservoirConstraint(std::vector<int> enforcement_literals,
+                              LinearExpressionProto capacity,
                               std::vector<std::optional<int>> is_active,
                               std::vector<LinearExpressionProto> times,
                               std::vector<LinearExpressionProto> demands)
-      : capacity_(std::move(capacity)),
+      : enforcement_literals_(std::move(enforcement_literals)),
+        capacity_(std::move(capacity)),
         is_active_(std::move(is_active)),
         times_(std::move(times)),
         demands_(std::move(demands)) {
@@ -734,13 +744,7 @@ class CompiledReservoirConstraint : public CompiledConstraint {
     InitializeDenseIndexToEvents();
   }
 
-  // Note that since we have our own ViolationDelta() implementation this is
-  // only used for initialization and our PerformMove(). It is why we set
-  // violations_ here.
-  int64_t ComputeViolation(absl::Span<const int64_t> solution) final {
-    violation_ = BuildProfileAndReturnViolation(solution);
-    return violation_;
-  }
+  int64_t ComputeViolation(absl::Span<const int64_t> solution) final;
 
   void PerformMove(int /*var*/, int64_t /*old_value*/,
                    absl::Span<const int64_t> solution_with_new_value) final {
@@ -772,6 +776,7 @@ class CompiledReservoirConstraint : public CompiledConstraint {
 
   // The const data from the constructor.
   // Note that is_active_ might be empty if all events are mandatory.
+  const std::vector<int> enforcement_literals_;
   const LinearExpressionProto capacity_;
   const std::vector<std::optional<int>> is_active_;
   const std::vector<LinearExpressionProto> times_;
diff --git a/ortools/sat/container.h b/ortools/sat/container.h
new file mode 100644
index 0000000000..cbb58974da
--- /dev/null
+++ b/ortools/sat/container.h
@@ -0,0 +1,238 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OR_TOOLS_SAT_CONTAINER_H_
+#define OR_TOOLS_SAT_CONTAINER_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+#include <utility>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/log/check.h"
+#include "absl/types/span.h"
+#include "ortools/base/stl_util.h"
+#include "ortools/sat/sat_base.h"
+
+namespace operations_research {
+namespace sat {
+
+// This is a very specific container that is optimized for the specific usage
+// patterns of BinaryImplicationGraph.
+// It stores an ordered set of literals and an unordered set of offsets.
+// internally, both arrays are stored contiguously, literals first, then
+// offsets. There might be a hole between the two arrays. In comments, we denote
+// literals as `L` and offsets as `O`, and holes as `.`. For example, `LLL..OO`
+// has 3 literals and 2 offsets, with a hole of size 2 in between.
+class LiteralsOrOffsets {
+ public:
+  LiteralsOrOffsets() = default;
+
+  LiteralsOrOffsets(const LiteralsOrOffsets&) = delete;
+  LiteralsOrOffsets& operator=(const LiteralsOrOffsets&) = delete;
+  LiteralsOrOffsets(LiteralsOrOffsets&&) = default;
+  LiteralsOrOffsets& operator=(LiteralsOrOffsets&&) = default;
+
+  using Offset = int;
+
+  // Adds a literal to the end of the list of literals.
+  void PushBackLiteral(Literal literal);
+
+  // Adds an offset to the set of offsets.
+  void InsertOffset(Offset offset) {
+    values_.push_back({.offset = offset});
+    ++num_offsets_;
+  }
+
+  int num_literals() const { return num_literals_; }
+  int num_offsets() const { return num_offsets_; }
+
+  absl::Span<const Literal> literals() const;
+  absl::Span<Literal> literals();
+
+  // Note that order is arbitrary.
+  absl::Span<const Offset> offsets() const;
+  absl::Span<Offset> offsets();
+
+  // Clears the literals and offsets. If `shrink_to_fit` is true, releases the
+  // backing memory.
+  void Clear(bool shrink_to_fit);
+
+  // Clears the literals. If `shrink_to_fit` is true, compacts the backing
+  // memory (i.e., also removes the potential hole in between literals and
+  // offsets).
+  void ClearLiterals(bool shrink_to_fit);
+
+  // Clears offsets.
+  void ClearOffsets() { num_offsets_ = 0; }
+
+  // Resizes the list of literals. If `new_size` is smaller than the current
+  // size, the literals are truncated (memory is not released). Otherwise,
+  // the list is extended with default-constructed literals.
+  void ResizeLiterals(int new_size);
+
+  // Removes all literals for which `predicate` returns true, and truncates the
+  // list of literals to the number of remaining literals (memory is not
+  // released).
+  template <typename Predicate>
+  void RemoveLiteralsIf(Predicate predicate);
+
+  // Sorts the list of literals, removes duplicate literals, and truncates the
+  // list of literals to the number of remaining literals (memory is not
+  // released).
+  void SortLiteralsAndRemoveDuplicates();
+
+  // Returns the backing capacity for literals and offsets.
+  size_t capacity() const { return values_.capacity(); }
+
+  static constexpr size_t kInlineElements = 4;
+
+ private:
+  // Elements are either literals or offsets.
+  union LiteralOrOffset {
+    Literal literal;
+    Offset offset;
+  };
+  static_assert(std::is_trivially_destructible_v<Literal>);
+
+  uint32_t num_literals_ = 0;
+  uint32_t num_offsets_ = 0;
+  // This array contains `num_literals_` literals, then `values_.size() -
+  // num_literals_ - num_offsets_` holes, then `num_offsets_` offsets.
+  // TODO(user): Try a custom implementation of a inlined vector with just a
+  // "capacity" we can always put the literal in [0, num_literals) and the
+  // offsets in [capa-num_offset, capa). This should have the same number of
+  // inlined element while taking 64bit less per LiteralsOrOffsets.
+  absl::InlinedVector<LiteralOrOffset, kInlineElements> values_;
+};
+
+inline absl::Span<const Literal> LiteralsOrOffsets::literals() const {
+  DCHECK_LE(num_literals_, values_.size());
+  // Casting is OK because "pointer to LiteralOrOffset" is
+  // pointer-interconvertible with "pointer to Literal": `LiteralOrOffset` is
+  // an union object and the other is a non-static data member of that object.
+  return absl::MakeConstSpan(reinterpret_cast<const Literal*>(values_.data()),
+                             num_literals_);
+}
+
+inline absl::Span<Literal> LiteralsOrOffsets::literals() {
+  DCHECK_LE(num_literals_, values_.size());
+  return absl::MakeSpan(reinterpret_cast<Literal*>(values_.data()),
+                        num_literals_);
+}
+
+inline absl::Span<const LiteralsOrOffsets::Offset> LiteralsOrOffsets::offsets()
+    const {
+  DCHECK_LE(num_offsets_, values_.size());
+  return absl::MakeConstSpan(
+      reinterpret_cast<const Offset*>(values_.data() +
+                                      (values_.size() - num_offsets_)),
+      num_offsets_);
+}
+
+inline absl::Span<LiteralsOrOffsets::Offset> LiteralsOrOffsets::offsets() {
+  DCHECK_LE(num_offsets_, values_.size());
+  return absl::MakeSpan(reinterpret_cast<Offset*>(
+                            values_.data() + (values_.size() - num_offsets_)),
+                        num_offsets_);
+}
+
+inline void LiteralsOrOffsets::PushBackLiteral(Literal literal) {
+  // When adding a new literal N, there are three cases:
+  //   -  There is a hole, we can put the literal here:
+  //      `LLLL..OOO` -> `LLLLN.OOO`, or
+  //      `LLLL..` -> `LLLLN.`
+  //   -  There are only literals. We can just append the literal:
+  //      `LLLL` -> `LLLLN`
+  //   -  There is no space before the offsets. The last offset must be moved
+  //      to the back to make room:
+  //      `LLLLOOO` -> `LLLL.OOO` -> `LLLLNOOO`
+  if (values_.size() > (num_literals_ + num_offsets_)) {
+    // There is a hole, use it.
+    values_[num_literals_].literal = literal;
+  } else if (num_offsets_ == 0) {
+    values_.push_back({.literal = literal});
+  } else {
+    // Move the first offset to the back to make room for the new literal.
+    values_.push_back(values_[num_literals_]);
+    values_[num_literals_].literal = literal;
+  }
+  ++num_literals_;
+}
+
+inline void LiteralsOrOffsets::ResizeLiterals(int new_size) {
+  if (new_size <= num_literals_) {
+    num_literals_ = new_size;
+    return;
+  }
+  const int grow_by = new_size - num_literals_;
+  // We have to create a hole of size at least `grow_by` by moving offsets to
+  // the end.
+  const int hole_size = values_.size() - (num_literals_ + num_offsets_);
+  DCHECK_GE(hole_size, 0);
+  if (hole_size < grow_by) {
+    const int hole_growth = grow_by - hole_size;
+    values_.resize(values_.size() + hole_growth);
+    memcpy(values_.data() + num_literals_ + hole_size + num_offsets_,
+           values_.data() + num_literals_ + hole_size,
+           hole_growth * sizeof(LiteralOrOffset));
+  }
+  // Initialize with default-constructed literals.
+  LiteralOrOffset* const hole_data = values_.data() + num_literals_;
+  for (int i = 0; i < grow_by; ++i) {
+    hole_data[i].literal = {};
+  }
+  num_literals_ = new_size;
+}
+
+template <typename Predicate>
+void LiteralsOrOffsets::RemoveLiteralsIf(Predicate predicate) {
+  const auto new_end = std::remove_if(literals().begin(), literals().end(),
+                                      std::move(predicate));
+  num_literals_ = new_end - literals().begin();
+}
+
+inline void LiteralsOrOffsets::SortLiteralsAndRemoveDuplicates() {
+  const auto range = literals();
+  std::sort(range.begin(), range.end());
+  const auto new_end = std::unique(range.begin(), range.end());
+  num_literals_ = new_end - literals().begin();
+}
+
+inline void LiteralsOrOffsets::Clear(bool shrink_to_fit) {
+  num_literals_ = 0;
+  num_offsets_ = 0;
+  if (shrink_to_fit) {
+    gtl::STLClearObject(&values_);
+  }
+}
+
+inline void LiteralsOrOffsets::ClearLiterals(bool shrink_to_fit) {
+  num_literals_ = 0;
+  if (shrink_to_fit) {
+    absl::InlinedVector<LiteralOrOffset, kInlineElements> tmp;
+    if (num_offsets_ > 0) {
+      tmp.insert(tmp.end(), values_.data() + (values_.size() - num_offsets_),
+                 values_.data() + values_.size());
+    }
+    values_ = std::move(tmp);
+  }
+}
+
+}  // namespace sat
+}  // namespace operations_research
+
+#endif  // OR_TOOLS_SAT_CONTAINER_H_
diff --git a/ortools/sat/container_test.cc b/ortools/sat/container_test.cc
new file mode 100644
index 0000000000..56247a4e99
--- /dev/null
+++ b/ortools/sat/container_test.cc
@@ -0,0 +1,139 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/container.h"
+
+#include "gtest/gtest.h"
+#include "ortools/base/gmock.h"
+#include "ortools/sat/sat_base.h"
+
+namespace operations_research {
+namespace sat {
+namespace {
+
+using testing::ElementsAre;
+using testing::SizeIs;
+using testing::UnorderedElementsAre;
+
+TEST(LiteralsOrOffsetsTest, Basic) {
+  LiteralsOrOffsets container;
+  container.PushBackLiteral(Literal(1));
+  container.InsertOffset(2);
+  container.PushBackLiteral(Literal(3));
+  container.InsertOffset(4);
+  container.PushBackLiteral(Literal(5));
+
+  EXPECT_EQ(container.num_literals(), 3);
+  EXPECT_EQ(container.num_offsets(), 2);
+
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(1), Literal(3), Literal(5)));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(2, 4));
+}
+
+TEST(LiteralsOrOffsetsTest, Holes) {
+  LiteralsOrOffsets container;
+
+  // LLLOO
+  container.PushBackLiteral(Literal(11));
+  container.PushBackLiteral(Literal(12));
+  container.PushBackLiteral(Literal(13));
+  container.InsertOffset(21);
+  container.InsertOffset(22);
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(11), Literal(12), Literal(13)));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(21, 22));
+
+  // LLLLOO
+  container.ResizeLiterals(4);
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(11), Literal(12), Literal(13), Literal()));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(21, 22));
+
+  // LL..OO
+  container.RemoveLiteralsIf(
+      [](Literal l) { return l == Literal(11) || l == Literal(13); });
+  EXPECT_THAT(container.literals(), ElementsAre(Literal(12), Literal()));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(21, 22));
+
+  // LLL.OO
+  container.ResizeLiterals(3);
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(12), Literal(), Literal()));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(21, 22));
+
+  // LLL.
+  container.ClearOffsets();
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(12), Literal(), Literal()));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre());
+
+  // LLLL
+  container.PushBackLiteral(Literal(14));
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(12), Literal(), Literal(), Literal(14)));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre());
+
+  // LLLL0
+  container.InsertOffset(23);
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(12), Literal(), Literal(), Literal(14)));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(23));
+}
+
+TEST(LiteralsOrOffsetsTest, Capacity) {
+  LiteralsOrOffsets container;
+  container.ResizeLiterals(10);
+  container.InsertOffset(2);
+  EXPECT_THAT(container.literals(), SizeIs(10));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(2));
+  EXPECT_GE(container.capacity(), 11);
+
+  container.ClearLiterals(/*shrink_to_fit=*/false);
+  EXPECT_THAT(container.literals(), SizeIs(0));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(2));
+  EXPECT_GE(container.capacity(), 11);
+
+  container.ResizeLiterals(9);
+  EXPECT_THAT(container.literals(), SizeIs(9));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(2));
+  EXPECT_GE(container.capacity(), 10);
+
+  container.ClearLiterals(/*shrink_to_fit=*/true);
+  EXPECT_THAT(container.literals(), SizeIs(0));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(2));
+  EXPECT_THAT(container.capacity(), LiteralsOrOffsets::kInlineElements);
+}
+
+TEST(LiteralsOrOffsetsTest, SortLiteralsAndRemoveDuplicates) {
+  LiteralsOrOffsets container;
+  container.PushBackLiteral(Literal(1));
+  container.PushBackLiteral(Literal(2));
+  container.PushBackLiteral(Literal(3));
+  container.PushBackLiteral(Literal(1));
+  container.PushBackLiteral(Literal(2));
+  container.PushBackLiteral(Literal(3));
+  container.PushBackLiteral(Literal(4));
+  container.PushBackLiteral(Literal(2));
+  container.InsertOffset(15);
+  container.InsertOffset(16);
+  container.InsertOffset(17);
+  container.SortLiteralsAndRemoveDuplicates();
+  EXPECT_THAT(container.literals(),
+              ElementsAre(Literal(1), Literal(2), Literal(3), Literal(4)));
+  EXPECT_THAT(container.offsets(), UnorderedElementsAre(15, 16, 17));
+}
+
+}  // namespace
+}  // namespace sat
+}  // namespace operations_research
diff --git a/ortools/sat/cp_constraints.cc b/ortools/sat/cp_constraints.cc
index 341ca496bd..2739446378 100644
--- a/ortools/sat/cp_constraints.cc
+++ b/ortools/sat/cp_constraints.cc
@@ -14,381 +14,35 @@
 #include "ortools/sat/cp_constraints.h"
 
 #include <algorithm>
-#include <functional>
-#include <ostream>
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/types/span.h"
-#include "ortools/base/stl_util.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/sat_base.h"
-#include "ortools/sat/sat_solver.h"
 #include "ortools/util/strong_integers.h"
 
 namespace operations_research {
 namespace sat {
 
-std::ostream& operator<<(std::ostream& os, const EnforcementStatus& e) {
-  switch (e) {
-    case EnforcementStatus::IS_FALSE:
-      os << "IS_FALSE";
-      break;
-    case EnforcementStatus::CANNOT_PROPAGATE:
-      os << "CANNOT_PROPAGATE";
-      break;
-    case EnforcementStatus::CAN_PROPAGATE:
-      os << "CAN_PROPAGATE";
-      break;
-    case EnforcementStatus::IS_ENFORCED:
-      os << "IS_ENFORCED";
-      break;
-  }
-  return os;
-}
-
-EnforcementPropagator::EnforcementPropagator(Model* model)
-    : SatPropagator("EnforcementPropagator"),
-      trail_(*model->GetOrCreate<Trail>()),
-      assignment_(trail_.Assignment()),
-      integer_trail_(model->GetOrCreate<IntegerTrail>()),
-      rev_int_repository_(model->GetOrCreate<RevIntRepository>()) {
-  // Note that this will be after the integer trail since rev_int_repository_
-  // depends on IntegerTrail.
-  model->GetOrCreate<SatSolver>()->AddPropagator(this);
-
-  // Sentinel - also start of next Register().
-  starts_.push_back(0);
-}
-
-bool EnforcementPropagator::Propagate(Trail* /*trail*/) {
-  rev_int_repository_->SaveStateWithStamp(&rev_stack_size_, &rev_stamp_);
-  while (propagation_trail_index_ < trail_.Index()) {
-    const Literal literal = trail_[propagation_trail_index_++];
-    if (literal.Index() >= static_cast<int>(watcher_.size())) continue;
-
-    int new_size = 0;
-    auto& watch_list = watcher_[literal.Index()];
-    for (const EnforcementId id : watch_list) {
-      const LiteralIndex index = ProcessIdOnTrue(literal, id);
-      if (index == kNoLiteralIndex) {
-        // We keep the same watcher.
-        watch_list[new_size++] = id;
-      } else {
-        // Change the watcher.
-        CHECK_NE(index, literal.Index());
-        watcher_[index].push_back(id);
-      }
-    }
-    watch_list.resize(new_size);
-
-    // We also mark some constraint false.
-    for (const EnforcementId id : watcher_[literal.NegatedIndex()]) {
-      ChangeStatus(id, EnforcementStatus::IS_FALSE);
-    }
-  }
-  rev_stack_size_ = static_cast<int>(untrail_stack_.size());
-
-  // Compute the enforcement status of any constraint added at a positive level.
-  // This is only needed until we are back to level zero.
-  for (const EnforcementId id : ids_to_fix_until_next_root_level_) {
-    ChangeStatus(id, DebugStatus(id));
-  }
-  if (trail_.CurrentDecisionLevel() == 0) {
-    ids_to_fix_until_next_root_level_.clear();
-  }
-
-  return true;
-}
-
-void EnforcementPropagator::Untrail(const Trail& /*trail*/, int trail_index) {
-  // Simply revert the status change.
-  const int size = static_cast<int>(untrail_stack_.size());
-  for (int i = size - 1; i >= rev_stack_size_; --i) {
-    const auto [id, status] = untrail_stack_[i];
-    statuses_[id] = status;
-    if (callbacks_[id] != nullptr) callbacks_[id](id, status);
-  }
-  untrail_stack_.resize(rev_stack_size_);
-  propagation_trail_index_ = trail_index;
-}
-
-// Adds a new constraint to the class and returns the constraint id.
-//
-// Note that we accept empty enforcement list so that client code can be used
-// regardless of the presence of enforcement or not. A negative id means the
-// constraint is never enforced, and should be ignored.
-EnforcementId EnforcementPropagator::Register(
-    absl::Span<const Literal> enforcement,
-    std::function<void(EnforcementId, EnforcementStatus)> callback) {
-  int num_true = 0;
-  int num_false = 0;
-  temp_literals_.clear();
-  const int level = trail_.CurrentDecisionLevel();
-  for (const Literal l : enforcement) {
-    // Make sure we always have enough room for the literal and its negation.
-    const int size = std::max(l.Index().value(), l.NegatedIndex().value()) + 1;
-    if (size > static_cast<int>(watcher_.size())) {
-      watcher_.resize(size);
-    }
-    if (assignment_.LiteralIsTrue(l)) {
-      if (level == 0 || trail_.Info(l.Variable()).level == 0) continue;
-      ++num_true;
-    } else if (assignment_.LiteralIsFalse(l)) {
-      ++num_false;
-    }
-    temp_literals_.push_back(l);
-  }
-  gtl::STLSortAndRemoveDuplicates(&temp_literals_);
-
-  // Return special index if always enforced.
-  if (temp_literals_.empty()) {
-    if (callback != nullptr)
-      callback(EnforcementId(-1), EnforcementStatus::IS_ENFORCED);
-    return EnforcementId(-1);
-  }
-
-  const EnforcementId id(static_cast<int>(callbacks_.size()));
-  callbacks_.push_back(std::move(callback));
-
-  CHECK(!temp_literals_.empty());
-  buffer_.insert(buffer_.end(), temp_literals_.begin(), temp_literals_.end());
-  starts_.push_back(buffer_.size());  // Sentinel/next-start.
-
-  // The default status at level zero.
-  statuses_.push_back(temp_literals_.size() == 1
-                          ? EnforcementStatus::CAN_PROPAGATE
-                          : EnforcementStatus::CANNOT_PROPAGATE);
-
-  if (temp_literals_.size() == 1) {
-    watcher_[temp_literals_[0].Index()].push_back(id);
-  } else {
-    // Make sure we watch correct literals.
-    const auto span = GetSpan(id);
-    int num_not_true = 0;
-    for (int i = 0; i < span.size(); ++i) {
-      if (assignment_.LiteralIsTrue(span[i])) continue;
-      std::swap(span[num_not_true], span[i]);
-      ++num_not_true;
-      if (num_not_true == 2) break;
-    }
-
-    // We need to watch one of the literals at highest level.
-    if (num_not_true == 1) {
-      int max_level = trail_.Info(span[1].Variable()).level;
-      for (int i = 2; i < span.size(); ++i) {
-        const int level = trail_.Info(span[i].Variable()).level;
-        if (level > max_level) {
-          max_level = level;
-          std::swap(span[1], span[i]);
-        }
-      }
-    }
-
-    watcher_[span[0].Index()].push_back(id);
-    watcher_[span[1].Index()].push_back(id);
-  }
-
-  // Change status, call callback and set up untrail if the status is different
-  // from EnforcementStatus::CANNOT_PROPAGATE.
-  if (num_false > 0) {
-    ChangeStatus(id, EnforcementStatus::IS_FALSE);
-  } else if (num_true == temp_literals_.size()) {
-    ChangeStatus(id, EnforcementStatus::IS_ENFORCED);
-  } else if (num_true + 1 == temp_literals_.size()) {
-    ChangeStatus(id, EnforcementStatus::CAN_PROPAGATE);
-    // Because this is the default status, we still need to call the callback.
-    if (temp_literals_.size() == 1) {
-      if (callbacks_[id] != nullptr) {
-        callbacks_[id](id, EnforcementStatus::CAN_PROPAGATE);
-      }
-    }
-  }
-
-  // Tricky: if we added something at a positive level, and its status is
-  // not CANNOT_PROPAGATE, then we might need to fix it on backtrack.
-  if (trail_.CurrentDecisionLevel() > 0 &&
-      statuses_[id] != EnforcementStatus::CANNOT_PROPAGATE) {
-    ids_to_fix_until_next_root_level_.push_back(id);
-  }
-
-  return id;
-}
-
-EnforcementId EnforcementPropagator::Register(
-    absl::Span<const Literal> enforcement_literals,
-    GenericLiteralWatcher* watcher, int literal_watcher_id) {
-  return Register(enforcement_literals,
-                  [=](EnforcementId, EnforcementStatus status) {
-                    if (status == EnforcementStatus::CAN_PROPAGATE ||
-                        status == EnforcementStatus::IS_ENFORCED) {
-                      watcher->CallOnNextPropagate(literal_watcher_id);
-                    }
-                  });
-}
-
-// Add the enforcement reason to the given vector.
-void EnforcementPropagator::AddEnforcementReason(
-    EnforcementId id, std::vector<Literal>* reason) const {
-  for (const Literal l : GetSpan(id)) {
-    reason->push_back(l.Negated());
-  }
-}
-
-// Try to propagate when the enforced constraint is not satisfiable.
-// This is currently in O(enforcement_size);
-bool EnforcementPropagator::PropagateWhenFalse(
-    EnforcementId id, absl::Span<const Literal> literal_reason,
-    absl::Span<const IntegerLiteral> integer_reason) {
-  temp_reason_.clear();
-  LiteralIndex unique_unassigned = kNoLiteralIndex;
-  for (const Literal l : GetSpan(id)) {
-    if (assignment_.LiteralIsFalse(l)) return true;
-    if (assignment_.LiteralIsTrue(l)) {
-      temp_reason_.push_back(l.Negated());
-      continue;
-    }
-    if (unique_unassigned != kNoLiteralIndex) return true;
-    unique_unassigned = l.Index();
-  }
-
-  temp_reason_.insert(temp_reason_.end(), literal_reason.begin(),
-                      literal_reason.end());
-  if (unique_unassigned == kNoLiteralIndex) {
-    return integer_trail_->ReportConflict(temp_reason_, integer_reason);
-  }
-
-  // We also change the status right away.
-  ChangeStatus(id, EnforcementStatus::IS_FALSE);
-  integer_trail_->EnqueueLiteral(Literal(unique_unassigned).Negated(),
-                                 temp_reason_, integer_reason);
-  return true;
-}
-
-bool EnforcementPropagator::SafeEnqueue(
-    EnforcementId id, IntegerLiteral i_lit,
-    absl::Span<const IntegerLiteral> integer_reason) {
-  temp_reason_.clear();
-  AddEnforcementReason(id, &temp_reason_);
-  return integer_trail_->SafeEnqueue(i_lit, temp_reason_, integer_reason);
-}
-
-bool EnforcementPropagator::ReportConflict(
-    EnforcementId id, absl::Span<const IntegerLiteral> integer_reason) {
-  temp_reason_.clear();
-  AddEnforcementReason(id, &temp_reason_);
-  return integer_trail_->ReportConflict(temp_reason_, integer_reason);
-}
-
-absl::Span<Literal> EnforcementPropagator::GetSpan(EnforcementId id) {
-  if (id < 0) return {};
-  DCHECK_LE(id + 1, starts_.size());
-  const int size = starts_[id + 1] - starts_[id];
-  DCHECK_NE(size, 0);
-  return absl::MakeSpan(&buffer_[starts_[id]], size);
-}
-
-absl::Span<const Literal> EnforcementPropagator::GetSpan(
-    EnforcementId id) const {
-  if (id < 0) return {};
-  DCHECK_LE(id + 1, starts_.size());
-  const int size = starts_[id + 1] - starts_[id];
-  DCHECK_NE(size, 0);
-  return absl::MakeSpan(&buffer_[starts_[id]], size);
-}
-
-LiteralIndex EnforcementPropagator::ProcessIdOnTrue(Literal watched,
-                                                    EnforcementId id) {
-  const EnforcementStatus status = statuses_[id];
-  if (status == EnforcementStatus::IS_FALSE) return kNoLiteralIndex;
-
-  const auto span = GetSpan(id);
-  if (span.size() == 1) {
-    CHECK_EQ(status, EnforcementStatus::CAN_PROPAGATE);
-    ChangeStatus(id, EnforcementStatus::IS_ENFORCED);
-    return kNoLiteralIndex;
-  }
-
-  const int watched_pos = (span[0] == watched) ? 0 : 1;
-  CHECK_EQ(span[watched_pos], watched);
-  if (assignment_.LiteralIsFalse(span[watched_pos ^ 1])) {
-    ChangeStatus(id, EnforcementStatus::IS_FALSE);
-    return kNoLiteralIndex;
-  }
-
-  for (int i = 2; i < span.size(); ++i) {
-    const Literal l = span[i];
-    if (assignment_.LiteralIsFalse(l)) {
-      ChangeStatus(id, EnforcementStatus::IS_FALSE);
-      return kNoLiteralIndex;
-    }
-    if (!assignment_.LiteralIsAssigned(l)) {
-      // Replace the watched literal. Note that if the other watched literal is
-      // true, it should be processed afterwards. We do not change the status
-      std::swap(span[watched_pos], span[i]);
-      return span[watched_pos].Index();
-    }
-  }
-
-  // All literal with index > 1 are true. Two case.
-  if (assignment_.LiteralIsTrue(span[watched_pos ^ 1])) {
-    // All literals are true.
-    ChangeStatus(id, EnforcementStatus::IS_ENFORCED);
-    return kNoLiteralIndex;
-  } else {
-    // The other watched literal is the last unassigned
-    CHECK_EQ(status, EnforcementStatus::CANNOT_PROPAGATE);
-    ChangeStatus(id, EnforcementStatus::CAN_PROPAGATE);
-    return kNoLiteralIndex;
-  }
-}
-
-void EnforcementPropagator::ChangeStatus(EnforcementId id,
-                                         EnforcementStatus new_status) {
-  const EnforcementStatus old_status = statuses_[id];
-  if (old_status == new_status) return;
-  if (trail_.CurrentDecisionLevel() != 0) {
-    untrail_stack_.push_back({id, old_status});
-  }
-  statuses_[id] = new_status;
-  if (callbacks_[id] != nullptr) callbacks_[id](id, new_status);
-}
-
-EnforcementStatus EnforcementPropagator::DebugStatus(EnforcementId id) {
-  if (id < 0) return EnforcementStatus::IS_ENFORCED;
-
-  int num_true = 0;
-  for (const Literal l : GetSpan(id)) {
-    if (assignment_.LiteralIsFalse(l)) {
-      return EnforcementStatus::IS_FALSE;
-    }
-    if (assignment_.LiteralIsTrue(l)) ++num_true;
-  }
-  const int size = GetSpan(id).size();
-  if (num_true == size) return EnforcementStatus::IS_ENFORCED;
-  if (num_true + 1 == size) return EnforcementStatus::CAN_PROPAGATE;
-  return EnforcementStatus::CANNOT_PROPAGATE;
-}
-
 BooleanXorPropagator::BooleanXorPropagator(
     absl::Span<const Literal> enforcement_literals,
     const std::vector<Literal>& literals, bool value, Model* model)
     : literals_(literals),
       value_(value),
-      trail_(model->GetOrCreate<Trail>()),
-      integer_trail_(model->GetOrCreate<IntegerTrail>()),
-      enforcement_propagator_(model->GetOrCreate<EnforcementPropagator>()) {
+      trail_(*model->GetOrCreate<Trail>()),
+      integer_trail_(*model->GetOrCreate<IntegerTrail>()),
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
-  enforcement_id_ = enforcement_propagator_->Register(
-      enforcement_literals, watcher, RegisterWith(watcher));
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
 }
 
 bool BooleanXorPropagator::Propagate() {
-  const EnforcementStatus status =
-      enforcement_propagator_->Status(enforcement_id_);
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
   if (status == EnforcementStatus::IS_FALSE ||
       status == EnforcementStatus::CANNOT_PROPAGATE) {
     return true;
@@ -398,9 +52,9 @@ bool BooleanXorPropagator::Propagate() {
   int unassigned_index = -1;
   for (int i = 0; i < literals_.size(); ++i) {
     const Literal l = literals_[i];
-    if (trail_->Assignment().LiteralIsFalse(l)) {
+    if (trail_.Assignment().LiteralIsFalse(l)) {
       sum ^= false;
-    } else if (trail_->Assignment().LiteralIsTrue(l)) {
+    } else if (trail_.Assignment().LiteralIsTrue(l)) {
       sum ^= true;
     } else {
       // If we have more than one unassigned literal, we can't deduce anything.
@@ -409,29 +63,23 @@ bool BooleanXorPropagator::Propagate() {
     }
   }
 
-  // Propagates?
-  if (status == EnforcementStatus::IS_ENFORCED && unassigned_index != -1) {
+  auto fill_literal_reason = [&]() {
     literal_reason_.clear();
-    enforcement_propagator_->AddEnforcementReason(enforcement_id_,
-                                                  &literal_reason_);
     for (int i = 0; i < literals_.size(); ++i) {
       if (i == unassigned_index) continue;
       const Literal l = literals_[i];
       literal_reason_.push_back(
-          trail_->Assignment().LiteralIsFalse(l) ? l : l.Negated());
+          trail_.Assignment().LiteralIsFalse(l) ? l : l.Negated());
     }
+  };
+
+  // Propagates?
+  if (status == EnforcementStatus::IS_ENFORCED && unassigned_index != -1) {
+    fill_literal_reason();
     const Literal u = literals_[unassigned_index];
-    integer_trail_->EnqueueLiteral(sum == value_ ? u.Negated() : u,
-                                   literal_reason_, {});
-    return true;
-  }
-  if (status == EnforcementStatus::CAN_PROPAGATE && unassigned_index == -1 &&
-      sum != value_) {
-    return enforcement_propagator_->PropagateWhenFalse(enforcement_id_,
-                                                       literals_,
-                                                       /*integer_reason=*/{});
-  }
-  if (status != EnforcementStatus::IS_ENFORCED || unassigned_index != -1) {
+    enforcement_helper_.EnqueueLiteral(
+        enforcement_id_, sum == value_ ? u.Negated() : u, literal_reason_,
+        /*integer_reason=*/{});
     return true;
   }
 
@@ -439,14 +87,17 @@ bool BooleanXorPropagator::Propagate() {
   if (sum == value_) return true;
 
   // Conflict.
-  std::vector<Literal>* conflict = trail_->MutableConflict();
-  conflict->clear();
-  enforcement_propagator_->AddEnforcementReason(enforcement_id_, conflict);
-  for (const Literal& l : literals_) {
-    conflict->push_back(trail_->Assignment().LiteralIsFalse(l) ? l
-                                                               : l.Negated());
+  if (status == EnforcementStatus::IS_ENFORCED) {
+    fill_literal_reason();
+    return enforcement_helper_.ReportConflict(enforcement_id_, literal_reason_,
+                                              /*integer_reason=*/{});
+  } else if (unassigned_index == -1) {
+    fill_literal_reason();
+    return enforcement_helper_.PropagateWhenFalse(
+        enforcement_id_, literal_reason_, /*integer_reason=*/{});
+  } else {
+    return true;
   }
-  return false;
 }
 
 int BooleanXorPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
diff --git a/ortools/sat/cp_constraints.h b/ortools/sat/cp_constraints.h
index 4e8a296366..323152d634 100644
--- a/ortools/sat/cp_constraints.h
+++ b/ortools/sat/cp_constraints.h
@@ -16,142 +16,21 @@
 
 #include <cstdint>
 #include <functional>
-#include <ostream>
-#include <utility>
 #include <vector>
 
-#include "absl/base/attributes.h"
-#include "absl/container/inlined_vector.h"
 #include "absl/log/check.h"
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
-#include "ortools/base/strong_vector.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/sat_base.h"
-#include "ortools/util/strong_integers.h"
 
 namespace operations_research {
 namespace sat {
 
-DEFINE_STRONG_INDEX_TYPE(EnforcementId);
-
-// An enforced constraint can be in one of these 4 states.
-// Note that we rely on the integer encoding to take 2 bits for optimization.
-enum class EnforcementStatus {
-  // One enforcement literal is false.
-  IS_FALSE = 0,
-  // More than two literals are unassigned.
-  CANNOT_PROPAGATE = 1,
-  // All enforcement literals are true but one.
-  CAN_PROPAGATE = 2,
-  // All enforcement literals are true.
-  IS_ENFORCED = 3,
-};
-
-std::ostream& operator<<(std::ostream& os, const EnforcementStatus& e);
-
-// This is meant as an helper to deal with enforcement for any constraint.
-class EnforcementPropagator : public SatPropagator {
- public:
-  explicit EnforcementPropagator(Model* model);
-
-  // SatPropagator interface.
-  bool Propagate(Trail* trail) final;
-  void Untrail(const Trail& trail, int trail_index) final;
-
-  // Adds a new constraint to the class and register a callback that will
-  // be called on status change. Note that we also call the callback with the
-  // initial status if different from CANNOT_PROPAGATE when added.
-  //
-  // It is better to not call this for empty enforcement list, but you can. A
-  // negative id means the level zero status will never change, and only the
-  // first call to callback() should be necessary, we don't save it.
-  EnforcementId Register(
-      absl::Span<const Literal> enforcement,
-      std::function<void(EnforcementId, EnforcementStatus)> callback = nullptr);
-
-  // Calls `Register` with a callback calling
-  // `watcher->CallOnNextPropagate(literal_watcher_id)` if a propagation might
-  // be possible.
-  EnforcementId Register(absl::Span<const Literal> enforcement_literals,
-                         GenericLiteralWatcher* watcher,
-                         int literal_watcher_id);
-
-  // Add the enforcement reason to the given vector.
-  void AddEnforcementReason(EnforcementId id,
-                            std::vector<Literal>* reason) const;
-
-  // Try to propagate when the enforced constraint is not satisfiable.
-  // This is currently in O(enforcement_size).
-  ABSL_MUST_USE_RESULT bool PropagateWhenFalse(
-      EnforcementId id, absl::Span<const Literal> literal_reason,
-      absl::Span<const IntegerLiteral> integer_reason);
-
-  ABSL_MUST_USE_RESULT bool SafeEnqueue(
-      EnforcementId id, IntegerLiteral i_lit,
-      absl::Span<const IntegerLiteral> integer_reason);
-
-  bool ReportConflict(EnforcementId id,
-                      absl::Span<const IntegerLiteral> integer_reason);
-
-  EnforcementStatus Status(EnforcementId id) const {
-    if (id < 0) return EnforcementStatus::IS_ENFORCED;
-    return statuses_[id];
-  }
-
-  // Recompute the status from the current assignment.
-  // This should only used in DCHECK().
-  EnforcementStatus DebugStatus(EnforcementId id);
-
-  // Returns the enforcement literals of the given id.
-  absl::Span<const Literal> GetEnforcementLiterals(EnforcementId id) const {
-    if (id < 0) return {};
-    return GetSpan(id);
-  }
-
- private:
-  absl::Span<Literal> GetSpan(EnforcementId id);
-  absl::Span<const Literal> GetSpan(EnforcementId id) const;
-  void ChangeStatus(EnforcementId id, EnforcementStatus new_status);
-
-  // Returns kNoLiteralIndex if nothing need to change or a new literal to
-  // watch. This also calls the registered callback.
-  LiteralIndex ProcessIdOnTrue(Literal watched, EnforcementId id);
-
-  // External classes.
-  const Trail& trail_;
-  const VariablesAssignment& assignment_;
-  IntegerTrail* integer_trail_;
-  RevIntRepository* rev_int_repository_;
-
-  // All enforcement will be copied there, and we will create Span out of this.
-  // Note that we don't store the span so that we are not invalidated on buffer_
-  // resizing.
-  util_intops::StrongVector<EnforcementId, int> starts_;
-  std::vector<Literal> buffer_;
-
-  util_intops::StrongVector<EnforcementId, EnforcementStatus> statuses_;
-  util_intops::StrongVector<
-      EnforcementId, std::function<void(EnforcementId, EnforcementStatus)>>
-      callbacks_;
-
-  // Used to restore status and call callback on untrail.
-  std::vector<std::pair<EnforcementId, EnforcementStatus>> untrail_stack_;
-  int rev_stack_size_ = 0;
-  int64_t rev_stamp_ = 0;
-
-  // We use a two watcher scheme.
-  util_intops::StrongVector<LiteralIndex, absl::InlinedVector<EnforcementId, 6>>
-      watcher_;
-
-  std::vector<Literal> temp_literals_;
-  std::vector<Literal> temp_reason_;
-
-  std::vector<EnforcementId> ids_to_fix_until_next_root_level_;
-};
-
 // Propagate the fact that a XOR of literals is equal to the given value.
 // The complexity is in O(n).
 //
@@ -175,9 +54,9 @@ class BooleanXorPropagator : public PropagatorInterface {
   const std::vector<Literal> literals_;
   const bool value_;
   std::vector<Literal> literal_reason_;
-  Trail* trail_;
-  IntegerTrail* integer_trail_;
-  EnforcementPropagator* enforcement_propagator_;
+  const Trail& trail_;
+  const IntegerTrail& integer_trail_;
+  EnforcementHelper& enforcement_helper_;
   EnforcementId enforcement_id_;
 };
 
diff --git a/ortools/sat/cp_constraints_test.cc b/ortools/sat/cp_constraints_test.cc
index 88efa3d167..667243b4ed 100644
--- a/ortools/sat/cp_constraints_test.cc
+++ b/ortools/sat/cp_constraints_test.cc
@@ -32,118 +32,6 @@ namespace operations_research {
 namespace sat {
 namespace {
 
-TEST(EnforcementPropagatorTest, BasicTest) {
-  Model model;
-  auto* sat_solver = model.GetOrCreate<SatSolver>();
-  auto* trail = model.GetOrCreate<Trail>();
-  auto* propag = model.GetOrCreate<EnforcementPropagator>();
-  sat_solver->SetNumVariables(10);
-
-  const EnforcementId id1 = propag->Register(Literals({+1}));
-  const EnforcementId id2 = propag->Register(Literals({+1, +2}));
-  const EnforcementId id3 = propag->Register(Literals({-2}));
-
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::CAN_PROPAGATE);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CANNOT_PROPAGATE);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE);
-
-  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+1));
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CAN_PROPAGATE);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE);
-
-  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+2));
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::IS_FALSE);
-
-  CHECK(sat_solver->ResetToLevelZero());
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::CAN_PROPAGATE);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CANNOT_PROPAGATE);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE);
-}
-
-TEST(EnforcementPropagatorTest, UntrailWork) {
-  Model model;
-  auto* sat_solver = model.GetOrCreate<SatSolver>();
-  auto* trail = model.GetOrCreate<Trail>();
-  auto* propag = model.GetOrCreate<EnforcementPropagator>();
-  sat_solver->SetNumVariables(10);
-
-  const EnforcementId id1 = propag->Register(Literals({+1}));
-  const EnforcementId id2 = propag->Register(Literals({+2}));
-  const EnforcementId id3 = propag->Register(Literals({+3}));
-
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::CAN_PROPAGATE);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CAN_PROPAGATE);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE);
-
-  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+1));
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CAN_PROPAGATE);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE);
-
-  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+2));
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE);
-  const int level = sat_solver->CurrentDecisionLevel();
-
-  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+3));
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::IS_ENFORCED);
-
-  sat_solver->Backtrack(level);
-  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
-  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE);
-}
-
-TEST(EnforcementPropagatorTest, AddingAtPositiveLevelTrue) {
-  Model model;
-  auto* sat_solver = model.GetOrCreate<SatSolver>();
-  auto* trail = model.GetOrCreate<Trail>();
-  auto* propag = model.GetOrCreate<EnforcementPropagator>();
-  sat_solver->SetNumVariables(10);
-
-  EXPECT_TRUE(propag->Propagate(trail));
-  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+1));
-  EXPECT_TRUE(propag->Propagate(trail));
-
-  const EnforcementId id = propag->Register(std::vector<Literal>{+1});
-  EXPECT_EQ(propag->Status(id), EnforcementStatus::IS_ENFORCED);
-
-  sat_solver->Backtrack(0);
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id), EnforcementStatus::CAN_PROPAGATE);
-}
-
-TEST(EnforcementPropagatorTest, AddingAtPositiveLevelFalse) {
-  Model model;
-  auto* sat_solver = model.GetOrCreate<SatSolver>();
-  auto* trail = model.GetOrCreate<Trail>();
-  auto* propag = model.GetOrCreate<EnforcementPropagator>();
-  sat_solver->SetNumVariables(10);
-
-  EXPECT_TRUE(propag->Propagate(trail));
-  sat_solver->EnqueueDecisionIfNotConflicting(Literal(-1));
-  EXPECT_TRUE(propag->Propagate(trail));
-
-  const EnforcementId id = propag->Register(std::vector<Literal>{+1});
-  EXPECT_EQ(propag->Status(id), EnforcementStatus::IS_FALSE);
-
-  sat_solver->Backtrack(0);
-  EXPECT_TRUE(propag->Propagate(trail));
-  EXPECT_EQ(propag->Status(id), EnforcementStatus::CAN_PROPAGATE);
-}
-
 TEST(LiteralXorIsTest, OneVariable) {
   Model model;
   const BooleanVariable a = model.Add(NewBooleanVariable());
diff --git a/ortools/sat/cp_model.proto b/ortools/sat/cp_model.proto
index 92e0d2fa63..a286defd6b 100644
--- a/ortools/sat/cp_model.proto
+++ b/ortools/sat/cp_model.proto
@@ -85,7 +85,7 @@ message LinearArgumentProto {
   repeated LinearExpressionProto exprs = 2;
 }
 
-// All affine expressions must take different values.
+// All expressions must take different values.
 message AllDifferentConstraintProto {
   repeated LinearExpressionProto exprs = 1;
 }
@@ -102,13 +102,12 @@ message LinearConstraintProto {
   repeated int64 domain = 3;
 }
 
-// The constraint target = vars[index].
+// The constraint linear_target = exprs[linear_index].
 // This enforces that index takes one of the value in [0, vars_size()).
 message ElementConstraintProto {
   int32 index = 1;          // Legacy field.
   int32 target = 2;         // Legacy field.
   repeated int32 vars = 3;  // Legacy field.
-  // All expressions below must be affine function with at most one variable.
   LinearExpressionProto linear_index = 4;
   LinearExpressionProto linear_target = 5;
   repeated LinearExpressionProto exprs = 6;
@@ -121,10 +120,6 @@ message ElementConstraintProto {
 // components, and it is up to the client to add in the model:
 // - enforcement => start + size == end.
 // - enforcement => size >= 0  // Only needed if size is not already >= 0.
-//
-// IMPORTANT: For now, we just support affine relation. We could easily
-// create an intermediate variable to support full linear expression, but this
-// isn't done currently.
 message IntervalConstraintProto {
   LinearExpressionProto start = 4;
   LinearExpressionProto end = 5;
@@ -188,9 +183,8 @@ message CumulativeConstraintProto {
 message ReservoirConstraintProto {
   int64 min_level = 1;
   int64 max_level = 2;
-  repeated LinearExpressionProto time_exprs = 3;  // affine expressions.
-  // Currently, we only support constant level changes.
-  repeated LinearExpressionProto level_changes = 6;  // affine expressions.
+  repeated LinearExpressionProto time_exprs = 3;
+  repeated LinearExpressionProto level_changes = 6;
   repeated int32 active_literals = 5;
   reserved 4;
 }
@@ -242,7 +236,6 @@ message RoutesConstraintProto {
   // A set of linear expressions associated with the nodes.
   message NodeExpressions {
     // The i-th element is the linear expression associated with the i-th node.
-    // All expressions must be affine expressions (a * var + b).
     repeated LinearExpressionProto exprs = 1;
   }
 
@@ -261,7 +254,6 @@ message RoutesConstraintProto {
 // The values of the n-tuple formed by the given expression can only be one of
 // the listed n-tuples in values. The n-tuples are encoded in a flattened way:
 //     [tuple0_v0, tuple0_v1, ..., tuple0_v{n-1}, tuple1_v0, ...].
-// Expressions must be affine (a * var + b).
 // Corner cases:
 //  - If all `vars`, `values` and `exprs` are empty, the constraint is trivially
 //    true, irrespective of the value of `negated`.
@@ -304,9 +296,8 @@ message AutomatonConstraintProto {
 
   // Legacy field.
   repeated int32 vars = 7;
-  // The sequence of affine expressions (a * var + b). The automaton is ran for
-  // exprs_size() "steps" and the value of exprs[i] corresponds to the
-  // transition label at step i.
+  // The sequence of expressions. The automaton is ran for exprs_size() "steps"
+  // and the value of exprs[i] corresponds to the transition label at step i.
   repeated LinearExpressionProto exprs = 8;
 }
 
@@ -330,11 +321,10 @@ message ConstraintProto {
   // (controlled by a literal l) and its negation (controlled by the negation of
   // l).
   //
-  // Important: as of July 2025, only a few constraint support enforcement:
-  // - bool_or, bool_and, at_most_one, exactly_one, bool_xor, int_div, int_mod,
-  // int_prod, linear, table: fully supported.
-  // - interval: only support a single enforcement literal.
-  // - other: no support (but can be added on a per-demand basis).
+  // Important: as of September 2025, some constraints might be less efficient
+  // with enforcement than without: circuit, routes, no_overlap, no_overlap_2d,
+  // and cumulative. If performance is not great, consider using a model without
+  // these constraints enforced.
   repeated int32 enforcement_literal = 2;
 
   // The actual constraint with its arguments.
diff --git a/ortools/sat/cp_model_checker.cc b/ortools/sat/cp_model_checker.cc
index 88ccd6485f..8ad69b431a 100644
--- a/ortools/sat/cp_model_checker.cc
+++ b/ortools/sat/cp_model_checker.cc
@@ -29,7 +29,6 @@
 #include "absl/container/flat_hash_set.h"
 #include "absl/flags/flag.h"
 #include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
@@ -285,17 +284,8 @@ std::string ValidateLinearExpression(const CpModelProto& model,
   return "";
 }
 
-std::string ValidateAffineExpression(const CpModelProto& model,
-                                     const LinearExpressionProto& expr) {
-  if (expr.vars_size() > 1) {
-    return absl::StrCat("expression must be affine: ",
-                        ProtobufShortDebugString(expr));
-  }
-  return ValidateLinearExpression(model, expr);
-}
-
-std::string ValidateConstantAffineExpression(
-    const CpModelProto& model, const LinearExpressionProto& expr) {
+std::string ValidateConstantExpression(const CpModelProto& model,
+                                       const LinearExpressionProto& expr) {
   if (!expr.vars().empty()) {
     return absl::StrCat("expression must be constant: ",
                         ProtobufShortDebugString(expr));
@@ -338,9 +328,9 @@ std::string ValidateIntModConstraint(const CpModelProto& model,
                         ProtobufShortDebugString(ct));
   }
 
-  RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, ct.int_mod().exprs(0)));
-  RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, ct.int_mod().exprs(1)));
-  RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, ct.int_mod().target()));
+  RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, ct.int_mod().exprs(0)));
+  RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, ct.int_mod().exprs(1)));
+  RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, ct.int_mod().target()));
 
   const LinearExpressionProto mod_expr = ct.int_mod().exprs(1);
   if (MinOfExpression(model, mod_expr) <= 0) {
@@ -360,9 +350,9 @@ std::string ValidateIntProdConstraint(const CpModelProto& model,
   }
 
   for (const LinearExpressionProto& expr : ct.int_prod().exprs()) {
-    RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, expr));
+    RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
   }
-  RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, ct.int_prod().target()));
+  RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, ct.int_prod().target()));
 
   // Detect potential overflow.
   Domain product_domain(1);
@@ -406,9 +396,9 @@ std::string ValidateIntDivConstraint(const CpModelProto& model,
                         ProtobufShortDebugString(ct));
   }
 
-  RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, ct.int_div().exprs(0)));
-  RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, ct.int_div().exprs(1)));
-  RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, ct.int_div().target()));
+  RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, ct.int_div().exprs(0)));
+  RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, ct.int_div().exprs(1)));
+  RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, ct.int_div().target()));
 
   const LinearExpressionProto& denom = ct.int_div().exprs(1);
   const int64_t offset = denom.offset();
@@ -498,11 +488,11 @@ std::string ValidateElementConstraint(const CpModelProto& model,
 
   if (in_linear_format) {
     RETURN_IF_NOT_EMPTY(
-        ValidateAffineExpression(model, element.linear_index()));
+        ValidateLinearExpression(model, element.linear_index()));
     RETURN_IF_NOT_EMPTY(
-        ValidateAffineExpression(model, element.linear_target()));
+        ValidateLinearExpression(model, element.linear_target()));
     for (const LinearExpressionProto& expr : element.exprs()) {
-      RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, expr));
+      RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
       LinearExpressionProto overflow_detection = ct.element().linear_target();
       AppendToOverflowValidator(expr, &overflow_detection, -1);
       const int64_t offset = CapSub(overflow_detection.offset(), expr.offset());
@@ -549,7 +539,7 @@ std::string ValidateTableConstraint(const CpModelProto& model,
     }
   }
   for (const LinearExpressionProto& expr : arg.exprs()) {
-    RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, expr));
+    RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
   }
   return "";
 }
@@ -576,7 +566,7 @@ std::string ValidateAutomatonConstraint(const CpModelProto& model,
     }
   }
   for (const LinearExpressionProto& expr : automaton.exprs()) {
-    RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, expr));
+    RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
   }
   absl::flat_hash_map<std::pair<int64_t, int64_t>, int64_t> tail_label_to_head;
   for (int i = 0; i < num_transistions; ++i) {
@@ -670,7 +660,7 @@ std::string ValidateRoutesConstraint(const CpModelProto& model,
                               ProtobufShortDebugString(ct));
         }
       }
-      RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, expr));
+      RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
     }
   }
 
@@ -679,12 +669,6 @@ std::string ValidateRoutesConstraint(const CpModelProto& model,
 
 std::string ValidateIntervalConstraint(const CpModelProto& model,
                                        const ConstraintProto& ct) {
-  if (ct.enforcement_literal().size() > 1) {
-    return absl::StrCat(
-        "Interval with more than one enforcement literals are currently not "
-        "supported: ",
-        ProtobufShortDebugString(ct));
-  }
   const IntervalConstraintProto& arg = ct.interval();
 
   if (!arg.has_start()) {
@@ -809,9 +793,6 @@ std::string ValidateNoOverlap2DConstraint(const CpModelProto& model,
 
 std::string ValidateReservoirConstraint(const CpModelProto& model,
                                         const ConstraintProto& ct) {
-  if (ct.enforcement_literal_size() > 0) {
-    return "Reservoir does not support enforcement literals.";
-  }
   if (ct.reservoir().time_exprs().size() !=
       ct.reservoir().level_changes().size()) {
     return absl::StrCat(
@@ -819,7 +800,7 @@ std::string ValidateReservoirConstraint(const CpModelProto& model,
         ProtobufShortDebugString(ct));
   }
   for (const LinearExpressionProto& expr : ct.reservoir().time_exprs()) {
-    RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, expr));
+    RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
     // We want to be able to safely put time_exprs[i]-time_exprs[j] in a linear.
     if (MinOfExpression(model, expr) <=
             -std::numeric_limits<int64_t>::max() / 4 ||
@@ -831,7 +812,7 @@ std::string ValidateReservoirConstraint(const CpModelProto& model,
     }
   }
   for (const LinearExpressionProto& expr : ct.reservoir().level_changes()) {
-    RETURN_IF_NOT_EMPTY(ValidateConstantAffineExpression(model, expr));
+    RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
   }
   if (ct.reservoir().min_level() > 0) {
     return absl::StrCat(
@@ -1002,13 +983,17 @@ std::string ValidateSearchStrategies(const CpModelProto& model) {
       }
     }
     for (const LinearExpressionProto& expr : strategy.exprs()) {
+      if (expr.vars_size() > 1) {
+        return absl::StrCat("expression must be affine in strategy: ",
+                            ProtobufShortDebugString(strategy));
+      }
       for (const int var : expr.vars()) {
         if (!VariableReferenceIsValid(model, var)) {
           return absl::StrCat("Invalid variable reference in strategy: ",
                               ProtobufShortDebugString(strategy));
         }
       }
-      if (!ValidateAffineExpression(model, expr).empty()) {
+      if (!ValidateLinearExpression(model, expr).empty()) {
         return absl::StrCat("Invalid affine expr in strategy: ",
                             ProtobufShortDebugString(strategy));
       }
@@ -1132,30 +1117,16 @@ std::string ValidateCpModel(const CpModelProto& model, bool after_presolve) {
   for (int c = 0; c < model.constraints_size(); ++c) {
     RETURN_IF_NOT_EMPTY(ValidateVariablesUsedInConstraint(model, c));
 
-    // By default, a constraint does not support enforcement literals except if
-    // explicitly stated by setting this to true below.
-    bool support_enforcement = false;
-
     // Other non-generic validations.
     const ConstraintProto& ct = model.constraints(c);
     switch (ct.constraint_case()) {
       case ConstraintProto::ConstraintCase::kBoolOr:
-        support_enforcement = true;
-        break;
       case ConstraintProto::ConstraintCase::kBoolAnd:
-        support_enforcement = true;
-        break;
       case ConstraintProto::ConstraintCase::kAtMostOne:
-        support_enforcement = true;
-        break;
       case ConstraintProto::ConstraintCase::kExactlyOne:
-        support_enforcement = true;
-        break;
       case ConstraintProto::ConstraintCase::kBoolXor:
-        support_enforcement = true;
         break;
       case ConstraintProto::ConstraintCase::kLinear:
-        support_enforcement = true;
         RETURN_IF_NOT_EMPTY(ValidateLinearConstraint(model, ct));
         break;
       case ConstraintProto::ConstraintCase::kLinMax: {
@@ -1167,15 +1138,12 @@ std::string ValidateCpModel(const CpModelProto& model, bool after_presolve) {
         break;
       }
       case ConstraintProto::ConstraintCase::kIntProd:
-        support_enforcement = true;
         RETURN_IF_NOT_EMPTY(ValidateIntProdConstraint(model, ct));
         break;
       case ConstraintProto::ConstraintCase::kIntDiv:
-        support_enforcement = true;
         RETURN_IF_NOT_EMPTY(ValidateIntDivConstraint(model, ct));
         break;
       case ConstraintProto::ConstraintCase::kIntMod:
-        support_enforcement = true;
         RETURN_IF_NOT_EMPTY(ValidateIntModConstraint(model, ct));
         break;
       case ConstraintProto::ConstraintCase::kInverse:
@@ -1186,7 +1154,7 @@ std::string ValidateCpModel(const CpModelProto& model, bool after_presolve) {
         break;
       case ConstraintProto::ConstraintCase::kAllDiff:
         for (const LinearExpressionProto& expr : ct.all_diff().exprs()) {
-          RETURN_IF_NOT_EMPTY(ValidateAffineExpression(model, expr));
+          RETURN_IF_NOT_EMPTY(ValidateLinearExpression(model, expr));
         }
         break;
       case ConstraintProto::ConstraintCase::kElement:
@@ -1194,7 +1162,6 @@ std::string ValidateCpModel(const CpModelProto& model, bool after_presolve) {
         break;
       case ConstraintProto::ConstraintCase::kTable:
         RETURN_IF_NOT_EMPTY(ValidateTableConstraint(model, ct));
-        support_enforcement = true;
         break;
       case ConstraintProto::ConstraintCase::kAutomaton:
         RETURN_IF_NOT_EMPTY(ValidateAutomatonConstraint(model, ct));
@@ -1208,7 +1175,6 @@ std::string ValidateCpModel(const CpModelProto& model, bool after_presolve) {
         break;
       case ConstraintProto::ConstraintCase::kInterval:
         RETURN_IF_NOT_EMPTY(ValidateIntervalConstraint(model, ct));
-        support_enforcement = true;
         break;
       case ConstraintProto::ConstraintCase::kCumulative:
         constraints_using_intervals.push_back(c);
@@ -1227,21 +1193,6 @@ std::string ValidateCpModel(const CpModelProto& model, bool after_presolve) {
       default:
         break;
     }
-
-    // Because some client set fixed enforcement literal which are supported
-    // in the presolve for all constraints, we just check that there is no
-    // non-fixed enforcement.
-    if (!support_enforcement && !ct.enforcement_literal().empty()) {
-      for (const int ref : ct.enforcement_literal()) {
-        const int var = PositiveRef(ref);
-        const Domain domain = ReadDomainFromProto(model.variables(var));
-        if (domain.Size() != 1) {
-          return absl::StrCat(
-              "Enforcement literal not supported in constraint: ",
-              ProtobufShortDebugString(ct));
-        }
-      }
-    }
   }
 
   // Extra validation for constraint using intervals.
diff --git a/ortools/sat/cp_model_checker_test.cc b/ortools/sat/cp_model_checker_test.cc
index 23f9678959..8d7d3439e3 100644
--- a/ortools/sat/cp_model_checker_test.cc
+++ b/ortools/sat/cp_model_checker_test.cc
@@ -726,33 +726,6 @@ TEST(ValidateCpModelTest, InvalidNodeExpressionsCount) {
   EXPECT_THAT(ValidateCpModel(model), HasSubstr("must be of size num_nodes:2"));
 }
 
-TEST(ValidateCpModelTest, NonAffineExpressionInRoutesConstraint) {
-  const CpModelProto model = ParseTestProto(R"pb(
-    variables { domain: [ 0, 1 ] }
-    variables { domain: [ 0, 1 ] }
-    variables { domain: [ 0, 10 ] }
-    variables { domain: [ 0, 10 ] }
-    constraints {
-      routes {
-        tails: [ 0, 1 ]
-        heads: [ 1, 0 ]
-        literals: [ 0, 1 ]
-        dimensions {
-          exprs {
-            vars: [ 2, 3 ]
-            coeffs: [ 1, 2 ]
-          }
-          exprs {
-            vars: [ 3 ]
-            coeffs: [ 1 ]
-          }
-        }
-      }
-    }
-  )pb");
-  EXPECT_THAT(ValidateCpModel(model), HasSubstr("expression must be affine"));
-}
-
 TEST(ValidateCpModelTest, InvalidNodeExpressionInRoutesConstraint) {
   const CpModelProto model = ParseTestProto(R"pb(
     variables { domain: [ 0, 1 ] }
diff --git a/ortools/sat/cp_model_copy.cc b/ortools/sat/cp_model_copy.cc
index 590410ffcd..ad935b8e31 100644
--- a/ortools/sat/cp_model_copy.cc
+++ b/ortools/sat/cp_model_copy.cc
@@ -15,10 +15,13 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <cstdlib>
 #include <functional>
 #include <limits>
+#include <numeric>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/container/flat_hash_set.h"
@@ -81,6 +84,7 @@ bool ModelCopy::ImportAndSimplifyConstraints(
   std::vector<int> constraints_using_intervals;
 
   interval_mapping_.assign(in_model.constraints().size(), -1);
+  boolean_product_encoding_.clear();
 
   starting_constraint_index_ = context_->working_model->constraints_size();
   for (int c = 0; c < in_model.constraints_size(); ++c) {
@@ -201,6 +205,7 @@ bool ModelCopy::ImportAndSimplifyConstraints(
   DCHECK(first_copy || constraints_using_intervals.empty());
   for (const int c : constraints_using_intervals) {
     const ConstraintProto& ct = in_model.constraints(c);
+    if (!PrepareEnforcementCopyWithDup(ct)) continue;
     switch (ct.constraint_case()) {
       case ConstraintProto::kNoOverlap:
         CopyAndMapNoOverlap(ct);
@@ -216,6 +221,9 @@ bool ModelCopy::ImportAndSimplifyConstraints(
     }
   }
 
+  if (first_copy) {
+    ExpandNonAffineExpressions();
+  }
   return true;
 }
 
@@ -544,6 +552,8 @@ bool ModelCopy::CopyElement(const ConstraintProto& ct) {
   if (ct.element().vars().empty() && !ct.element().exprs().empty()) {
     // New format, just copy.
     *new_ct = ct;
+    new_ct->mutable_enforcement_literal()->Clear();
+    FinishEnforcementCopy(new_ct);
     return true;
   }
 
@@ -559,6 +569,7 @@ bool ModelCopy::CopyElement(const ConstraintProto& ct) {
     }
   };
 
+  FinishEnforcementCopy(new_ct);
   fill_expr(ct.element().index(),
             new_ct->mutable_element()->mutable_linear_index());
   fill_expr(ct.element().target(),
@@ -571,8 +582,20 @@ bool ModelCopy::CopyElement(const ConstraintProto& ct) {
 
 bool ModelCopy::CopyAutomaton(const ConstraintProto& ct) {
   ConstraintProto* new_ct = context_->working_model->add_constraints();
-  *new_ct = ct;
-  if (new_ct->automaton().vars().empty()) return true;
+  new_ct->mutable_automaton()->set_starting_state(
+      ct.automaton().starting_state());
+  *new_ct->mutable_automaton()->mutable_final_states() =
+      ct.automaton().final_states();
+  *new_ct->mutable_automaton()->mutable_transition_tail() =
+      ct.automaton().transition_tail();
+  *new_ct->mutable_automaton()->mutable_transition_head() =
+      ct.automaton().transition_head();
+  *new_ct->mutable_automaton()->mutable_transition_label() =
+      ct.automaton().transition_label();
+  for (const LinearExpressionProto& expr : ct.automaton().exprs()) {
+    CopyLinearExpression(expr, new_ct->mutable_automaton()->add_exprs());
+  }
+  FinishEnforcementCopy(new_ct);
 
   auto fill_expr = [this](int var, LinearExpressionProto* expr) mutable {
     if (context_->IsFixed(var)) {
@@ -589,7 +612,6 @@ bool ModelCopy::CopyAutomaton(const ConstraintProto& ct) {
   for (const int var : ct.automaton().vars()) {
     fill_expr(var, new_ct->mutable_automaton()->add_exprs());
   }
-  new_ct->mutable_automaton()->clear_vars();
 
   return true;
 }
@@ -599,6 +621,8 @@ bool ModelCopy::CopyTable(const ConstraintProto& ct) {
   if (ct.table().vars().empty() && !ct.table().exprs().empty()) {
     // New format, just copy.
     *new_ct = ct;
+    new_ct->mutable_enforcement_literal()->Clear();
+    FinishEnforcementCopy(new_ct);
     return true;
   }
 
@@ -614,6 +638,7 @@ bool ModelCopy::CopyTable(const ConstraintProto& ct) {
     }
   };
 
+  FinishEnforcementCopy(new_ct);
   for (const int var : ct.table().vars()) {
     fill_expr(var, new_ct->mutable_table()->add_exprs());
   }
@@ -630,6 +655,7 @@ bool ModelCopy::CopyAllDiff(const ConstraintProto& ct) {
   for (const LinearExpressionProto& expr : ct.all_diff().exprs()) {
     CopyLinearExpression(expr, new_ct->mutable_all_diff()->add_exprs());
   }
+  FinishEnforcementCopy(new_ct);
   return true;
 }
 
@@ -673,28 +699,10 @@ bool ModelCopy::CopyLinMax(const ConstraintProto& ct) {
   if (new_ct == nullptr) return false;  // No expr == unsat.
   CopyLinearExpression(ct.lin_max().target(),
                        new_ct->mutable_lin_max()->mutable_target());
+  FinishEnforcementCopy(new_ct);
   return true;
 }
 
-namespace {
-void LiteralsToLinear(absl::Span<const int> literals, int64_t lb, int64_t ub,
-                      LinearConstraintProto* linear) {
-  for (const int lit : literals) {
-    if (RefIsPositive(lit)) {
-      linear->add_vars(lit);
-      linear->add_coeffs(1);
-    } else {
-      linear->add_vars(NegatedRef(lit));
-      linear->add_coeffs(-1);
-      lb -= 1;
-      ub -= 1;
-    }
-  }
-  linear->add_domain(lb);
-  linear->add_domain(ub);
-}
-}  // namespace
-
 bool ModelCopy::CopyAtMostOne(const ConstraintProto& ct) {
   if (!ct.enforcement_literal().empty()) {
     ConstraintProto new_ct;
@@ -757,7 +765,11 @@ bool ModelCopy::CopyInterval(const ConstraintProto& ct, int c,
   if (!ignore_names) {
     new_ct->set_name(ct.name());
   }
-  *new_ct->mutable_enforcement_literal() = ct.enforcement_literal();
+  if (temp_enforcement_literals_.size() > 1) {
+    temp_enforcement_literals_ = {
+        GetOrCreateVariableForConjunction(&temp_enforcement_literals_)};
+  }
+  FinishEnforcementCopy(new_ct);
   CopyLinearExpression(ct.interval().start(),
                        new_ct->mutable_interval()->mutable_start(),
                        ct.enforcement_literal());
@@ -854,56 +866,92 @@ bool ModelCopy::AddLinearConstraintForInterval(const ConstraintProto& ct) {
   return true;
 }
 
+int ModelCopy::GetOrCreateVariableForConjunction(std::vector<int>* literals) {
+  std::sort(literals->begin(), literals->end());
+  auto it = boolean_product_encoding_.find(*literals);
+  if (it != boolean_product_encoding_.end()) return it->second;
+  const int new_var = context_->NewBoolVarWithConjunction(*literals);
+  boolean_product_encoding_[*literals] = new_var;
+  // Add the constraint 'literals => new_var'
+  auto* ct1 = context_->working_model->add_constraints();
+  ct1->mutable_bool_or()->mutable_literals()->Reserve(literals->size() + 1);
+  for (const int literal : *literals) {
+    ct1->mutable_bool_or()->add_literals(NegatedRef(literal));
+  }
+  ct1->mutable_bool_or()->add_literals(new_var);
+  // Add the constraint 'new_var => literals'
+  auto* ct2 = context_->working_model->add_constraints();
+  ct2->add_enforcement_literal(new_var);
+  *ct2->mutable_bool_and()->mutable_literals() = {literals->begin(),
+                                                  literals->end()};
+  return new_var;
+}
+
 void ModelCopy::CopyAndMapNoOverlap(const ConstraintProto& ct) {
-  // Note that we don't copy names or enforcement_literal (not supported) here.
-  auto* new_ct =
-      context_->working_model->add_constraints()->mutable_no_overlap();
-  new_ct->mutable_intervals()->Reserve(ct.no_overlap().intervals().size());
+  // Note that we don't copy names here.
+  auto* new_ct = context_->working_model->add_constraints();
+  FinishEnforcementCopy(new_ct);
+  NoOverlapConstraintProto* no_overlap = new_ct->mutable_no_overlap();
+  no_overlap->mutable_intervals()->Reserve(ct.no_overlap().intervals().size());
   for (const int index : ct.no_overlap().intervals()) {
     const int new_index = interval_mapping_[index];
     if (new_index != -1) {
-      new_ct->add_intervals(new_index);
+      no_overlap->add_intervals(new_index);
     }
   }
 }
 
 void ModelCopy::CopyAndMapNoOverlap2D(const ConstraintProto& ct) {
-  // Note that we don't copy names or enforcement_literal (not supported) here.
-  auto* new_ct =
-      context_->working_model->add_constraints()->mutable_no_overlap_2d();
-
+  // Note that we don't copy names here.
+  auto* new_ct = context_->working_model->add_constraints();
+  FinishEnforcementCopy(new_ct);
+  NoOverlap2DConstraintProto* no_overlap_2d = new_ct->mutable_no_overlap_2d();
   const int num_intervals = ct.no_overlap_2d().x_intervals().size();
-  new_ct->mutable_x_intervals()->Reserve(num_intervals);
-  new_ct->mutable_y_intervals()->Reserve(num_intervals);
+  no_overlap_2d->mutable_x_intervals()->Reserve(num_intervals);
+  no_overlap_2d->mutable_y_intervals()->Reserve(num_intervals);
   for (int i = 0; i < num_intervals; ++i) {
     const int new_x = interval_mapping_[ct.no_overlap_2d().x_intervals(i)];
     if (new_x == -1) continue;
     const int new_y = interval_mapping_[ct.no_overlap_2d().y_intervals(i)];
     if (new_y == -1) continue;
-    new_ct->add_x_intervals(new_x);
-    new_ct->add_y_intervals(new_y);
+    no_overlap_2d->add_x_intervals(new_x);
+    no_overlap_2d->add_y_intervals(new_y);
   }
 }
 
 bool ModelCopy::CopyAndMapCumulative(const ConstraintProto& ct) {
   if (ct.cumulative().intervals().empty() &&
       context_->IsFixed(ct.cumulative().capacity())) {
-    // Trivial constraint, either obviously SAT or UNSAT.
-    return context_->FixedValue(ct.cumulative().capacity()) >= 0;
+    // Trivial constraint, either obviously SAT or UNSAT if enforced.
+    const int64_t capacity = context_->FixedValue(ct.cumulative().capacity());
+    if (temp_enforcement_literals_.empty()) {
+      return capacity >= 0;
+    }
+    if (capacity < 0) {
+      // At least one enforcement literal must be false.
+      auto* new_ct = context_->working_model->add_constraints();
+      for (const int literal : temp_enforcement_literals_) {
+        new_ct->mutable_bool_or()->add_literals(NegatedRef(literal));
+      }
+    }
+    return true;
   }
-  // Note that we don't copy names or enforcement_literal (not supported) here.
-  auto* new_ct =
-      context_->working_model->add_constraints()->mutable_cumulative();
-  CopyLinearExpression(ct.cumulative().capacity(), new_ct->mutable_capacity());
+  // Note that we don't copy names here.
+  auto* new_ct = context_->working_model->add_constraints();
+  FinishEnforcementCopy(new_ct);
+  CumulativeConstraintProto* cumulative = new_ct->mutable_cumulative();
+  CopyLinearExpression(ct.cumulative().capacity(),
+                       cumulative->mutable_capacity());
 
   const int num_intervals = ct.cumulative().intervals().size();
-  new_ct->mutable_intervals()->Reserve(num_intervals);
-  new_ct->mutable_demands()->Reserve(num_intervals);
+  cumulative->mutable_intervals()->Reserve(num_intervals);
+  cumulative->mutable_demands()->Reserve(num_intervals);
   for (int i = 0; i < num_intervals; ++i) {
     const int new_index = interval_mapping_[ct.cumulative().intervals(i)];
     if (new_index != -1) {
-      new_ct->add_intervals(new_index);
-      CopyLinearExpression(ct.cumulative().demands(i), new_ct->add_demands());
+      cumulative->add_intervals(new_index);
+      CopyLinearExpression(ct.cumulative().demands(i),
+                           cumulative->add_demands());
     }
   }
 
@@ -937,6 +985,153 @@ bool ModelCopy::CreateUnsatModel(int c, const ConstraintProto& ct) {
   return context_->NotifyThatModelIsUnsat(message);
 }
 
+void ModelCopy::ExpandNonAffineExpressions() {
+  // Make sure all domains are initialized (they are used in
+  // MaybeExpandNonAffineExpression()).
+  context_->InitializeNewDomains();
+
+  non_affine_expression_to_new_var_.clear();
+  for (int c = 0; c < context_->working_model->constraints_size(); ++c) {
+    ConstraintProto* const ct = context_->working_model->mutable_constraints(c);
+    switch (ct->constraint_case()) {
+      case ConstraintProto::kIntDiv:
+        MaybeExpandNonAffineExpressions(ct->mutable_int_div());
+        break;
+      case ConstraintProto::kIntMod:
+        MaybeExpandNonAffineExpressions(ct->mutable_int_mod());
+        break;
+      case ConstraintProto::kIntProd:
+        MaybeExpandNonAffineExpressions(ct->mutable_int_prod());
+        break;
+      case ConstraintProto::kAllDiff:
+        for (LinearExpressionProto& expr :
+             *ct->mutable_all_diff()->mutable_exprs()) {
+          MaybeExpandNonAffineExpression(&expr);
+        }
+        break;
+      case ConstraintProto::kElement:
+        if (!ct->element().exprs().empty()) {
+          MaybeExpandNonAffineExpression(
+              ct->mutable_element()->mutable_linear_index());
+          MaybeExpandNonAffineExpression(
+              ct->mutable_element()->mutable_linear_target());
+          for (LinearExpressionProto& expr :
+               *ct->mutable_element()->mutable_exprs()) {
+            MaybeExpandNonAffineExpression(&expr);
+          }
+        }
+        break;
+      case ConstraintProto::kInterval:
+        MaybeExpandNonAffineExpression(ct->mutable_interval()->mutable_start());
+        MaybeExpandNonAffineExpression(ct->mutable_interval()->mutable_end());
+        MaybeExpandNonAffineExpression(ct->mutable_interval()->mutable_size());
+        break;
+      case ConstraintProto::kReservoir:
+        for (LinearExpressionProto& expr :
+             *ct->mutable_reservoir()->mutable_time_exprs()) {
+          MaybeExpandNonAffineExpression(&expr);
+        }
+        break;
+      case ConstraintProto::kRoutes:
+        for (RoutesConstraintProto::NodeExpressions& node_exprs :
+             *ct->mutable_routes()->mutable_dimensions()) {
+          for (LinearExpressionProto& expr : *node_exprs.mutable_exprs()) {
+            MaybeExpandNonAffineExpression(&expr);
+          }
+        }
+        break;
+      case ConstraintProto::kTable:
+        for (LinearExpressionProto& expr :
+             *ct->mutable_table()->mutable_exprs()) {
+          MaybeExpandNonAffineExpression(&expr);
+        }
+        break;
+      case ConstraintProto::kAutomaton:
+        for (LinearExpressionProto& expr :
+             *ct->mutable_automaton()->mutable_exprs()) {
+          MaybeExpandNonAffineExpression(&expr);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+// Replaces the expression sum a_i * x_i + c with gcd * y + c, where y is a new
+// variable defined with an additional constraint y = sum a_i / gcd * x_i.
+void ModelCopy::MaybeExpandNonAffineExpression(LinearExpressionProto* expr) {
+  int new_size = 0;
+  for (int i = 0; i < expr->vars().size(); ++i) {
+    if (expr->coeffs(i) != 0) {
+      expr->set_vars(new_size, expr->vars(i));
+      expr->set_coeffs(new_size, expr->coeffs(i));
+      ++new_size;
+    }
+  }
+  expr->mutable_vars()->Truncate(new_size);
+  expr->mutable_coeffs()->Truncate(new_size);
+  if (expr->vars_size() < 2) return;
+
+  int64_t gcd = std::abs(expr->coeffs(0));
+  for (int i = 1; i < expr->coeffs().size(); ++i) {
+    gcd = std::gcd(gcd, std::abs(expr->coeffs(i)));
+  }
+  Domain domain(0);
+  std::vector<std::pair<int, int64_t>> definition;
+  for (int i = 0; i < expr->vars().size(); ++i) {
+    const int var = expr->vars(i);
+    const int64_t coeff = expr->coeffs(i) / gcd;
+    domain =
+        domain.AdditionWith(context_->DomainOf(var).MultiplicationBy(coeff));
+    definition.push_back({var, coeff});
+  }
+  std::sort(definition.begin(), definition.end());
+  int new_var;
+  auto it = non_affine_expression_to_new_var_.find(definition);
+  if (it != non_affine_expression_to_new_var_.end()) {
+    new_var = it->second;
+  } else {
+    std::vector<std::pair<int, int64_t>> negated_definition;
+    negated_definition.reserve(definition.size());
+    for (const auto [var, coeff] : definition) {
+      negated_definition.push_back({var, -coeff});
+    }
+    std::sort(negated_definition.begin(), negated_definition.end());
+    it = non_affine_expression_to_new_var_.find(negated_definition);
+    if (it != non_affine_expression_to_new_var_.end()) {
+      new_var = it->second;
+      gcd = -gcd;
+    } else {
+      new_var = context_->NewIntVar(domain);
+      non_affine_expression_to_new_var_[definition] = new_var;
+      auto* new_linear =
+          context_->working_model->add_constraints()->mutable_linear();
+      new_linear->add_vars(new_var);
+      new_linear->add_coeffs(-1);
+      for (const auto [var, coeff] : definition) {
+        new_linear->add_vars(var);
+        new_linear->add_coeffs(coeff);
+      }
+      new_linear->add_domain(0);
+      new_linear->add_domain(0);
+      context_->solution_crush().SetVarToLinearExpression(new_var, definition);
+    }
+  }
+  expr->clear_vars();
+  expr->clear_coeffs();
+  expr->add_vars(new_var);
+  expr->add_coeffs(gcd);
+}
+
+void ModelCopy::MaybeExpandNonAffineExpressions(
+    LinearArgumentProto* linear_argument) {
+  MaybeExpandNonAffineExpression(linear_argument->mutable_target());
+  for (LinearExpressionProto& expr : *linear_argument->mutable_exprs()) {
+    MaybeExpandNonAffineExpression(&expr);
+  }
+}
+
 bool ImportModelWithBasicPresolveIntoContext(const CpModelProto& in_model,
                                              PresolveContext* context) {
   ModelCopy copier(context);
diff --git a/ortools/sat/cp_model_copy.h b/ortools/sat/cp_model_copy.h
index ff9b438b31..fbdb415350 100644
--- a/ortools/sat/cp_model_copy.h
+++ b/ortools/sat/cp_model_copy.h
@@ -16,8 +16,10 @@
 
 #include <cstdint>
 #include <functional>
+#include <utility>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/types/span.h"
 #include "ortools/sat/cp_model.pb.h"
@@ -107,9 +109,12 @@ class ModelCopy {
 
   // If we "copy" an interval for a first time, we make sure to create the
   // linear constraint between the start, size and end. This allow to simplify
-  // the input proto and client side code.
+  // the input proto and client side code. If there are more than one
+  // enforcement literals, we replace them with a new one, made equal to their
+  // conjunction with two new constraints.
   bool CopyInterval(const ConstraintProto& ct, int c, bool ignore_names);
   bool AddLinearConstraintForInterval(const ConstraintProto& ct);
+  int GetOrCreateVariableForConjunction(std::vector<int>* literals);
 
   // These function remove unperformed intervals. Note that they requires
   // interval to appear before (validated) as they test unperformed by testing
@@ -118,6 +123,17 @@ class ModelCopy {
   void CopyAndMapNoOverlap2D(const ConstraintProto& ct);
   bool CopyAndMapCumulative(const ConstraintProto& ct);
 
+  // Expands linear expressions with more than one variable in constraints which
+  // internally only support affine expressions (such as all_diff, element,
+  // interval, reservoir, table, etc). This creates new variables for each such
+  // expression, and replaces the original expressions with the new variables in
+  // the constraints.
+  void ExpandNonAffineExpressions();
+  // Replaces the expression sum a_i * x_i + c with gcd * y + c, where y is a
+  // new variable defined with an additional constraint y = sum a_i / gcd * x_i.
+  void MaybeExpandNonAffineExpression(LinearExpressionProto* expr);
+  void MaybeExpandNonAffineExpressions(LinearArgumentProto* linear_argument);
+
   PresolveContext* context_;
 
   // Temp vectors.
@@ -133,6 +149,14 @@ class ModelCopy {
   absl::flat_hash_set<int> temp_literals_set_;
 
   ConstraintProto tmp_constraint_;
+
+  // Map used in GetOrCreateVariableForConjunction() to avoid creating duplicate
+  // variables for identical sets of literals.
+  absl::flat_hash_map<std::vector<int>, int> boolean_product_encoding_;
+  // Map used in ExpandNonAffineExpressions() to avoid creating duplicate
+  // variables for the identical non affine expressions.
+  absl::flat_hash_map<std::vector<std::pair<int, int64_t>>, int>
+      non_affine_expression_to_new_var_;
 };
 
 // Copy in_model to the model in the presolve context.
diff --git a/ortools/sat/cp_model_copy_test.cc b/ortools/sat/cp_model_copy_test.cc
index 4675f66f41..ed4a9997b0 100644
--- a/ortools/sat/cp_model_copy_test.cc
+++ b/ortools/sat/cp_model_copy_test.cc
@@ -255,6 +255,137 @@ TEST(ModelCopyTest, ChangeEnforcedAtMostOrExactlyOneToLinear) {
   EXPECT_THAT(new_cp_model, EqualsProto(expected_moded));
 }
 
+TEST(ModelCopyTest, LegacyElementConstraint) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: [ 0, 1, 1 ]
+      element {
+        index: 0
+        target: 1
+        vars: [ 2, 3 ]
+      }
+    }
+  )pb");
+  const CpModelProto expected_moded = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: [ 0, 1 ]
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 }
+        exprs { vars: 3 coeffs: 1 }
+      }
+    }
+  )pb");
+  CpModelProto new_cp_model;
+  Model model;
+  model.GetOrCreate<SatParameters>()
+      ->set_keep_all_feasible_solutions_in_presolve(true);
+  PresolveContext context(&model, &new_cp_model, nullptr);
+  ImportModelWithBasicPresolveIntoContext(initial_model, &context);
+  EXPECT_THAT(new_cp_model, EqualsProto(expected_moded));
+}
+
+TEST(ModelCopyTest, ElementConstraint) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: [ 0, 1, 1 ]
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 }
+        exprs { vars: 3 coeffs: 1 }
+      }
+    }
+  )pb");
+  const CpModelProto expected_moded = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: [ 0, 1 ]
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 }
+        exprs { vars: 3 coeffs: 1 }
+      }
+    }
+  )pb");
+  CpModelProto new_cp_model;
+  Model model;
+  model.GetOrCreate<SatParameters>()
+      ->set_keep_all_feasible_solutions_in_presolve(true);
+  PresolveContext context(&model, &new_cp_model, nullptr);
+  ImportModelWithBasicPresolveIntoContext(initial_model, &context);
+  EXPECT_THAT(new_cp_model, EqualsProto(expected_moded));
+}
+
+TEST(ModelCopyTest, ExpandedNonAffineExpressionsShareVariableWhenPossible) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 10 ] }
+    variables { domain: [ 0, 10 ] }
+    constraints {
+      all_diff {
+        exprs {
+          vars: [ 0, 1 ]
+          coeffs: [ 1, 2 ]
+          offset: 1
+        }
+        exprs {
+          vars: [ 0, 1 ]
+          coeffs: [ 2, 4 ]
+          offset: 3
+        }
+        exprs {
+          vars: [ 1, 0 ]
+          coeffs: [ -2, -1 ]
+          offset: 6
+        }
+      }
+    }
+  )pb");
+  const CpModelProto expected_moded = ParseTestProto(R"pb(
+    variables { domain: [ 0, 10 ] }
+    variables { domain: [ 0, 10 ] }
+    variables { domain: [ 0, 30 ] }
+    constraints {
+      all_diff {
+        exprs { vars: 2 coeffs: 1 offset: 1 }
+        exprs { vars: 2 coeffs: 2 offset: 3 }
+        exprs { vars: 2 coeffs: -1 offset: 6 }
+      }
+    }
+    constraints {
+      linear {
+        vars: [ 2, 0, 1 ]
+        coeffs: [ -1, 1, 2 ]
+        domain: [ 0, 0 ]
+      }
+    }
+  )pb");
+  CpModelProto new_cp_model;
+  Model model;
+  model.GetOrCreate<SatParameters>()
+      ->set_keep_all_feasible_solutions_in_presolve(true);
+  PresolveContext context(&model, &new_cp_model, nullptr);
+  ImportModelWithBasicPresolveIntoContext(initial_model, &context);
+  EXPECT_THAT(new_cp_model, EqualsProto(expected_moded));
+}
+
 }  // namespace
 }  // namespace sat
 }  // namespace operations_research
diff --git a/ortools/sat/cp_model_expand.cc b/ortools/sat/cp_model_expand.cc
index 618a51b5bf..bc6e4d9ee8 100644
--- a/ortools/sat/cp_model_expand.cc
+++ b/ortools/sat/cp_model_expand.cc
@@ -28,8 +28,8 @@
 #include "absl/container/flat_hash_set.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "google/protobuf/message.h"
 #include "ortools/base/logging.h"
@@ -50,6 +50,153 @@ namespace operations_research {
 namespace sat {
 namespace {
 
+void ExpandAlwaysFalseConstraint(ConstraintProto* ct, PresolveContext* context,
+                                 absl::string_view message = "") {
+  if (ct->enforcement_literal().empty()) {
+    return (void)context->NotifyThatModelIsUnsat(message);
+  }
+  BoolArgumentProto& bool_or =
+      *context->working_model->add_constraints()->mutable_bool_or();
+  for (const int literal : ct->enforcement_literal()) {
+    bool_or.add_literals(NegatedRef(literal));
+  }
+  ct->Clear();
+}
+
+// Keeps track of the domains of the variables used in a constraint when this
+// constraint is enforced. These domains cannot be modified in the presolve
+// context because they are not valid when the constraint is not enforced.
+class EnforcedDomains {
+ public:
+  EnforcedDomains(ConstraintProto* ct, PresolveContext* context)
+      : constraint_(ct), context_(context) {}
+
+  int size() { return domains_.size(); }
+
+  bool IsFixed(const LinearExpressionProto& expr) const {
+    CHECK_LE(expr.vars_size(), 1);
+    return expr.vars().empty() || DomainOf(expr.vars(0)).IsFixed();
+  }
+
+  Domain DomainOf(int ref) const {
+    auto it = domains_.find(PositiveRef(ref));
+    if (it != domains_.end()) {
+      return RefIsPositive(ref) ? it->second : it->second.Negation();
+    }
+    return context_->DomainOf(ref);
+  }
+
+  bool DomainContains(const LinearExpressionProto& expr, int64_t value) const {
+    CHECK_LE(expr.vars_size(), 1);
+    const int64_t offset = expr.offset();
+    if (expr.vars().empty()) {
+      return offset == value;
+    }
+    const Domain domain = DomainOf(expr.vars(0));
+    const int64_t coeff = expr.coeffs(0);
+    if (value > coeff * (coeff > 0 ? domain.Max() : domain.Min()) + offset) {
+      return false;
+    }
+    if (value < coeff * (coeff > 0 ? domain.Min() : domain.Max()) + offset) {
+      return false;
+    }
+    // We assume expression is validated for overflow initially, and the code
+    // below should be overflow safe.
+    if ((value - expr.offset()) % expr.coeffs(0) != 0) return false;
+    return DomainOf(expr.vars(0))
+        .Contains((value - expr.offset()) / expr.coeffs(0));
+  }
+
+  // Returns false if the new domain is empty. This does not necessarily mean
+  // that the problem is infeasible though (if the constraint has enforcement
+  // literals, it just means that the enforcement must be false).
+  bool IntersectDomainWith(int ref, const Domain& domain,
+                           absl::string_view message = "",
+                           bool* domain_modified = nullptr) {
+    if (constraint_->enforcement_literal().empty() &&
+        !context_->IntersectDomainWith(ref, domain, domain_modified)) {
+      return context_->NotifyThatModelIsUnsat(message);
+    }
+    const Domain current_domain = DomainOf(ref);
+    if (current_domain.IsIncludedIn(domain)) return true;
+    if (domain_modified != nullptr) {
+      *domain_modified = true;
+    }
+    const Domain new_domain = current_domain.IntersectionWith(domain);
+    if (new_domain.IsEmpty()) {
+      ExpandAlwaysFalseConstraint(constraint_, context_, message);
+      return false;
+    }
+    domains_[PositiveRef(ref)] = new_domain;
+    return true;
+  };
+
+  bool SetLiteralToFalse(int lit) {
+    const int var = PositiveRef(lit);
+    const int64_t value = RefIsPositive(lit) ? 0 : 1;
+    return IntersectDomainWith(var, Domain(value));
+  }
+
+  bool IntersectDomainWith(const LinearExpressionProto& expr,
+                           const Domain& domain, absl::string_view message = "",
+                           bool* domain_modified = nullptr) {
+    CHECK_LE(expr.vars_size(), 1);
+    if (constraint_->enforcement_literal().empty() &&
+        !context_->IntersectDomainWith(expr, domain, domain_modified)) {
+      return context_->NotifyThatModelIsUnsat(message);
+    }
+    if (expr.vars().empty()) {
+      if (domain.Contains(expr.offset())) return true;
+      ExpandAlwaysFalseConstraint(constraint_, context_, message);
+      return false;
+    }
+    return IntersectDomainWith(expr.vars(0),
+                               domain.AdditionWith(Domain(-expr.offset()))
+                                   .InverseMultiplicationBy(expr.coeffs(0)),
+                               message, domain_modified);
+  }
+
+  void MaybeAddEnforcedDomainConstraints() const {
+    if (constraint_->enforcement_literal().empty()) return;
+    std::vector<int> vars;
+    for (const auto& [var, _] : domains_) {
+      vars.push_back(var);
+    }
+    std::sort(vars.begin(), vars.end());
+    for (const int var : vars) {
+      // enforcement_literal => var in domain
+      ConstraintProto* const imply = context_->working_model->add_constraints();
+      *imply->mutable_enforcement_literal() =
+          constraint_->enforcement_literal();
+      LinearConstraintProto* const lin = imply->mutable_linear();
+      lin->add_vars(var);
+      lin->add_coeffs(1);
+      FillDomainInProto(domains_.at(var), lin);
+    }
+  }
+
+ private:
+  ConstraintProto* constraint_;
+  PresolveContext* context_;
+  absl::flat_hash_map<int, Domain> domains_;
+};
+
+void ExpandEnforcedAtMostOneOrExactlyOneConstraint(ConstraintProto* ct, int c,
+                                                   PresolveContext* context) {
+  if (ct->enforcement_literal().empty()) {
+    return;
+  }
+  LinearConstraintProto linear;
+  if (ct->has_at_most_one()) {
+    LiteralsToLinear(ct->at_most_one().literals(), /*lb=*/0, /*ub=*/1, &linear);
+  } else {
+    LiteralsToLinear(ct->exactly_one().literals(), /*lb=*/1, /*ub=*/1, &linear);
+  }
+  ct->mutable_linear()->Swap(&linear);
+  context->CanonicalizeLinearConstraint(ct);
+  context->UpdateConstraintVariableUsage(c);
+}
+
 // Different encoding that support general demands. This is usually a pretty bad
 // encoding, at least until we improve the solver on such models.
 void ExpandReservoirUsingCircuit(int64_t sum_of_positive_demand,
@@ -102,10 +249,11 @@ void ExpandReservoirUsingCircuit(int64_t sum_of_positive_demand,
       // Add enforced linear for demand.
       {
         ConstraintProto* new_ct = context->working_model->add_constraints();
+        *new_ct->mutable_enforcement_literal() =
+            reservoir_ct->enforcement_literal();
         new_ct->add_enforcement_literal(start_var);
         LinearConstraintProto* lin = new_ct->mutable_linear();
-        lin->add_domain(0);
-        lin->add_domain(0);
+        FillDomainInProto(0, lin);
         lin->add_vars(level_vars[i]);
         lin->add_coeffs(1);
         AddLinearExpressionToLinearConstraint(reservoir.level_changes(i), -1,
@@ -141,10 +289,11 @@ void ExpandReservoirUsingCircuit(int64_t sum_of_positive_demand,
       // Add enforced linear for time.
       {
         ConstraintProto* new_ct = context->working_model->add_constraints();
+        *new_ct->mutable_enforcement_literal() =
+            reservoir_ct->enforcement_literal();
         new_ct->add_enforcement_literal(arc_i_j);
         LinearConstraintProto* lin = new_ct->mutable_linear();
-        lin->add_domain(0);
-        lin->add_domain(std::numeric_limits<int64_t>::max());
+        FillDomainInProto(0, std::numeric_limits<int64_t>::max(), lin);
         AddLinearExpressionToLinearConstraint(reservoir.time_exprs(j), 1, lin);
         AddLinearExpressionToLinearConstraint(reservoir.time_exprs(i), -1, lin);
         context->CanonicalizeLinearConstraint(new_ct);
@@ -153,10 +302,11 @@ void ExpandReservoirUsingCircuit(int64_t sum_of_positive_demand,
       // Add enforced linear for demand.
       {
         ConstraintProto* new_ct = context->working_model->add_constraints();
+        *new_ct->mutable_enforcement_literal() =
+            reservoir_ct->enforcement_literal();
         new_ct->add_enforcement_literal(arc_i_j);
         LinearConstraintProto* lin = new_ct->mutable_linear();
-        lin->add_domain(0);
-        lin->add_domain(0);
+        FillDomainInProto(0, lin);
         lin->add_vars(level_vars[j]);
         lin->add_coeffs(1);
         lin->add_vars(level_vars[i]);
@@ -201,6 +351,8 @@ void ExpandReservoirUsingPrecedences(bool max_level_is_constraining,
     if (demand_i < 0 && !min_level_is_constraining) continue;
 
     ConstraintProto* new_cumul = context->working_model->add_constraints();
+    *new_cumul->mutable_enforcement_literal() =
+        reservoir_ct->enforcement_literal();
     LinearConstraintProto* new_linear = new_cumul->mutable_linear();
     int64_t offset = 0;
 
@@ -236,11 +388,11 @@ void ExpandReservoirUsingPrecedences(bool max_level_is_constraining,
     // Note that according to the sign of demand_i, we only need one side.
     // We apply the offset here to make sure we use int64_t min and max.
     if (demand_i > 0) {
-      new_linear->add_domain(std::numeric_limits<int64_t>::min());
-      new_linear->add_domain(reservoir.max_level() - offset);
+      FillDomainInProto(std::numeric_limits<int64_t>::min(),
+                        reservoir.max_level() - offset, new_linear);
     } else {
-      new_linear->add_domain(reservoir.min_level() - offset);
-      new_linear->add_domain(std::numeric_limits<int64_t>::max());
+      FillDomainInProto(reservoir.min_level() - offset,
+                        std::numeric_limits<int64_t>::max(), new_linear);
     }
 
     // Canonicalize the newly created constraint.
@@ -257,8 +409,9 @@ void ExpandReservoirUsingPrecedences(bool max_level_is_constraining,
 void ExpandReservoir(ConstraintProto* reservoir_ct, PresolveContext* context) {
   if (reservoir_ct->reservoir().min_level() >
       reservoir_ct->reservoir().max_level()) {
-    VLOG(1) << "Empty level domain in reservoir constraint.";
-    return (void)context->NotifyThatModelIsUnsat();
+    ExpandAlwaysFalseConstraint(reservoir_ct, context,
+                                "Empty level domain in reservoir constraint.");
+    return;
   }
 
   const ReservoirConstraintProto& reservoir = reservoir_ct->reservoir();
@@ -298,7 +451,10 @@ void ExpandReservoir(ConstraintProto* reservoir_ct, PresolveContext* context) {
   if (num_negatives == 0 || num_positives == 0) {
     const int true_literal = context->GetTrueLiteral();
     ConstraintProto* new_ct = context->working_model->add_constraints();
+    *new_ct->mutable_enforcement_literal() =
+        reservoir_ct->enforcement_literal();
     LinearConstraintProto* sum = new_ct->mutable_linear();
+    FillDomainInProto(reservoir.min_level(), reservoir.max_level(), sum);
     for (int i = 0; i < num_events; ++i) {
       const int active = reservoir.active_literals().empty()
                              ? true_literal
@@ -331,8 +487,7 @@ void ExpandReservoir(ConstraintProto* reservoir_ct, PresolveContext* context) {
               context->working_model->add_constraints();
           demand_ct->add_enforcement_literal(active);
           LinearConstraintProto* lin = demand_ct->mutable_linear();
-          lin->add_domain(0);
-          lin->add_domain(0);
+          FillDomainInProto(0, lin);
           lin->add_vars(new_var);
           lin->add_coeffs(1);
           AddLinearExpressionToLinearConstraint(demand, -1, lin);
@@ -347,8 +502,6 @@ void ExpandReservoir(ConstraintProto* reservoir_ct, PresolveContext* context) {
                                                   NegatedRef(active));
       }
     }
-    sum->add_domain(reservoir.min_level());
-    sum->add_domain(reservoir.max_level());
     context->CanonicalizeLinearConstraint(new_ct);
 
     context->UpdateRuleStats("reservoir: simple expansion with sum");
@@ -387,6 +540,7 @@ void EncodeCumulativeAsReservoir(ConstraintProto* ct,
   // Note that we know that the min_level can never go below zero, so we can
   // just ignore this part of the constraint here.
   ConstraintProto reservoir_ct;
+  *reservoir_ct.mutable_enforcement_literal() = ct->enforcement_literal();
   auto* reservoir = reservoir_ct.mutable_reservoir();
   reservoir->set_min_level(std::numeric_limits<int64_t>::min());
   reservoir->set_max_level(context->FixedValue(ct->cumulative().capacity()));
@@ -467,6 +621,10 @@ void ExpandIntMod(ConstraintProto* ct, PresolveContext* context) {
           .ContinuousMultiplicationBy(context->DomainSuperSetOf(mod_expr))
           .IntersectionWith(context->DomainSuperSetOf(expr).AdditionWith(
               context->DomainSuperSetOf(target_expr).Negation()));
+  if (prod_domain.IsEmpty()) {
+    return (void)context->NotifyThatModelIsUnsat(
+        "int_mod: empty target domain");
+  }
   const int prod_var = context->NewIntVar(prod_domain);
   LinearExpressionProto prod_expr;
   prod_expr.add_vars(prod_var);
@@ -481,8 +639,7 @@ void ExpandIntMod(ConstraintProto* ct, PresolveContext* context) {
   // expr - prod_expr = target_expr.
   LinearConstraintProto* const lin =
       new_enforced_constraint()->mutable_linear();
-  lin->add_domain(0);
-  lin->add_domain(0);
+  FillDomainInProto(0, lin);
   AddLinearExpressionToLinearConstraint(expr, 1, lin);
   AddLinearExpressionToLinearConstraint(prod_expr, -1, lin);
   AddLinearExpressionToLinearConstraint(target_expr, -1, lin);
@@ -546,25 +703,25 @@ void ExpandInverse(ConstraintProto* ct, PresolveContext* context) {
   //
   // TODO(user): Add support for UNSAT at expansion. This should create empty
   // domain if UNSAT, so it should still work correctly.
-  absl::flat_hash_set<int> used_variables;
+  EnforcedDomains enforced_domains(ct, context);
   for (const int ref : f_direct) {
-    used_variables.insert(PositiveRef(ref));
-    if (!context->IntersectDomainWith(ref, Domain(0, n - 1))) {
-      VLOG(1) << "Empty domain for a variable in ExpandInverse()";
+    if (!enforced_domains.IntersectDomainWith(
+            ref, Domain(0, n - 1),
+            "Empty domain for a variable in ExpandInverse()")) {
       return;
     }
   }
   for (const int ref : f_inverse) {
-    used_variables.insert(PositiveRef(ref));
-    if (!context->IntersectDomainWith(ref, Domain(0, n - 1))) {
-      VLOG(1) << "Empty domain for a variable in ExpandInverse()";
+    if (!enforced_domains.IntersectDomainWith(
+            ref, Domain(0, n - 1),
+            "Empty domain for a variable in ExpandInverse()")) {
       return;
     }
   }
 
   // If we have duplicate variables, we make sure the domain are reduced
   // as the loop below might not detect incompatibilities.
-  if (used_variables.size() != 2 * n) {
+  if (enforced_domains.size() != 2 * n) {
     for (int i = 0; i < n; ++i) {
       for (int j = 0; j < n; ++j) {
         // Note that if we don't have the same sign, both domain are at zero.
@@ -572,8 +729,9 @@ void ExpandInverse(ConstraintProto* ct, PresolveContext* context) {
 
         // We can't have i or j as value if i != j.
         if (i == j) continue;
-        if (!context->IntersectDomainWith(
-                f_direct[i], Domain::FromValues({i, j}).Complement())) {
+        if (!enforced_domains.IntersectDomainWith(
+                f_direct[i], Domain::FromValues({i, j}).Complement(),
+                "Empty domain for a variable in ExpandInverse()")) {
           return;
         }
       }
@@ -585,54 +743,74 @@ void ExpandInverse(ConstraintProto* ct, PresolveContext* context) {
   std::vector<int64_t> possible_values;
 
   // Propagate from one vector to its counterpart.
-  const auto filter_inverse_domain =
-      [context, n, &possible_values](const auto& direct, const auto& inverse) {
-        // Propagate from the inverse vector to the direct vector.
-        for (int i = 0; i < n; ++i) {
-          possible_values.clear();
-          const Domain domain = context->DomainOf(direct[i]);
-          bool removed_value = false;
-          for (const int64_t j : domain.Values()) {
-            if (context->DomainOf(inverse[j]).Contains(i)) {
-              possible_values.push_back(j);
-            } else {
-              removed_value = true;
-            }
-          }
-          if (removed_value) {
-            if (!context->IntersectDomainWith(
-                    direct[i], Domain::FromValues(possible_values))) {
-              VLOG(1) << "Empty domain for a variable in ExpandInverse()";
-              return false;
-            }
-          }
+  const auto filter_inverse_domain = [&enforced_domains, n, &possible_values](
+                                         const auto& direct,
+                                         const auto& inverse) {
+    // Propagate from the inverse vector to the direct vector.
+    for (int i = 0; i < n; ++i) {
+      possible_values.clear();
+      const Domain domain = enforced_domains.DomainOf(direct[i]);
+      bool removed_value = false;
+      for (const int64_t j : domain.Values()) {
+        if (enforced_domains.DomainOf(inverse[j]).Contains(i)) {
+          possible_values.push_back(j);
+        } else {
+          removed_value = true;
         }
-        return true;
-      };
+      }
+      if (removed_value) {
+        if (!enforced_domains.IntersectDomainWith(
+                direct[i], Domain::FromValues(possible_values),
+                "Empty domain for a variable in ExpandInverse()")) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
 
   // Note that this should reach the fixed point in one pass.
   // However, if we have duplicate variable, I am not sure.
   if (!filter_inverse_domain(f_direct, f_inverse)) return;
   if (!filter_inverse_domain(f_inverse, f_direct)) return;
 
+  enforced_domains.MaybeAddEnforcedDomainConstraints();
+
   // Expand the inverse constraint by associating literal to var == value
   // and sharing them between the direct and inverse variables.
   //
   // Note that this is only correct because the domain are tight now.
   for (int i = 0; i < n; ++i) {
     const int f_i = f_direct[i];
-    for (const int64_t j : context->DomainOf(f_i).Values()) {
-      // We have f[i] == j <=> r[j] == i;
+    for (const int64_t j : enforced_domains.DomainOf(f_i).Values()) {
       const int r_j = f_inverse[j];
-      int r_j_i;
-      if (context->HasVarValueEncoding(r_j, i, &r_j_i)) {
-        if (!context->InsertVarValueEncoding(r_j_i, f_i, j)) {
-          return;
+      if (ct->enforcement_literal().empty()) {
+        // We have f[i] == j <=> r[j] == i;
+        int r_j_i;
+        if (context->HasVarValueEncoding(r_j, i, &r_j_i)) {
+          if (!context->InsertVarValueEncoding(r_j_i, f_i, j)) {
+            return;
+          }
+        } else {
+          const int f_i_j = context->GetOrCreateVarValueEncoding(f_i, j);
+          if (!context->InsertVarValueEncoding(f_i_j, r_j, i)) {
+            return;
+          }
         }
       } else {
+        // We have enforcement_literal && f[i] == j => r[j] == i;
+        // We have enforcement_literal && r[j] == i => f[i] == j;
         const int f_i_j = context->GetOrCreateVarValueEncoding(f_i, j);
-        if (!context->InsertVarValueEncoding(f_i_j, r_j, i)) {
-          return;
+        const int r_j_i = context->GetOrCreateVarValueEncoding(r_j, i);
+        if (f_i_j != r_j_i) {
+          ConstraintProto* eq = context->working_model->add_constraints();
+          *eq->mutable_enforcement_literal() = ct->enforcement_literal();
+          eq->add_enforcement_literal(f_i_j);
+          eq->mutable_bool_and()->add_literals(r_j_i);
+          eq = context->working_model->add_constraints();
+          *eq->mutable_enforcement_literal() = ct->enforcement_literal();
+          eq->add_enforcement_literal(r_j_i);
+          eq->mutable_bool_and()->add_literals(f_i_j);
         }
       }
     }
@@ -653,27 +831,28 @@ void ExpandLinMax(ConstraintProto* ct, PresolveContext* context) {
   // We will create 2 * num_exprs constraints for target = max(a1, ..., an).
 
   // First.
-  // - target >= ai
+  // - enforcement literals => target >= ai
   for (const LinearExpressionProto& expr : ct->lin_max().exprs()) {
     ConstraintProto* new_ct = context->working_model->add_constraints();
+    *new_ct->mutable_enforcement_literal() = ct->enforcement_literal();
     LinearConstraintProto* lin = new_ct->mutable_linear();
-    lin->add_domain(0);
-    lin->add_domain(std::numeric_limits<int64_t>::max());
+    FillDomainInProto(0, std::numeric_limits<int64_t>::max(), lin);
     AddLinearExpressionToLinearConstraint(ct->lin_max().target(), 1, lin);
     AddLinearExpressionToLinearConstraint(expr, -1, lin);
     context->CanonicalizeLinearConstraint(new_ct);
   }
 
   // Second, for each expr, create a new boolean bi, and add bi => target <= ai
-  // With exactly_one(bi)
+  // With enforcement literals => exactly_one(bi)
   std::vector<int> enforcement_literals;
   enforcement_literals.reserve(num_exprs);
-  if (num_exprs == 2) {
+  if (num_exprs == 2 && ct->enforcement_literal().empty()) {
     const int new_bool = context->NewBoolVar("lin max expansion");
     enforcement_literals.push_back(new_bool);
     enforcement_literals.push_back(NegatedRef(new_bool));
   } else {
     ConstraintProto* exactly_one = context->working_model->add_constraints();
+    *exactly_one->mutable_enforcement_literal() = ct->enforcement_literal();
     for (int i = 0; i < num_exprs; ++i) {
       const int new_bool = context->NewBoolVar("lin max expansion");
       exactly_one->mutable_exactly_one()->add_literals(new_bool);
@@ -685,8 +864,7 @@ void ExpandLinMax(ConstraintProto* ct, PresolveContext* context) {
     ConstraintProto* new_ct = context->working_model->add_constraints();
     new_ct->add_enforcement_literal(enforcement_literals[i]);
     LinearConstraintProto* lin = new_ct->mutable_linear();
-    lin->add_domain(std::numeric_limits<int64_t>::min());
-    lin->add_domain(0);
+    FillDomainInProto(std::numeric_limits<int64_t>::min(), 0, lin);
     AddLinearExpressionToLinearConstraint(ct->lin_max().target(), 1, lin);
     AddLinearExpressionToLinearConstraint(ct->lin_max().exprs(i), -1, lin);
     context->CanonicalizeLinearConstraint(new_ct);
@@ -699,8 +877,9 @@ void ExpandLinMax(ConstraintProto* ct, PresolveContext* context) {
 }
 
 // A[V] == V means for all i, V == i => A_i == i
-void ExpandElementWhenTargetShareVarWithIndex(ConstraintProto* ct,
-                                              PresolveContext* context) {
+void ExpandElementWhenTargetShareVarWithIndex(
+    ConstraintProto* ct, PresolveContext* context,
+    const Domain& reduced_index_var_domain) {
   const ElementConstraintProto& element = ct->element();
 
   const LinearExpressionProto& index = element.linear_index();
@@ -710,15 +889,15 @@ void ExpandElementWhenTargetShareVarWithIndex(ConstraintProto* ct,
   DCHECK_EQ(target.vars_size(), 1);
   DCHECK_EQ(target.vars(0), index_var);
 
-  for (const int64_t v : context->DomainOf(index_var).Values()) {
+  for (const int64_t v : reduced_index_var_domain.Values()) {
     const int64_t index_value = AffineExpressionValueAt(index, v);
     const int64_t target_value = AffineExpressionValueAt(target, v);
     const LinearExpressionProto& expr = element.exprs(index_value);
     ConstraintProto* imply = context->working_model->add_constraints();
+    *imply->mutable_enforcement_literal() = ct->enforcement_literal();
     imply->add_enforcement_literal(
         context->GetOrCreateVarValueEncoding(index_var, v));
-    imply->mutable_linear()->add_domain(target_value);
-    imply->mutable_linear()->add_domain(target_value);
+    FillDomainInProto(target_value, imply->mutable_linear());
     AddLinearExpressionToLinearConstraint(expr, 1, imply->mutable_linear());
     context->CanonicalizeLinearConstraint(imply);
   }
@@ -729,23 +908,20 @@ void ExpandElementWhenTargetShareVarWithIndex(ConstraintProto* ct,
 }
 
 // Special case if the array of the element is filled with constant values.
-void ExpandConstantArrayElement(ConstraintProto* ct, PresolveContext* context) {
+void ExpandConstantArrayElement(ConstraintProto* ct, PresolveContext* context,
+                                const Domain& reduced_index_var_domain) {
   const ElementConstraintProto& element = ct->element();
   const LinearExpressionProto& index = element.linear_index();
   DCHECK_EQ(index.vars_size(), 1);
   const int index_var = index.vars(0);
   const LinearExpressionProto& target = element.linear_target();
 
-  // Index and target domain have been reduced before calling this function.
-  const Domain index_var_domain = context->DomainOf(index_var);
-  const Domain target_domain = context->DomainSuperSetOf(target);
-
   // This BoolOrs implements the deduction that if all index literals pointing
   // to the same value in the constant array are false, then this value is no
   // no longer valid for the target variable. They are created only for values
   // that have multiples literals supporting them.
   absl::btree_map<int64_t, std::vector<int>> supports;
-  for (const int64_t v : index_var_domain.Values()) {
+  for (const int64_t v : reduced_index_var_domain.Values()) {
     const int64_t index_value = AffineExpressionValueAt(index, v);
     const int64_t expr_value = context->FixedValue(element.exprs(index_value));
     supports[expr_value].push_back(v);
@@ -755,25 +931,31 @@ void ExpandConstantArrayElement(ConstraintProto* ct, PresolveContext* context) {
   // covered, it allows to easily detect this fact in the presolve.
   //
   // TODO(user): Do we need the support part ? Is this discovered by probing?
-  auto* exactly_one =
-      context->working_model->add_constraints()->mutable_exactly_one();
+  ConstraintProto* const exactly_one =
+      context->working_model->add_constraints();
+  *exactly_one->mutable_enforcement_literal() = ct->enforcement_literal();
   for (const auto& [expr_value, support] : supports) {
     const int target_literal =
         context->GetOrCreateAffineValueEncoding(target, expr_value);
-    // not(indices supporting value) -> target != value
-    BoolArgumentProto* bool_or =
-        context->working_model->add_constraints()->mutable_bool_or();
-    bool_or->add_literals(NegatedRef(target_literal));
+    // enforcement_literal && not(indices supporting value) => target != value
+    ConstraintProto* const bool_or = context->working_model->add_constraints();
+    *bool_or->mutable_enforcement_literal() = ct->enforcement_literal();
+    bool_or->mutable_bool_or()->add_literals(NegatedRef(target_literal));
     for (const int64_t v : support) {
       const int index_literal =
           context->GetOrCreateVarValueEncoding(index_var, v);
-      bool_or->add_literals(index_literal);
+      bool_or->mutable_bool_or()->add_literals(index_literal);
 
-      // index == v => target == value
-      context->AddImplication(index_literal, target_literal);
+      // enforcement_literal && index == v => target == value
+      if (index_literal != target_literal) {
+        ConstraintProto* const eq = context->working_model->add_constraints();
+        *eq->mutable_enforcement_literal() = ct->enforcement_literal();
+        eq->add_enforcement_literal(index_literal);
+        eq->mutable_bool_and()->add_literals(target_literal);
+      }
 
       // Helps presolve.
-      exactly_one->add_literals(index_literal);
+      exactly_one->mutable_exactly_one()->add_literals(index_literal);
     }
   }
 
@@ -782,28 +964,28 @@ void ExpandConstantArrayElement(ConstraintProto* ct, PresolveContext* context) {
 }
 
 // General element when the array contains non fixed variables.
-void ExpandVariableElement(ConstraintProto* ct, PresolveContext* context) {
+void ExpandVariableElement(ConstraintProto* ct, PresolveContext* context,
+                           const Domain& reduced_index_var_domain) {
   const ElementConstraintProto& element = ct->element();
   const LinearExpressionProto& index = element.linear_index();
   DCHECK_EQ(index.vars_size(), 1);
   const int index_var = index.vars(0);
-  const Domain index_var_domain = context->DomainOf(index_var);
   const LinearExpressionProto& target = element.linear_target();
 
-  BoolArgumentProto* exactly_one =
-      context->working_model->add_constraints()->mutable_exactly_one();
+  ConstraintProto* exactly_one = context->working_model->add_constraints();
+  *exactly_one->mutable_enforcement_literal() = ct->enforcement_literal();
 
-  for (const int64_t v : index_var_domain.Values()) {
+  for (const int64_t v : reduced_index_var_domain.Values()) {
     const int64_t index_value = AffineExpressionValueAt(index, v);
     DCHECK_GE(index_value, 0);
     DCHECK_LT(index_value, element.exprs_size());
     const int index_lit = context->GetOrCreateVarValueEncoding(index_var, v);
-    exactly_one->add_literals(index_lit);
+    exactly_one->mutable_exactly_one()->add_literals(index_lit);
 
     ConstraintProto* const imply = context->working_model->add_constraints();
+    *imply->mutable_enforcement_literal() = ct->enforcement_literal();
     imply->add_enforcement_literal(index_lit);
-    imply->mutable_linear()->add_domain(0);
-    imply->mutable_linear()->add_domain(0);
+    FillDomainInProto(0, imply->mutable_linear());
     AddLinearExpressionToLinearConstraint(target, -1, imply->mutable_linear());
     AddLinearExpressionToLinearConstraint(ct->element().exprs(index_value), 1,
                                           imply->mutable_linear());
@@ -829,18 +1011,50 @@ void ExpandElement(ConstraintProto* ct, PresolveContext* context) {
 
   // Reduce the domain of the index to be compatible with the array of
   // variables. Note that the element constraint is 0 based.
-  if (!context->IntersectDomainWith(index, Domain(0, size - 1))) {
-    VLOG(1) << "Empty domain for the index variable in ExpandElement()";
-    return;
+  const Domain reduced_index_var_domain =
+      index.vars_size() == 1
+          ? context->DomainOf(index.vars(0))
+                .IntersectionWith(Domain(0, size - 1)
+                                      .AdditionWith(Domain(-index.offset()))
+                                      .InverseMultiplicationBy(index.coeffs(0)))
+          : Domain();
+
+  if (ct->enforcement_literal().empty()) {
+    if (!context->IntersectDomainWith(index, Domain(0, size - 1))) {
+      VLOG(1) << "Empty domain for the index variable in ExpandElement()";
+      return;
+    }
+  } else {
+    const bool reduced_index_domain_is_empty =
+        index.vars_size() == 1 ? reduced_index_var_domain.IsEmpty()
+                               : (index.offset() < 0 || index.offset() >= size);
+    if (reduced_index_domain_is_empty) {
+      ExpandAlwaysFalseConstraint(ct, context);
+      return;
+    }
+    // enforcement_literal => index in [0, size - 1]
+    ConstraintProto* const index_ct = context->working_model->add_constraints();
+    *index_ct->mutable_enforcement_literal() = ct->enforcement_literal();
+    FillDomainInProto(0, size - 1, index_ct->mutable_linear());
+    AddLinearExpressionToLinearConstraint(index, 1, index_ct->mutable_linear());
+    context->CanonicalizeLinearConstraint(index_ct);
   }
 
-  if (context->IsFixed(index)) {
+  const bool reduced_index_domain_is_fixed =
+      index.vars_size() == 0 || reduced_index_var_domain.IsFixed();
+  if (reduced_index_domain_is_fixed) {
+    DCHECK(!ct->enforcement_literal().empty() || context->IsFixed(index));
     ConstraintProto* const eq = context->working_model->add_constraints();
-    eq->mutable_linear()->add_domain(0);
-    eq->mutable_linear()->add_domain(0);
+    *eq->mutable_enforcement_literal() = ct->enforcement_literal();
+    FillDomainInProto(0, eq->mutable_linear());
     AddLinearExpressionToLinearConstraint(target, 1, eq->mutable_linear());
+    const int64_t reduced_index_fixed_value =
+        index.vars_size() == 0
+            ? index.offset()
+            : AffineExpressionValueAt(index,
+                                      reduced_index_var_domain.FixedValue());
     AddLinearExpressionToLinearConstraint(
-        ct->element().exprs(context->FixedValue(index)), -1,
+        ct->element().exprs(reduced_index_fixed_value), -1,
         eq->mutable_linear());
     context->CanonicalizeLinearConstraint(eq);
     context->UpdateRuleStats("element: expanded with fixed index");
@@ -851,13 +1065,14 @@ void ExpandElement(ConstraintProto* ct, PresolveContext* context) {
   // Special case when index.var = target.var.
   if (index.vars_size() == 1 && target.vars_size() == 1 &&
       index.vars(0) == target.vars(0)) {
-    ExpandElementWhenTargetShareVarWithIndex(ct, context);
+    ExpandElementWhenTargetShareVarWithIndex(ct, context,
+                                             reduced_index_var_domain);
     return;
   }
 
   // Checks if all elements are constant.
   bool all_constants = true;
-  for (const int64_t v : context->DomainOf(index.vars(0)).Values()) {
+  for (const int64_t v : reduced_index_var_domain.Values()) {
     const int64_t index_value = AffineExpressionValueAt(index, v);
     if (!context->IsFixed(element.exprs(index_value))) {
       all_constants = false;
@@ -866,15 +1081,19 @@ void ExpandElement(ConstraintProto* ct, PresolveContext* context) {
   }
 
   if (all_constants) {
-    ExpandConstantArrayElement(ct, context);
+    ExpandConstantArrayElement(ct, context, reduced_index_var_domain);
   } else {
-    ExpandVariableElement(ct, context);
+    ExpandVariableElement(ct, context, reduced_index_var_domain);
   }
 }
 
-// Adds clauses so that literals[i] true <=> encoding[values[i]] true.
-// This also implicitly use the fact that exactly one alternative is true.
-void LinkLiteralsAndValues(absl::Span<const int> literals,
+// Adds clauses so that:
+//  enforcement_literals && literals[i] true => encoding[values[i]] true
+//  enforcement_literals => one of literals[i in I(j)] true || encoding[j] false
+// where I(j) = {i | values[i] = j}. This also implicitly uses the fact that
+// exactly one alternative is true.
+void LinkLiteralsAndValues(absl::Span<const int> enforcement_literals,
+                           absl::Span<const int> literals,
                            absl::Span<const int64_t> values,
                            const absl::flat_hash_map<int64_t, int>& encoding,
                            PresolveContext* context) {
@@ -885,36 +1104,46 @@ void LinkLiteralsAndValues(absl::Span<const int> literals,
   // TODO(user): Make sure this does not appear in the profile.
   absl::btree_map<int, std::vector<int>> encoding_lit_to_support;
 
-  // If a value is false (i.e not possible), then the tuple with this
-  // value is false too (i.e not possible). Conversely, if the tuple is
-  // selected, the value must be selected.
   for (int i = 0; i < values.size(); ++i) {
     encoding_lit_to_support[encoding.at(values[i])].push_back(literals[i]);
   }
 
-  // If all tuples supporting a value are false, then this value must be
-  // false.
   for (const auto& [encoding_lit, support] : encoding_lit_to_support) {
     CHECK(!support.empty());
-    if (support.size() == 1) {
+    if (support.size() == 1 && enforcement_literals.empty()) {
       if (!context->StoreBooleanEqualityRelation(encoding_lit, support[0])) {
         return;
       }
     } else {
-      BoolArgumentProto* bool_or =
-          context->working_model->add_constraints()->mutable_bool_or();
+      // The `ct` constraint ensures that if all tuples supporting a value are
+      // false, then this value must be false (if the automaton constraint is
+      // enforced).
+      ConstraintProto* ct = context->working_model->add_constraints();
+      *ct->mutable_enforcement_literal() = {enforcement_literals.begin(),
+                                            enforcement_literals.end()};
+      BoolArgumentProto* bool_or = ct->mutable_bool_or();
       bool_or->add_literals(NegatedRef(encoding_lit));
       for (const int lit : support) {
         bool_or->add_literals(lit);
-        context->AddImplication(lit, encoding_lit);
+        // Conversely, if a tuple supporting a value is selected, this value
+        // must be selected (if the automaton constraint is enforced).
+        if (lit != encoding_lit) {
+          ConstraintProto* inv_ct = context->working_model->add_constraints();
+          *inv_ct->mutable_enforcement_literal() = {
+              enforcement_literals.begin(), enforcement_literals.end()};
+          inv_ct->add_enforcement_literal(lit);
+          inv_ct->mutable_bool_and()->add_literals(encoding_lit);
+        }
       }
     }
   }
 }
 
-// Add the constraint literal => one_of(encoding[v]), for v in reachable_values.
-// Note that all possible values are the ones appearing in encoding.
-void AddImplyInReachableValues(int literal,
+// Add the constraint enforcement_literals && literal => one_of(encoding[v]),
+// for v in reachable_values. Note that all possible values are the ones
+// appearing in encoding.
+void AddImplyInReachableValues(absl::Span<const int> enforcement_literals,
+                               int literal,
                                std::vector<int64_t>& reachable_values,
                                const absl::flat_hash_map<int64_t, int> encoding,
                                PresolveContext* context) {
@@ -923,6 +1152,8 @@ void AddImplyInReachableValues(int literal,
   if (reachable_values.size() <= encoding.size() / 2) {
     // Bool or encoding.
     ConstraintProto* ct = context->working_model->add_constraints();
+    *ct->mutable_enforcement_literal() = {enforcement_literals.begin(),
+                                          enforcement_literals.end()};
     ct->add_enforcement_literal(literal);
     BoolArgumentProto* bool_or = ct->mutable_bool_or();
     for (const int64_t v : reachable_values) {
@@ -933,6 +1164,8 @@ void AddImplyInReachableValues(int literal,
     absl::flat_hash_set<int64_t> set(reachable_values.begin(),
                                      reachable_values.end());
     ConstraintProto* ct = context->working_model->add_constraints();
+    *ct->mutable_enforcement_literal() = {enforcement_literals.begin(),
+                                          enforcement_literals.end()};
     ct->add_enforcement_literal(literal);
     BoolArgumentProto* bool_and = ct->mutable_bool_and();
     for (const auto [value, literal] : encoding) {
@@ -955,11 +1188,15 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
         return;
       }
     }
-    return (void)context->NotifyThatModelIsUnsat(
+
+    ExpandAlwaysFalseConstraint(
+        ct, context,
         "automaton: empty with an initial state not in the final states.");
+    return;
   } else if (proto.transition_label_size() == 0) {
-    return (void)context->NotifyThatModelIsUnsat(
-        "automaton: non-empty with no transition.");
+    ExpandAlwaysFalseConstraint(ct, context,
+                                "automaton: non-empty with no transition.");
+    return;
   }
 
   std::vector<absl::flat_hash_set<int64_t>> reachable_states;
@@ -975,6 +1212,7 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
   absl::flat_hash_map<int64_t, int> in_encoding;
   absl::flat_hash_map<int64_t, int> out_encoding;
   bool removed_values = false;
+  EnforcedDomains enforced_domains(ct, context);
 
   const int n = proto.exprs_size();
   std::vector<SolutionCrush::StateVar> new_state_vars;
@@ -995,7 +1233,7 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
 
       if (!reachable_states[time].contains(tail)) continue;
       if (!reachable_states[time + 1].contains(head)) continue;
-      if (!context->DomainContains(proto.exprs(time), label)) continue;
+      if (!enforced_domains.DomainContains(proto.exprs(time), label)) continue;
 
       still_reachable_after_domain_change.insert(head);
       // TODO(user): if this transition correspond to just one in-state or
@@ -1014,9 +1252,9 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
     // Deal with single tuple.
     const int num_tuples = in_states.size();
     if (num_tuples == 1) {
-      if (!context->IntersectDomainWith(proto.exprs(time),
-                                        Domain(labels.front()))) {
-        VLOG(1) << "Infeasible automaton.";
+      if (!enforced_domains.IntersectDomainWith(proto.exprs(time),
+                                                Domain(labels.front()),
+                                                "Infeasible automaton.")) {
         return;
       }
 
@@ -1026,7 +1264,7 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
       std::vector<int> at_false;
       for (const auto [value, literal] : in_encoding) {
         if (value != in_states[0]) {
-          if (!context->SetLiteralToFalse(literal)) return;
+          if (!enforced_domains.SetLiteralToFalse(literal)) return;
         }
       }
 
@@ -1041,17 +1279,17 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
       gtl::STLSortAndRemoveDuplicates(&transitions);
 
       encoding.clear();
-      if (!context->IntersectDomainWith(expr, Domain::FromValues(transitions),
-                                        &removed_values)) {
-        VLOG(1) << "Infeasible automaton.";
+      if (!enforced_domains.IntersectDomainWith(
+              expr, Domain::FromValues(transitions), "Infeasible automaton.",
+              &removed_values)) {
         return;
       }
 
       // Fully encode the variable.
       // We can leave the encoding empty for fixed vars.
-      if (!context->IsFixed(expr)) {
+      if (!enforced_domains.IsFixed(expr)) {
         const int var = expr.vars(0);
-        for (const int64_t v : context->DomainOf(var).Values()) {
+        for (const int64_t v : enforced_domains.DomainOf(var).Values()) {
           encoding[AffineExpressionValueAt(expr, v)] =
               context->GetOrCreateVarValueEncoding(var, v);
         }
@@ -1166,16 +1404,18 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
           in_encoding.begin(), in_encoding.end());
       absl::c_sort(in_to_label_pairs);
       for (const auto [in_value, in_literal] : in_to_label_pairs) {
-        AddImplyInReachableValues(in_literal, in_to_label[in_value], encoding,
-                                  context);
-        AddImplyInReachableValues(in_literal, in_to_out[in_value], out_encoding,
-                                  context);
+        AddImplyInReachableValues(ct->enforcement_literal(), in_literal,
+                                  in_to_label[in_value], encoding, context);
+        AddImplyInReachableValues(ct->enforcement_literal(), in_literal,
+                                  in_to_out[in_value], out_encoding, context);
       }
 
-      // Part2, add all 3-clauses: (in_state, label) => out_state.
+      // Part2, add all 3-clauses: enforcement_literal && (in_state, label) =>
+      // out_state.
       for (int i = 0; i < num_tuples; ++i) {
-        auto* bool_or =
-            context->working_model->add_constraints()->mutable_bool_or();
+        ConstraintProto* bool_or_ct = context->working_model->add_constraints();
+        *bool_or_ct->mutable_enforcement_literal() = ct->enforcement_literal();
+        auto* bool_or = bool_or_ct->mutable_bool_or();
         bool_or->add_literals(NegatedRef(in_encoding.at(in_states[i])));
         bool_or->add_literals(NegatedRef(encoding.at(labels[i])));
         bool_or->add_literals(out_encoding.at(out_states[i]));
@@ -1200,8 +1440,11 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
       // Note that we do not need the ExactlyOneConstraint(tuple_literals)
       // because it is already implicitly encoded since we have exactly one
       // transition value. But adding one seems to help.
-      BoolArgumentProto* exactly_one =
-          context->working_model->add_constraints()->mutable_exactly_one();
+      ConstraintProto* exactly_one_ct =
+          context->working_model->add_constraints();
+      *exactly_one_ct->mutable_enforcement_literal() =
+          ct->enforcement_literal();
+      BoolArgumentProto* exactly_one = exactly_one_ct->mutable_exactly_one();
       for (int i = 0; i < num_tuples; ++i) {
         int tuple_literal;
         if (in_count[in_states[i]] == 1 && !in_encoding.empty()) {
@@ -1222,19 +1465,24 @@ void ExpandAutomaton(ConstraintProto* ct, PresolveContext* context) {
     }
 
     if (!in_encoding.empty()) {
-      LinkLiteralsAndValues(tuple_literals, in_states, in_encoding, context);
+      LinkLiteralsAndValues(ct->enforcement_literal(), tuple_literals,
+                            in_states, in_encoding, context);
     }
     if (!encoding.empty()) {
-      LinkLiteralsAndValues(tuple_literals, labels, encoding, context);
+      LinkLiteralsAndValues(ct->enforcement_literal(), tuple_literals, labels,
+                            encoding, context);
     }
     if (!out_encoding.empty()) {
-      LinkLiteralsAndValues(tuple_literals, out_states, out_encoding, context);
+      LinkLiteralsAndValues(ct->enforcement_literal(), tuple_literals,
+                            out_states, out_encoding, context);
     }
 
     in_encoding.swap(out_encoding);
     out_encoding.clear();
   }
 
+  enforced_domains.MaybeAddEnforcedDomainConstraints();
+
   context->solution_crush().SetAutomatonExpandedVars(proto, new_state_vars,
                                                      new_transition_vars);
   if (removed_values) {
@@ -1581,8 +1829,7 @@ bool ReduceTableInPresenceOfUniqueVariableWithCosts(
         LinearConstraintProto* new_lin = mapping_ct->mutable_linear();
         new_lin->add_vars(deleted_vars[j]);
         new_lin->add_coeffs(1);
-        new_lin->add_domain((*tuples)[i][new_vars.size() + 1 + j]);
-        new_lin->add_domain((*tuples)[i][new_vars.size() + 1 + j]);
+        FillDomainInProto((*tuples)[i][new_vars.size() + 1 + j], new_lin);
       }
       (*tuples)[i].resize(new_vars.size() + 1);
       (*tuples)[new_size++] = (*tuples)[i];
@@ -1965,12 +2212,13 @@ void ExpandPositiveTable(ConstraintProto* ct, PresolveContext* context) {
 }
 
 bool AllDiffShouldBeExpanded(const Domain& union_of_domains,
-                             ConstraintProto* ct, PresolveContext* context) {
+                             const ConstraintProto* ct,
+                             PresolveContext* context) {
   if (union_of_domains.Size() > context->params().max_alldiff_domain_size()) {
     return false;
   }
 
-  const AllDifferentConstraintProto& proto = *ct->mutable_all_diff();
+  const AllDifferentConstraintProto& proto = ct->all_diff();
   const int num_exprs = proto.exprs_size();
   int num_fully_encoded = 0;
   for (int i = 0; i < num_exprs; ++i) {
@@ -2116,8 +2364,7 @@ void ExpandComplexLinearConstraint(int c, ConstraintProto* ct,
     ct->mutable_linear()->add_vars(slack);
     ct->mutable_linear()->add_coeffs(-1);
     ct->mutable_linear()->clear_domain();
-    ct->mutable_linear()->add_domain(0);
-    ct->mutable_linear()->add_domain(0);
+    FillDomainInProto(0, ct->mutable_linear());
   } else {
     // Boolean encoding.
     int single_bool;
@@ -2227,7 +2474,7 @@ bool IsVarEqOrNeqValue(PresolveContext* context,
 // terms, and with a tight domain ( == cst).
 // TODO(user): The above rule is complex. Revisit.
 void ScanModelAndDecideAllDiffExpansion(
-    ConstraintProto* all_diff_ct, PresolveContext* context,
+    const ConstraintProto* all_diff_ct, PresolveContext* context,
     absl::flat_hash_set<int>& domain_of_var_is_used,
     absl::flat_hash_set<int>& bounds_of_var_are_used,
     absl::flat_hash_set<int>& processed_variables, bool& expand, bool& keep) {
@@ -2418,8 +2665,10 @@ void MaybeExpandAllDiff(ConstraintProto* ct, PresolveContext* context,
 
     if (fixed_expression_count > 1) {
       // Violates the definition of AllDifferent.
-      return (void)context->NotifyThatModelIsUnsat();
-    } else if (fixed_expression_count == 1) {
+      ExpandAlwaysFalseConstraint(ct, context);
+      return;
+    } else if (fixed_expression_count == 1 &&
+               ct->enforcement_literal().empty()) {
       // Remove values from other domains.
       for (const LinearExpressionProto& expr : possible_exprs) {
         if (context->IsFixed(expr)) continue;
@@ -2430,10 +2679,11 @@ void MaybeExpandAllDiff(ConstraintProto* ct, PresolveContext* context,
       }
     }
 
+    ConstraintProto* const new_ct = context->working_model->add_constraints();
+    *new_ct->mutable_enforcement_literal() = ct->enforcement_literal();
     BoolArgumentProto* at_most_or_equal_one =
-        is_a_permutation
-            ? context->working_model->add_constraints()->mutable_exactly_one()
-            : context->working_model->add_constraints()->mutable_at_most_one();
+        is_a_permutation ? new_ct->mutable_exactly_one()
+                         : new_ct->mutable_at_most_one();
     for (const LinearExpressionProto& expr : possible_exprs) {
       // The above propagation can remove a value after the expressions was
       // added to possible_exprs.
@@ -2453,6 +2703,50 @@ void MaybeExpandAllDiff(ConstraintProto* ct, PresolveContext* context,
   if (!keep_after_expansion) ct->Clear();
 }
 
+template <typename T>
+void ExpandCircuitOrRoutes(absl::Span<const int> enforcement_literals,
+                           const T& graph_proto, PresolveContext* context,
+                           bool multiple_subcircuit_through_zero) {
+  // The constraints added below are added by LoadSubcircuitConstraint() when
+  // enforcement_literals is empty.
+  // TODO(user): ideally we don't want to do that here, but only create
+  // these constraints at loading time so that the presolve does not have to
+  // deal with redundant constraints.
+  if (enforcement_literals.empty()) return;
+  const int num_arcs = graph_proto.tails_size();
+  // At this point the node indices can have arbitrary values.
+  absl::flat_hash_map<int, int> dense_node_index;
+  for (int arc = 0; arc < num_arcs; arc++) {
+    dense_node_index.insert({graph_proto.tails(arc), dense_node_index.size()});
+    dense_node_index.insert({graph_proto.heads(arc), dense_node_index.size()});
+  }
+  const int num_nodes = dense_node_index.size();
+  std::vector<std::vector<int>> exactly_one_incoming(num_nodes);
+  std::vector<std::vector<int>> exactly_one_outgoing(num_nodes);
+  for (int arc = 0; arc < num_arcs; arc++) {
+    const int tail = dense_node_index[graph_proto.tails(arc)];
+    const int head = dense_node_index[graph_proto.heads(arc)];
+    exactly_one_outgoing[tail].push_back(graph_proto.literals(arc));
+    exactly_one_incoming[head].push_back(graph_proto.literals(arc));
+  }
+  for (int i = 0; i < exactly_one_incoming.size(); ++i) {
+    if (i == 0 && multiple_subcircuit_through_zero) continue;
+    ConstraintProto* const new_ct = context->working_model->add_constraints();
+    *new_ct->mutable_enforcement_literal() = {enforcement_literals.begin(),
+                                              enforcement_literals.end()};
+    LiteralsToLinear(exactly_one_incoming[i], /*lb=*/1, /*ub=*/1,
+                     new_ct->mutable_linear());
+  }
+  for (int i = 0; i < exactly_one_outgoing.size(); ++i) {
+    if (i == 0 && multiple_subcircuit_through_zero) continue;
+    ConstraintProto* const new_ct = context->working_model->add_constraints();
+    *new_ct->mutable_enforcement_literal() = {enforcement_literals.begin(),
+                                              enforcement_literals.end()};
+    LiteralsToLinear(exactly_one_outgoing[i], /*lb=*/1, /*ub=*/1,
+                     new_ct->mutable_linear());
+  }
+}
+
 }  // namespace
 
 void ExpandCpModel(PresolveContext* context) {
@@ -2530,6 +2824,14 @@ void ExpandCpModel(PresolveContext* context) {
         has_all_diffs = true;
         skip = true;
         break;
+      case ConstraintProto::kCircuit:
+        ExpandCircuitOrRoutes(ct->enforcement_literal(), ct->circuit(), context,
+                              /*multiple_subcircuit_through_zero=*/false);
+        break;
+      case ConstraintProto::kRoutes:
+        ExpandCircuitOrRoutes(ct->enforcement_literal(), ct->routes(), context,
+                              /*multiple_subcircuit_through_zero=*/true);
+        break;
       default:
         skip = true;
         break;
@@ -2561,6 +2863,12 @@ void ExpandCpModel(PresolveContext* context) {
     ConstraintProto* const ct = context->working_model->mutable_constraints(i);
     bool skip = false;
     switch (ct->constraint_case()) {
+      case ConstraintProto::kAtMostOne:
+      case ConstraintProto::kExactlyOne:
+        // We do those in the second pass since MaybeExpandAllDiff() below may
+        // create such constraints.
+        ExpandEnforcedAtMostOneOrExactlyOneConstraint(ct, i, context);
+        break;
       case ConstraintProto::kAllDiff:
         MaybeExpandAllDiff(ct, context, domain_of_var_is_used,
                            bounds_of_var_are_used, processed_variables);
diff --git a/ortools/sat/cp_model_expand_test.cc b/ortools/sat/cp_model_expand_test.cc
index 8114f6892f..06004e6138 100644
--- a/ortools/sat/cp_model_expand_test.cc
+++ b/ortools/sat/cp_model_expand_test.cc
@@ -14,7 +14,6 @@
 #include "ortools/sat/cp_model_expand.h"
 
 #include <cstdint>
-#include <string>
 #include <vector>
 
 #include "absl/container/btree_set.h"
@@ -24,6 +23,7 @@
 #include "ortools/base/gmock.h"
 #include "ortools/base/logging.h"
 #include "ortools/base/parse_test_proto.h"
+#include "ortools/base/parse_text_proto.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_checker.h"
 #include "ortools/sat/cp_model_solver.h"
@@ -38,6 +38,7 @@ namespace sat {
 namespace {
 
 using ::google::protobuf::contrib::parse_proto::ParseTestProto;
+using ::google::protobuf::contrib::parse_proto::ParseTextOrDie;
 
 CpSolverResponse SolveAndCheck(
     const CpModelProto& initial_model, absl::string_view extra_parameters = "",
@@ -48,7 +49,7 @@ CpSolverResponse SolveAndCheck(
   params.set_debug_crash_if_presolve_breaks_hint(true);
   params.set_log_search_progress(true);
   if (!extra_parameters.empty()) {
-    params.MergeFromString(extra_parameters);
+    params.MergeFrom(ParseTextOrDie<SatParameters>(extra_parameters));
   }
   auto observer = [&](const CpSolverResponse& response) {
     VLOG(1) << response;
@@ -117,6 +118,31 @@ TEST(ReservoirExpandTest, SimpleSemaphore) {
   EXPECT_EQ(187, solutions.size());
 }
 
+TEST(ReservoirExpandTest, SimpleSemaphoreWithEnforcementLiteral) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: 0 domain: 10 }
+    variables { domain: 0 domain: 10 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    constraints {
+      enforcement_literal: 3
+      reservoir {
+        max_level: 2
+        time_exprs { vars: 0 coeffs: 1 }
+        time_exprs { vars: 1 coeffs: 1 }
+        active_literals: [ 2, 2 ]
+        level_changes { offset: -1 }
+        level_changes { offset: 1 }
+      }
+    }
+  )pb");
+  absl::btree_set<std::vector<int>> solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "", &solutions);
+  EXPECT_EQ(OPTIMAL, response.status());
+  EXPECT_EQ(187 + 11 * 11 * 2, solutions.size());
+}
+
 TEST(ReservoirExpandTest, GizaReport) {
   const CpModelProto initial_model = ParseTestProto(R"pb(
     variables { domain: 0 domain: 10 }
@@ -229,7 +255,7 @@ TEST(ReservoirExpandTest, RepeatedTimesWithDifferentActivationVariables) {
   )pb");
   absl::btree_set<std::vector<int>> solutions;
   const CpSolverResponse response =
-      SolveAndCheck(initial_model, "", &solutions);
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &solutions);
   EXPECT_EQ(OPTIMAL, response.status());
   // First two time variables should be unconstrained giving us 3x3 solutions.
   EXPECT_EQ(9, solutions.size());
@@ -317,7 +343,7 @@ TEST(ReservoirExpandTest, OneUnschedulableOptionalAndInitiallyFeasible) {
   )pb");
   absl::btree_set<std::vector<int>> solutions;
   const CpSolverResponse response =
-      SolveAndCheck(initial_model, "", &solutions);
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &solutions);
   EXPECT_EQ(OPTIMAL, response.status());
   EXPECT_EQ(3, solutions.size());
 }
@@ -412,12 +438,78 @@ TEST(ReservoirExpandTest, ExpandReservoirUsingCircuitPreservesSolutionHint) {
     }
   )pb");
 
-  SatParameters params;
-  params.set_expand_reservoir_using_circuit(true);
-  params.set_log_search_progress(true);
-  params.set_debug_crash_if_presolve_breaks_hint(true);
-  CpSolverResponse response = SolveWithParameters(initial_model, params);
-  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  absl::btree_set<std::vector<int>> solutions;
+  const CpSolverResponse response = SolveAndCheck(
+      initial_model, "expand_reservoir_using_circuit:true", &solutions);
+  EXPECT_EQ(OPTIMAL, response.status());
+}
+
+TEST(ReservoirExpandTest, ExpandReservoirUsingCircuitWithEnforcementLiteral) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 2
+      reservoir {
+        max_level: 2
+        time_exprs { offset: 1 }
+        time_exprs { offset: 1 }
+        time_exprs { offset: 1 }
+        time_exprs { offset: 2 }
+        time_exprs { offset: 3 }
+        level_changes: { offset: -1 }
+        level_changes: { offset: -1 }
+        level_changes: { offset: 2 }
+        level_changes: { offset: -2 }
+        level_changes: { offset: 1 }
+        active_literals: 0
+        active_literals: 0
+        active_literals: 0
+        active_literals: 1
+        active_literals: 0
+      }
+    }
+    solution_hint {
+      vars: [ 0, 1, 2 ]
+      values: [ 1, 0, 1 ]
+    }
+  )pb");
+  absl::btree_set<std::vector<int>> solutions;
+  const CpSolverResponse response = SolveAndCheck(
+      initial_model, "expand_reservoir_using_circuit:true", &solutions);
+  EXPECT_EQ(OPTIMAL, response.status());
+  EXPECT_EQ(2 + 2 * 2, solutions.size());
+}
+
+TEST(ReservoirExpandTest, ExpandReservoirUsingSumWithEnforcementLiteral) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 2
+      reservoir {
+        max_level: 2
+        time_exprs { offset: 1 }
+        time_exprs { offset: 1 }
+        time_exprs { offset: 2 }
+        time_exprs { offset: 2 }
+        level_changes: { offset: 1 }
+        level_changes: { offset: 2 }
+        level_changes: { offset: 1 }
+        level_changes: { offset: 2 }
+        active_literals: [ 0, -1, 1, -2 ]
+      }
+    }
+  )pb");
+  absl::btree_set<std::vector<int>> solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &solutions);
+  EXPECT_EQ(OPTIMAL, response.status());
+  // There is a single solution when the constraint is enforced. Otherwise the
+  // all the variable values are possible.
+  EXPECT_EQ(1 + 2 * 2, solutions.size());
 }
 
 TEST(IntModExpandTest, FzTest) {
@@ -778,6 +870,159 @@ TEST(IntProdExpansionTest, ExpandNonBinaryIntProdPreservesSolutionHint) {
   EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
 }
 
+TEST(ElementExpandTest, InfeasibleFixedIndex) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 4, 4 ] }
+    variables { domain: [ 0, 7 ] }
+    constraints {
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { offset: 4 }
+        exprs { offset: 2 }
+        exprs { offset: 3 }
+        exprs { offset: 2 }
+      }
+    }
+  )pb");
+
+  EXPECT_EQ(SolveAndCheck(initial_model, "cp_model_presolve:false").status(),
+            CpSolverStatus::INFEASIBLE);
+}
+
+TEST(ElementExpandTest, FixedIndex) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 2, 2 ] }
+    variables { domain: [ 0, 7 ] }
+    constraints {
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { offset: 4 }
+        exprs { offset: 2 }
+        exprs { offset: 3 }
+        exprs { offset: 2 }
+      }
+    }
+  )pb");
+
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &found_solutions);
+  absl::btree_set<std::vector<int>> expected{{2, 3}};
+  EXPECT_EQ(found_solutions, expected);
+}
+
+TEST(ElementExpandTest, InfeasibleFixedIndexWithEnforcementLiteral) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 4, 5 ] }
+    variables { domain: [ 0, 7 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 2
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { offset: 4 }
+        exprs { offset: 2 }
+        exprs { offset: 3 }
+        exprs { offset: 2 }
+      }
+    }
+  )pb");
+
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &found_solutions);
+  absl::btree_set<std::vector<int>> expected;
+  for (int index = 4; index <= 5; ++index) {
+    for (int target = 0; target <= 7; ++target) {
+      expected.insert({index, target, 0});
+    }
+  }
+  EXPECT_EQ(found_solutions, expected);
+}
+
+TEST(ElementExpandTest, FixedIndexWithEnforcementLiteral) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 3, 5 ] }
+    variables { domain: [ 0, 7 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 2
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { offset: 4 }
+        exprs { offset: 2 }
+        exprs { offset: 3 }
+        exprs { offset: 2 }
+      }
+    }
+  )pb");
+
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &found_solutions);
+  absl::btree_set<std::vector<int>> expected{{3, 2, 1}};
+  for (int index = 3; index <= 5; ++index) {
+    for (int target = 0; target <= 7; ++target) {
+      expected.insert({index, target, 0});
+    }
+  }
+  EXPECT_EQ(found_solutions, expected);
+}
+
+TEST(ElementExpandTest, SharedVariable) {
+  // 2i+1 = {3, 5, 4, 2}[i-1]
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 7 ] }
+    constraints {
+      element {
+        linear_index { vars: 0 coeffs: 1 offset: -1 }
+        linear_target { vars: 0 coeffs: 2 offset: 1 }
+        exprs { offset: 3 }
+        exprs { offset: 5 }
+        exprs { offset: 4 }
+        exprs { offset: 2 }
+      }
+    }
+  )pb");
+
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &found_solutions);
+  absl::btree_set<std::vector<int>> expected{{1}, {2}};
+  EXPECT_EQ(found_solutions, expected);
+}
+
+TEST(ElementExpandTest, SharedVariableWithEnforcementLiteral) {
+  // 2i+1 = {3, 5, 4, 2}[i-1]
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 7 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 1
+      element {
+        linear_index { vars: 0 coeffs: 1 offset: -1 }
+        linear_target { vars: 0 coeffs: 2 offset: 1 }
+        exprs { offset: 3 }
+        exprs { offset: 5 }
+        exprs { offset: 4 }
+        exprs { offset: 2 }
+      }
+    }
+  )pb");
+
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &found_solutions);
+  absl::btree_set<std::vector<int>> expected{{0, 0}, {1, 0}, {2, 0}, {3, 0},
+                                             {4, 0}, {5, 0}, {6, 0}, {7, 0},
+                                             {1, 1}, {2, 1}};
+  EXPECT_EQ(found_solutions, expected);
+}
+
 TEST(ElementExpandTest, ConstantArray) {
   CpModelProto initial_model = ParseTestProto(R"pb(
     variables { domain: [ -1, 5 ] }
@@ -805,6 +1050,38 @@ TEST(ElementExpandTest, ConstantArray) {
   EXPECT_EQ(found_solutions, expected);
 }
 
+TEST(ElementExpandTest, ConstantArrayWithEnforcementLiteral) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ -1, 5 ] }
+    variables { domain: [ 0, 7 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 2
+      element {
+        linear_index { vars: 0 coeffs: 1 }
+        linear_target { vars: 1 coeffs: 1 }
+        exprs { offset: 1 }
+        exprs { offset: 3 }
+        exprs { offset: 4 }
+        exprs { offset: 5 }
+        exprs { offset: 1 }
+      }
+    }
+  )pb");
+
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "", &found_solutions);
+  absl::btree_set<std::vector<int>> expected{
+      {0, 1, 1}, {1, 3, 1}, {2, 4, 1}, {3, 5, 1}, {4, 1, 1}};
+  for (int index = -1; index <= 5; ++index) {
+    for (int target = 0; target <= 7; ++target) {
+      expected.insert({index, target, 0});
+    }
+  }
+  EXPECT_EQ(found_solutions, expected);
+}
+
 TEST(AutomatonExpandTest, NonogramRule) {
   // Accept sequences with 3 '1', then 2 '1', then 1 '1', separated by at least
   // one '0'.
@@ -875,6 +1152,44 @@ TEST(AutomatonExpandTest, Bug1753_1) {
   EXPECT_EQ(found_solutions, expected);
 }
 
+TEST(AutomatonExpandTest, Bug1753WithEnforcementLiteral_1) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { name: "0" domain: 0 domain: 2 }
+    variables { name: "1" domain: 0 domain: 2 }
+    variables { name: "2" domain: 0 domain: 2 }
+    variables { name: "3" domain: 0 domain: 1 }
+    constraints {
+      enforcement_literal: 3
+      automaton {
+        starting_state: 1
+        final_states: 1
+        final_states: 2
+        transition_tail: 1
+        transition_tail: 2
+        transition_head: 2
+        transition_head: 1
+        transition_label: 1
+        transition_label: 2
+        exprs { vars: 0 coeffs: 1 }
+        exprs { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 }
+      }
+    }
+  )pb");
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "", &found_solutions);
+  absl::btree_set<std::vector<int>> expected{{1, 2, 1, 1}};
+  for (int i = 0; i <= 2; ++i) {
+    for (int j = 0; j <= 2; ++j) {
+      for (int k = 0; k <= 2; ++k) {
+        expected.insert({i, j, k, 0});
+      }
+    }
+  }
+  EXPECT_EQ(found_solutions, expected);
+}
+
 TEST(AutomatonExpandTest, Bug1753_2) {
   CpModelProto initial_model = ParseTestProto(R"pb(
     variables { name: "0" domain: 0 domain: 2 }
@@ -921,6 +1236,59 @@ TEST(AutomatonExpandTest, Bug1753_2) {
   EXPECT_EQ(found_solutions, expected);
 }
 
+TEST(AutomatonExpandTest, Bug1753WithEnforcementLiteral_2) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { name: "0" domain: 0 domain: 2 }
+    variables { name: "1" domain: 0 domain: 2 }
+    variables { name: "2" domain: 0 domain: 2 }
+    variables { name: "3" domain: 0 domain: 1 }
+    constraints { linear { vars: 2 coeffs: 1 domain: 1 domain: 1 } }
+    constraints {
+      enforcement_literal: 3
+      automaton {
+        starting_state: 1
+        final_states: 1
+        final_states: 2
+        transition_tail: 1
+        transition_tail: 0
+        transition_tail: 1
+        transition_tail: 2
+        transition_tail: 0
+        transition_tail: 2
+        transition_head: 2
+        transition_head: 2
+        transition_head: 1
+        transition_head: 1
+        transition_head: 1
+        transition_head: 2
+        transition_label: 1
+        transition_label: 1
+        transition_label: 0
+        transition_label: 2
+        transition_label: 2
+        transition_label: 0
+        vars: 0
+        vars: 1
+        vars: 2
+      }
+    }
+    solution_hint {
+      vars: [ 0, 1, 2, 3 ]
+      values: [ 0, 0, 1, 1 ]
+    }
+  )pb");
+  absl::btree_set<std::vector<int>> found_solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "", &found_solutions);
+  absl::btree_set<std::vector<int>> expected{{0, 0, 1, 1}, {1, 2, 1, 1}};
+  for (int i = 0; i <= 2; ++i) {
+    for (int j = 0; j <= 2; ++j) {
+      expected.insert({i, j, 1, 0});
+    }
+  }
+  EXPECT_EQ(found_solutions, expected);
+}
+
 TEST(AutomatonExpandTest, EverythingZero) {
   CpModelProto initial_model = ParseTestProto(R"pb(
     variables { domain: [ 0, 1 ] }
@@ -961,6 +1329,62 @@ TEST(AutomatonExpandTest, EverythingZero) {
   EXPECT_THAT(initial_model, testing::EqualsProto(expected_model));
 }
 
+TEST(AutomatonExpandTest, EverythingZeroWithEnforcementLiteral) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 0
+      automaton {
+        starting_state: 1,
+        final_states: [ 1 ],
+        transition_tail: 1,
+        transition_head: 1,
+        transition_label: 0,
+        exprs { vars: 0 coeffs: 1 }
+        exprs { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 }
+      }
+    }
+  )pb");
+  Model model;
+  PresolveContext context(&model, &initial_model, nullptr);
+  ExpandCpModel(&context);
+
+  const CpModelProto expected_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {}
+    constraints {
+      enforcement_literal: 0
+      linear {
+        vars: 0
+        coeffs: 1
+        domain: [ 0, 0 ]
+      }
+    }
+    constraints {
+      enforcement_literal: 0
+      linear {
+        vars: 1
+        coeffs: 1
+        domain: [ 0, 0 ]
+      }
+    }
+    constraints {
+      enforcement_literal: 0
+      linear {
+        vars: 2
+        coeffs: 1
+        domain: [ 0, 0 ]
+      }
+    }
+  )pb");
+  EXPECT_THAT(initial_model, testing::EqualsProto(expected_model));
+}
+
 TEST(AutomatonExpandTest, LoopingAutomatonMultipleFinalStates) {
   // These tuples accept "0*(12)+0*".
   CpModelProto initial_model = ParseTestProto(R"pb(
@@ -1520,12 +1944,74 @@ TEST(ExpandAllDiffTest, Permutation) {
 
   absl::btree_set<std::vector<int>> found_solutions;
   const CpSolverResponse response =
-      SolveAndCheck(initial_model, "presolve_cp_model:false", &found_solutions);
+      SolveAndCheck(initial_model, "cp_model_presolve:false", &found_solutions);
   absl::btree_set<std::vector<int>> expected{
       {0, 2, 1}, {2, 0, 1}, {1, 2, 0}, {2, 1, 0}};
   EXPECT_EQ(found_solutions, expected);
 }
 
+TEST(ExpandAllDiffTest, GoldenTestWithEnforcementLiteral) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: -1
+      all_diff {
+        exprs { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 offset: 1 }
+        exprs { vars: 3 coeffs: -1 offset: 3 }
+      }
+    })pb");
+  Model model;
+  PresolveContext context(&model, &initial_model, nullptr);
+  context.InitializeNewDomains();
+  context.UpdateNewConstraintsVariableUsage();
+  ExpandCpModel(&context);
+
+  const CpModelProto expected_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {}
+    constraints {
+      enforcement_literal: -1
+      linear {
+        vars: 1
+        coeffs: -1
+        domain: [ -1, 0 ]
+      }
+    }
+    constraints {
+      enforcement_literal: -1
+      linear {
+        vars: [ 1, 2 ]
+        coeffs: [ 1, -1 ]
+        domain: [ -1, 0 ]
+      }
+    }
+    constraints {
+      enforcement_literal: -1
+      linear {
+        vars: [ 2, 3 ]
+        coeffs: [ 1, 1 ]
+        domain: [ 0, 1 ]
+      }
+    }
+    constraints {
+      enforcement_literal: -1
+      linear {
+        vars: 3
+        coeffs: -1
+        domain: [ -1, 0 ]
+      }
+    }
+  )pb");
+  EXPECT_THAT(initial_model, testing::EqualsProto(expected_model));
+}
+
 TEST(ExpandInverseTest, CountInvolution) {
   const CpModelProto initial_model = ParseTestProto(R"pb(
     variables { domain: [ 0, 10 ] }
@@ -1547,6 +2033,30 @@ TEST(ExpandInverseTest, CountInvolution) {
   EXPECT_EQ(4, solutions.size());
 }
 
+TEST(ExpandInverseTest, CountInvolutionWithEnforcementLiteral) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 9 ] }
+    variables { domain: [ 0, 9 ] }
+    variables { domain: [ 0, 9 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 3
+      inverse {
+        f_direct: [ 0, 1, 2 ]
+        f_inverse: [ 0, 1, 2 ]
+      }
+    }
+  )pb");
+  absl::btree_set<std::vector<int>> solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "", &solutions);
+  EXPECT_EQ(OPTIMAL, response.status());
+
+  // On 3 elements, we either have the identity or one of the 3 two cycle (when
+  // the constraint is enforced; otherwise all 10^3 combinations are valid).
+  EXPECT_EQ(1004, solutions.size());
+}
+
 TEST(ExpandInverseTest, DuplicateAtDifferentPosition) {
   const CpModelProto initial_model = ParseTestProto(R"pb(
     variables { domain: [ 0, 10 ] }
@@ -1939,6 +2449,62 @@ TEST(LinMaxExpansionTest, GoldenTest) {
   EXPECT_THAT(initial_model, testing::EqualsProto(expected_model));
 }
 
+TEST(LinMaxExpansionTest, GoldenTestWithEnforcementLiterals) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 5 ] }
+    variables { domain: [ 0, 5 ] }
+    variables { domain: [ 0, 6 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 3
+      lin_max {
+        target { vars: 0 coeffs: 1 offset: 1 }
+        exprs { vars: 1 coeffs: 2 }
+        exprs: { vars: 2 coeffs: 1 offset: -3 }
+      }
+    }
+  )pb");
+  Model model;
+  model.GetOrCreate<SatParameters>()->set_max_lin_max_size_for_expansion(4);
+  PresolveContext context(&model, &initial_model, nullptr);
+  ExpandCpModel(&context);
+
+  const CpModelProto expected_model = ParseTestProto(R"pb(
+    variables { domain: 0 domain: 5 }
+    variables { domain: 0 domain: 5 }
+    variables { domain: 0 domain: 6 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    constraints {}
+    constraints {
+      enforcement_literal: 3
+      linear { vars: 0 vars: 1 coeffs: 1 coeffs: -2 domain: -1 domain: 5 }
+    }
+    constraints {
+      enforcement_literal: 3
+      linear { vars: 0 vars: 2 coeffs: 1 coeffs: -1 domain: -4 domain: 5 }
+    }
+    constraints {
+      enforcement_literal: 3
+      linear {
+        vars: [ 4, 5 ]
+        coeffs: [ 1, 1 ]
+        domain: [ 1, 1 ]
+      }
+    }
+    constraints {
+      enforcement_literal: 4
+      linear { vars: 0 vars: 1 coeffs: 1 coeffs: -2 domain: -10 domain: -1 }
+    }
+    constraints {
+      enforcement_literal: 5
+      linear { vars: 0 vars: 2 coeffs: 1 coeffs: -1 domain: -6 domain: -4 }
+    }
+  )pb");
+  EXPECT_THAT(initial_model, testing::EqualsProto(expected_model));
+}
+
 TEST(LinMaxExpansionTest, ExpandLinMaxPreservesSolutionHint) {
   CpModelProto initial_model = ParseTestProto(R"pb(
     variables { domain: [ 1, 4 ] }
diff --git a/ortools/sat/cp_model_loader.cc b/ortools/sat/cp_model_loader.cc
index fcecb82670..7fe304f98a 100644
--- a/ortools/sat/cp_model_loader.cc
+++ b/ortools/sat/cp_model_loader.cc
@@ -1512,9 +1512,11 @@ void LoadLinearConstraint(const ConstraintProto& ct, Model* m) {
 
 void LoadAllDiffConstraint(const ConstraintProto& ct, Model* m) {
   auto* mapping = m->GetOrCreate<CpModelMapping>();
+  const std::vector<Literal> enforcement_literals =
+      mapping->Literals(ct.enforcement_literal());
   const std::vector<AffineExpression> expressions =
       mapping->Affines(ct.all_diff().exprs());
-  m->Add(AllDifferentOnBounds(expressions));
+  m->Add(AllDifferentOnBounds(enforcement_literals, expressions));
 }
 
 void LoadAlwaysFalseConstraint(const ConstraintProto& ct, Model* m) {
@@ -1545,11 +1547,16 @@ void LoadIntProdConstraint(const ConstraintProto& ct, Model* m) {
         if (prod.constant.value() != 1) {
           LoadAlwaysFalseConstraint(ct, m);
         }
-      } else {
+      } else if (enforcement_literals.empty()) {
         if (!integer_trail->Enqueue(prod.LowerOrEqual(1)) ||
             !integer_trail->Enqueue(prod.GreaterOrEqual(1))) {
-          LoadAlwaysFalseConstraint(ct, m);
+          m->GetOrCreate<SatSolver>()->NotifyThatModelIsUnsat();
         }
+      } else {
+        LinearConstraintBuilder builder(m, /*lb=*/1, /*ub=*/1);
+        builder.AddTerm(prod, 1);
+        LoadConditionalLinearConstraint(enforcement_literals, builder.Build(),
+                                        m);
       }
       break;
     }
@@ -1611,7 +1618,7 @@ void LoadIntModConstraint(const ConstraintProto& ct, Model* m) {
 
 void LoadLinMaxConstraint(const ConstraintProto& ct, Model* m) {
   if (ct.lin_max().exprs().empty()) {
-    m->GetOrCreate<SatSolver>()->NotifyThatModelIsUnsat();
+    LoadAlwaysFalseConstraint(ct, m);
     return;
   }
 
@@ -1624,37 +1631,46 @@ void LoadLinMaxConstraint(const ConstraintProto& ct, Model* m) {
         NegationOf(mapping->GetExprFromProto(ct.lin_max().exprs(i))));
   }
   // TODO(user): Consider replacing the min propagator by max.
-  m->Add(IsEqualToMinOf(NegationOf(max), negated_exprs));
+  AddIsEqualToMinOf(mapping->Literals(ct.enforcement_literal()),
+                    NegationOf(max), negated_exprs, m);
 }
 
 void LoadNoOverlapConstraint(const ConstraintProto& ct, Model* m) {
   auto* mapping = m->GetOrCreate<CpModelMapping>();
-  AddDisjunctive(mapping->Intervals(ct.no_overlap().intervals()), m);
+  AddDisjunctive(mapping->Literals(ct.enforcement_literal()),
+                 mapping->Intervals(ct.no_overlap().intervals()), m);
 }
 
 void LoadNoOverlap2dConstraint(const ConstraintProto& ct, Model* m) {
   if (ct.no_overlap_2d().x_intervals().empty()) return;
   auto* mapping = m->GetOrCreate<CpModelMapping>();
+  const std::vector<Literal> enforcement_literals =
+      mapping->Literals(ct.enforcement_literal());
   const std::vector<IntervalVariable> x_intervals =
       mapping->Intervals(ct.no_overlap_2d().x_intervals());
   const std::vector<IntervalVariable> y_intervals =
       mapping->Intervals(ct.no_overlap_2d().y_intervals());
-  AddNonOverlappingRectangles(x_intervals, y_intervals, m);
+  AddNonOverlappingRectangles(enforcement_literals, x_intervals, y_intervals,
+                              m);
 }
 
 void LoadCumulativeConstraint(const ConstraintProto& ct, Model* m) {
   auto* mapping = m->GetOrCreate<CpModelMapping>();
+  const std::vector<Literal> enforcement_literals =
+      mapping->Literals(ct.enforcement_literal());
   const std::vector<IntervalVariable> intervals =
       mapping->Intervals(ct.cumulative().intervals());
   const AffineExpression capacity = mapping->Affine(ct.cumulative().capacity());
   const std::vector<AffineExpression> demands =
       mapping->Affines(ct.cumulative().demands());
-  m->Add(Cumulative(intervals, demands, capacity));
+  m->Add(Cumulative(enforcement_literals, intervals, demands, capacity));
 }
 
 void LoadReservoirConstraint(const ConstraintProto& ct, Model* m) {
   auto* mapping = m->GetOrCreate<CpModelMapping>();
   auto* encoder = m->GetOrCreate<IntegerEncoder>();
+  const std::vector<Literal> enforcement_literals =
+      mapping->Literals(ct.enforcement_literal());
   const std::vector<AffineExpression> times =
       mapping->Affines(ct.reservoir().time_exprs());
   const std::vector<AffineExpression> level_changes =
@@ -1668,7 +1684,7 @@ void LoadReservoirConstraint(const ConstraintProto& ct, Model* m) {
       presences.push_back(encoder->GetTrueLiteral());
     }
   }
-  AddReservoirConstraint(times, level_changes, presences,
+  AddReservoirConstraint(enforcement_literals, times, level_changes, presences,
                          ct.reservoir().min_level(), ct.reservoir().max_level(),
                          m);
 }
@@ -1679,10 +1695,13 @@ void LoadCircuitConstraint(const ConstraintProto& ct, Model* m) {
 
   std::vector<int> tails(circuit.tails().begin(), circuit.tails().end());
   std::vector<int> heads(circuit.heads().begin(), circuit.heads().end());
-  std::vector<Literal> literals =
-      m->GetOrCreate<CpModelMapping>()->Literals(circuit.literals());
+  auto* mapping = m->GetOrCreate<CpModelMapping>();
+  const std::vector<Literal> enforcement_literals =
+      mapping->Literals(ct.enforcement_literal());
+  const std::vector<Literal> literals = mapping->Literals(circuit.literals());
   const int num_nodes = ReindexArcs(&tails, &heads);
-  LoadSubcircuitConstraint(num_nodes, tails, heads, literals, m);
+  LoadSubcircuitConstraint(num_nodes, tails, heads, enforcement_literals,
+                           literals, m);
 }
 
 void LoadRoutesConstraint(const ConstraintProto& ct, Model* m) {
@@ -1691,10 +1710,13 @@ void LoadRoutesConstraint(const ConstraintProto& ct, Model* m) {
 
   std::vector<int> tails(routes.tails().begin(), routes.tails().end());
   std::vector<int> heads(routes.heads().begin(), routes.heads().end());
-  std::vector<Literal> literals =
-      m->GetOrCreate<CpModelMapping>()->Literals(routes.literals());
+  auto* mapping = m->GetOrCreate<CpModelMapping>();
+  const std::vector<Literal> enforcement_literals =
+      mapping->Literals(ct.enforcement_literal());
+  std::vector<Literal> literals = mapping->Literals(routes.literals());
   const int num_nodes = ReindexArcs(&tails, &heads);
-  LoadSubcircuitConstraint(num_nodes, tails, heads, literals, m,
+  LoadSubcircuitConstraint(num_nodes, tails, heads, enforcement_literals,
+                           literals, m,
                            /*multiple_subcircuit_through_zero=*/true);
 }
 
diff --git a/ortools/sat/cp_model_presolve.cc b/ortools/sat/cp_model_presolve.cc
index b5bd658cac..b157dd8433 100644
--- a/ortools/sat/cp_model_presolve.cc
+++ b/ortools/sat/cp_model_presolve.cc
@@ -318,10 +318,10 @@ bool CpModelPresolver::PresolveBoolXor(ConstraintProto* ct) {
           return false;
         }
       }
-    }
-    context_->UpdateNewConstraintsVariableUsage();
-    context_->UpdateRuleStats("bool_xor: two active literals");
-    return RemoveConstraint(ct);
+      context_->UpdateNewConstraintsVariableUsage();
+      context_->UpdateRuleStats("bool_xor: two active literals");
+      return RemoveConstraint(ct);
+    }  // TODO(user): maybe replace the enforced XOR by an enforced equality?
   }
 
   if (num_true_literals % 2 == 1) {
@@ -1086,6 +1086,7 @@ bool CpModelPresolver::PropagateAndReduceLinMax(ConstraintProto* ct) {
 
 bool CpModelPresolver::PresolveLinMax(int c, ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for this case.
   if (HasEnforcementLiteral(*ct)) return false;
   const LinearExpressionProto& target = ct->lin_max().target();
 
@@ -1655,11 +1656,18 @@ bool CpModelPresolver::PresolveIntProd(ConstraintProto* ct) {
         return false;
       }
       context_->UpdateRuleStats("int_prod: constant product");
-      return RemoveConstraint(ct);
     } else {
-      context_->UpdateRuleStats("TODO enforced int_prod: constant product");
       // Replace ct with an enforced linear "target == constant_factor".
+      ConstraintProto* new_ct = context_->working_model->add_constraints();
+      *new_ct->mutable_enforcement_literal() = ct->enforcement_literal();
+      LinearConstraintProto* const lin = new_ct->mutable_linear();
+      lin->add_domain(constant_factor);
+      lin->add_domain(constant_factor);
+      AddLinearExpressionToLinearConstraint(ct->int_prod().target(), 1, lin);
+      context_->UpdateNewConstraintsVariableUsage();
+      context_->UpdateRuleStats("enforced int_prod: constant product");
     }
+    return RemoveConstraint(ct);
   }
 
   // If target is fixed to zero, we can forget the constant factor.
@@ -3176,7 +3184,7 @@ bool CpModelPresolver::PresolveDiophantine(ConstraintProto* ct) {
   // TODO(user): Make sure the newly generated linear constraint
   // satisfy our no-overflow precondition on the min/max activity.
   // We should check that the model still satisfy conditions in
-  // 3/ortools/sat/cp_model_checker.cc;l=165;bpv=0
+  // https://source.corp.google.com/piper///depot/ortools/sat/cp_model_checker.cc;l=165;bpv=0
 
   // Create new variables.
   std::vector<int> new_variables(num_new_variables);
@@ -5018,6 +5026,8 @@ bool CpModelPresolver::PresolveInterval(int c, ConstraintProto* ct) {
 
 // TODO(user): avoid code duplication between expand and presolve.
 bool CpModelPresolver::PresolveInverse(ConstraintProto* ct) {
+  // TODO(user): add support for this case.
+  if (HasEnforcementLiteral(*ct)) return false;
   const int size = ct->inverse().f_direct().size();
   bool changed = false;
 
@@ -5119,8 +5129,7 @@ bool CpModelPresolver::PresolveElement(int c, ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
 
   if (ct->element().exprs().empty()) {
-    context_->UpdateRuleStats("element: empty array");
-    return context_->NotifyThatModelIsUnsat();
+    return MarkConstraintAsFalse(ct, "element: empty array");
   }
 
   bool changed = false;
@@ -5136,8 +5145,8 @@ bool CpModelPresolver::PresolveElement(int c, ConstraintProto* ct) {
   const LinearExpressionProto& index = ct->element().linear_index();
   const LinearExpressionProto& target = ct->element().linear_target();
 
-  // TODO(user): think about this once we do have such constraint.
-  if (HasEnforcementLiteral(*ct)) return false;
+  // TODO(user): add support for this case.
+  if (HasEnforcementLiteral(*ct)) return changed;
 
   // Reduce index domain from the array size.
   {
@@ -5607,6 +5616,7 @@ class UniqueNonNegativeValue {
 
 bool CpModelPresolver::PresolveAllDiff(ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for this case.
   if (HasEnforcementLiteral(*ct)) return false;
 
   AllDifferentConstraintProto& all_diff = *ct->mutable_all_diff();
@@ -5812,7 +5822,7 @@ void ExtractClauses(bool merge_into_bool_and,
     // bool_or.
     ConstraintProto* ct = proto->add_constraints();
     if (!debug_name.empty()) {
-      ct->set_name(std::string(debug_name));
+      ct->set_name(debug_name);
     }
     ct->mutable_bool_or()->mutable_literals()->Reserve(clause.size());
     for (const Literal l : clause) {
@@ -5830,6 +5840,8 @@ void ExtractClauses(bool merge_into_bool_and,
 
 bool CpModelPresolver::PresolveNoOverlap(ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for enforcement literals.
+  if (HasEnforcementLiteral(*ct)) return false;
   NoOverlapConstraintProto* proto = ct->mutable_no_overlap();
   bool changed = false;
 
@@ -6366,6 +6378,8 @@ bool CpModelPresolver::PresolveNoOverlap2D(int /*c*/, ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) {
     return false;
   }
+  // TODO(user): add support for enforcement literals.
+  if (HasEnforcementLiteral(*ct)) return false;
 
   const NoOverlap2DConstraintProto& proto = ct->no_overlap_2d();
   const int initial_num_boxes = proto.x_intervals_size();
@@ -6405,6 +6419,21 @@ bool CpModelPresolver::PresolveNoOverlap2D(int /*c*/, ConstraintProto* ct) {
               "no_overlap_2d: impossible interval.");
         }
       }
+
+      if (context_->SizeMin(interval_index) < 0) {
+        const ConstraintProto* interval_ct =
+            context_->working_model->mutable_constraints(interval_index);
+        if (interval_ct->enforcement_literal().empty()) {
+          bool domain_changed = false;
+          // Size can't be negative.
+          if (!context_->IntersectDomainWith(
+                  interval_ct->interval().size(),
+                  Domain(0, std::numeric_limits<int64_t>::max()),
+                  &domain_changed)) {
+            return false;
+          }
+        }
+      }
     }
 
     if (context_->ConstraintIsInactive(x_interval_index) ||
@@ -6646,6 +6675,8 @@ void CpModelPresolver::DetectDuplicateIntervals(
 
 bool CpModelPresolver::PresolveCumulative(ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for enforcement literals.
+  if (HasEnforcementLiteral(*ct)) return false;
 
   CumulativeConstraintProto* proto = ct->mutable_cumulative();
 
@@ -6724,7 +6755,7 @@ bool CpModelPresolver::PresolveCumulative(ConstraintProto* ct) {
       }
 
       const int interval_index = proto->intervals(i);
-      if (context_->SizeMax(interval_index) == 0) {
+      if (context_->SizeMax(interval_index) <= 0) {
         // Size 0 intervals cannot contribute to a cumulative.
         num_zero_size_removed++;
         continue;
@@ -7033,7 +7064,7 @@ bool CpModelPresolver::PresolveCumulative(ConstraintProto* ct) {
     if (context_->SizeMin(index) == 1 && context_->SizeMax(index) == 1) {
       num_duration_one++;
     }
-    if (context_->SizeMin(index) == 0) {
+    if (context_->SizeMin(index) <= 0) {
       // The behavior for zero-duration interval is currently not the same in
       // the no-overlap and the cumulative constraint.
       return changed;
@@ -7134,6 +7165,7 @@ bool CpModelPresolver::PresolveCumulative(ConstraintProto* ct) {
 
 bool CpModelPresolver::PresolveRoutes(ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for this case.
   if (HasEnforcementLiteral(*ct)) return false;
   RoutesConstraintProto& proto = *ct->mutable_routes();
 
@@ -7195,6 +7227,7 @@ bool CpModelPresolver::PresolveRoutes(ConstraintProto* ct) {
 
 bool CpModelPresolver::PresolveCircuit(ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for this case.
   if (HasEnforcementLiteral(*ct)) return false;
   CircuitConstraintProto& proto = *ct->mutable_circuit();
 
@@ -7394,6 +7427,7 @@ bool CpModelPresolver::PresolveCircuit(ConstraintProto* ct) {
 
 bool CpModelPresolver::PresolveAutomaton(ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for this case.
   if (HasEnforcementLiteral(*ct)) return false;
 
   AutomatonConstraintProto* proto = ct->mutable_automaton();
@@ -7439,6 +7473,7 @@ bool CpModelPresolver::PresolveAutomaton(ConstraintProto* ct) {
 
 bool CpModelPresolver::PresolveReservoir(ConstraintProto* ct) {
   if (context_->ModelIsUnsat()) return false;
+  // TODO(user): add support for this case.
   if (HasEnforcementLiteral(*ct)) return false;
 
   ReservoirConstraintProto& proto = *ct->mutable_reservoir();
@@ -8862,12 +8897,15 @@ void CpModelPresolver::MergeNoOverlapConstraints() {
   int old_num_no_overlaps = 0;
   int old_num_intervals = 0;
 
-  // Extract the no-overlap constraints.
+  // Extract the no-overlap constraints with no enforcement literals.
+  // TODO(user): generalize this to merge constraints with the same
+  // enforcement literals?
   std::vector<int> disjunctive_index;
   std::vector<std::vector<Literal>> cliques;
   for (int c = 0; c < num_constraints; ++c) {
     const ConstraintProto& ct = context_->working_model->constraints(c);
     if (ct.constraint_case() != ConstraintProto::kNoOverlap) continue;
+    if (HasEnforcementLiteral(ct)) continue;
     std::vector<Literal> clique;
     for (const int i : ct.no_overlap().intervals()) {
       clique.push_back(Literal(BooleanVariable(i), true));
diff --git a/ortools/sat/cp_model_search.cc b/ortools/sat/cp_model_search.cc
index f95d2c7c0e..9d8011422b 100644
--- a/ortools/sat/cp_model_search.cc
+++ b/ortools/sat/cp_model_search.cc
@@ -168,10 +168,18 @@ struct VarValue {
 namespace {
 
 // TODO(user): Save this somewhere instead of recomputing it.
-bool ModelHasSchedulingConstraints(const CpModelProto& cp_model_proto) {
+bool ModelHasSchedulingConstraints(const CpModelProto& cp_model_proto,
+                                   const SatParameters& params) {
+  const bool use_cumulative_relaxation_for_no_overlap_2d =
+      params.use_timetabling_in_no_overlap_2d() ||
+      params.use_energetic_reasoning_in_no_overlap_2d();
+
   for (const ConstraintProto& ct : cp_model_proto.constraints()) {
     if (ct.constraint_case() == ConstraintProto::kNoOverlap) return true;
     if (ct.constraint_case() == ConstraintProto::kCumulative) return true;
+    if (ct.constraint_case() == ConstraintProto::kNoOverlap2D &&
+        use_cumulative_relaxation_for_no_overlap_2d)
+      return true;
   }
   return false;
 }
@@ -189,6 +197,8 @@ void AddExtraSchedulingPropagators(SatParameters& new_params) {
   new_params.set_use_area_energetic_reasoning_in_no_overlap_2d(true);
   new_params.set_use_try_edge_reasoning_in_no_overlap_2d(true);
   new_params.set_no_overlap_2d_boolean_relations_limit(100);
+  new_params.set_use_dynamic_precedence_in_cumulative(true);
+  new_params.set_use_dynamic_precedence_in_disjunctive(true);
 }
 
 // We want a random tie breaking among variables with equivalent values.
@@ -354,9 +364,9 @@ std::function<BooleanOrIntegerLiteral()> ConstructUserSearchStrategy(
 // TODO(user): Implement a routing search.
 std::function<BooleanOrIntegerLiteral()> ConstructHeuristicSearchStrategy(
     const CpModelProto& cp_model_proto, Model* model) {
-  if (ModelHasSchedulingConstraints(cp_model_proto)) {
+  const auto& params = *model->GetOrCreate<SatParameters>();
+  if (ModelHasSchedulingConstraints(cp_model_proto, params)) {
     std::vector<std::function<BooleanOrIntegerLiteral()>> heuristics;
-    const auto& params = *model->GetOrCreate<SatParameters>();
     bool possible_new_constraints = false;
     if (params.use_dynamic_precedence_in_disjunctive()) {
       possible_new_constraints = true;
@@ -831,8 +841,9 @@ std::vector<SatParameters> GetFullWorkerParameters(
   // TODO(user): For scheduling, this is important to find good first solution
   // but afterwards it is not really great and should probably be replaced by a
   // LNS worker.
-  const bool use_fixed_strategy = !cp_model.search_strategy().empty() ||
-                                  ModelHasSchedulingConstraints(cp_model);
+  const bool use_fixed_strategy =
+      !cp_model.search_strategy().empty() ||
+      ModelHasSchedulingConstraints(cp_model, base_params);
 
   // Our current set of strategies
   //
diff --git a/ortools/sat/cp_model_solver.cc b/ortools/sat/cp_model_solver.cc
index 38db8b87a5..ea046c6487 100644
--- a/ortools/sat/cp_model_solver.cc
+++ b/ortools/sat/cp_model_solver.cc
@@ -53,6 +53,8 @@
 #include "ortools/base/logging.h"
 #include "ortools/base/options.h"
 #include "ortools/base/timer.h"
+#include "ortools/base/version.h"
+#include "ortools/port/os.h"
 #include "ortools/port/proto_utils.h"
 #include "ortools/sat/combine_solutions.h"
 #include "ortools/sat/cp_model.pb.h"
@@ -91,10 +93,7 @@
 #include "ortools/sat/work_assignment.h"
 #include "ortools/util/logging.h"
 #include "ortools/util/random_engine.h"
-#if !defined(__EMBEDDED_PLATFORM__)
 #include "ortools/util/sigint.h"
-#endif  // __EMBEDDED_PLATFORM__
-#include "ortools/base/version.h"
 #include "ortools/util/sorted_interval_list.h"
 #include "ortools/util/time_limit.h"
 
@@ -120,9 +119,6 @@ ABSL_FLAG(std::string, cp_model_params, "",
           "This is interpreted as a text SatParameters proto. The "
           "specified fields will override the normal ones for all solves.");
 
-ABSL_FLAG(bool, debug_model_copy, false,
-          "If true, copy the input model as if with no basic presolve");
-
 ABSL_FLAG(bool, cp_model_ignore_objective, false,
           "If true, ignore the objective.");
 ABSL_FLAG(bool, cp_model_ignore_hints, false,
@@ -305,12 +301,18 @@ std::string CpModelStats(const CpModelProto& model_proto) {
     // We split the linear constraints into 3 buckets has it gives more insight
     // on the type of problem we are facing.
     char const* name;
-    if (ct.constraint_case() == ConstraintProto::ConstraintCase::kLinear) {
+    if (ct.constraint_case() == ConstraintProto::kLinear) {
       if (ct.linear().vars_size() == 0) name = "kLinear0";
       if (ct.linear().vars_size() == 1) name = "kLinear1";
       if (ct.linear().vars_size() == 2) name = "kLinear2";
       if (ct.linear().vars_size() == 3) name = "kLinear3";
       if (ct.linear().vars_size() > 3) name = "kLinearN";
+    } else if (ct.constraint_case() == ConstraintProto::kBoolAnd &&
+               ct.enforcement_literal().size() > 1) {
+      // BoolAnd of the form "n literals => m literals" with n > 1 are just a
+      // compact way to encode m clauses of size n + 1. We report them
+      // separately as they are not handled in the same way internally.
+      name = "kBoolAndClauses";
     } else {
       name = ConstraintCaseName(ct.constraint_case()).data();
     }
@@ -1185,7 +1187,7 @@ class FullProblemSolver : public SubSolver {
   bool previous_task_is_completed_ ABSL_GUARDED_BY(mutex_) = true;
 };
 
-#if !defined(__EMBEDDED_PLATFORM__)
+#if ORTOOLS_TARGET_OS_SUPPORTS_THREADS
 
 class FeasibilityPumpSolver : public SubSolver {
  public:
@@ -1720,8 +1722,6 @@ class LnsSolver : public SubSolver {
 
 void SolveCpModelParallel(SharedClasses* shared, Model* global_model) {
   const SatParameters& params = *global_model->GetOrCreate<SatParameters>();
-  CHECK(!params.enumerate_all_solutions())
-      << "Enumerating all solutions in parallel is not supported.";
   if (global_model->GetOrCreate<TimeLimit>()->LimitReached()) return;
 
   // If specified by the user, we might disable some parameters based on their
@@ -2191,7 +2191,7 @@ void SolveCpModelParallel(SharedClasses* shared, Model* global_model) {
   LaunchSubsolvers(params, shared, subsolvers, name_filter.AllIgnored());
 }
 
-#endif  // !defined(__EMBEDDED_PLATFORM__)
+#endif  // ORTOOLS_TARGET_OS_SUPPORTS_THREADS
 
 // If the option use_sat_inprocessing is true, then before post-solving a
 // solution, we need to make sure we add any new clause required for postsolving
@@ -2439,13 +2439,13 @@ CpSolverResponse SolveCpModel(const CpModelProto& model_proto, Model* model) {
   // Initialize the time limit from the parameters.
   model->GetOrCreate<TimeLimit>()->ResetLimitFromParameters(params);
 
-#if !defined(__EMBEDDED_PLATFORM__)
+#if ORTOOLS_TARGET_OS_SUPPORTS_THREADS
   // Register SIGINT handler if requested by the parameters.
   if (params.catch_sigint_signal()) {
     model->GetOrCreate<SigintHandler>()->Register(
         [shared_time_limit]() { shared_time_limit->Stop(); });
   }
-#endif  // __EMBEDDED_PLATFORM__
+#endif  // ORTOOLS_TARGET_OS_SUPPORTS_THREADS
 
   SOLVER_LOG(logger, "");
   SOLVER_LOG(logger, "Starting ", CpSatSolverVersion());
@@ -2493,10 +2493,7 @@ CpSolverResponse SolveCpModel(const CpModelProto& model_proto, Model* model) {
   auto context = std::make_unique<PresolveContext>(model, new_cp_model_proto,
                                                    mapping_proto);
 
-  if (absl::GetFlag(FLAGS_debug_model_copy)) {
-    *new_cp_model_proto = model_proto;
-  } else if (!ImportModelWithBasicPresolveIntoContext(model_proto,
-                                                      context.get())) {
+  if (!ImportModelWithBasicPresolveIntoContext(model_proto, context.get())) {
     const std::string info = "Problem proven infeasible during initial copy.";
     SOLVER_LOG(logger, info);
     CpSolverResponse status_response;
@@ -2940,15 +2937,15 @@ CpSolverResponse SolveCpModel(const CpModelProto& model_proto, Model* model) {
   LoadDebugSolution(*new_cp_model_proto, model);
 
   if (!model->GetOrCreate<TimeLimit>()->LimitReached()) {
-#if defined(__EMBEDDED_PLATFORM__)
-    if (/* DISABLES CODE */ (false)) {
-      // We ignore the multithreading parameter in this case.
-#else   // __EMBEDDED_PLATFORM__
+#if ORTOOLS_TARGET_OS_SUPPORTS_THREADS
     if (params.num_workers() > 1 || params.interleave_search() ||
         !params.subsolvers().empty() || !params.filter_subsolvers().empty() ||
         params.use_ls_only()) {
       SolveCpModelParallel(&shared, model);
-#endif  // __EMBEDDED_PLATFORM__
+#else   // ORTOOLS_TARGET_OS_SUPPORTS_THREADS
+    if (/* DISABLES CODE */ (false)) {
+      // We ignore the multithreading parameter in this case.
+#endif  // ORTOOLS_TARGET_OS_SUPPORTS_THREADS
     } else {
       shared_response_manager->SetUpdateGapIntegralOnEachChange(true);
 
diff --git a/ortools/sat/cp_model_solver_helpers.cc b/ortools/sat/cp_model_solver_helpers.cc
index 9d6a72423f..1e8f696ffc 100644
--- a/ortools/sat/cp_model_solver_helpers.cc
+++ b/ortools/sat/cp_model_solver_helpers.cc
@@ -2047,22 +2047,24 @@ void AdaptGlobalParameters(const CpModelProto& model_proto, Model* model) {
   }
 
   if (params->enumerate_all_solutions()) {
-    if (params->num_workers() >= 1) {
+    if (params->num_workers() == 0) {
       SOLVER_LOG(logger,
-                 "Forcing sequential search as enumerating all solutions is "
-                 "not supported in multi-thread.");
+                 "Setting num_workers to 1 since it is not specified and "
+                 "enumerate_all_solutions is true.");
+      params->set_num_workers(1);
+    } else if (params->num_workers() > 1) {
+      SOLVER_LOG(
+          logger,
+          "WARNING: enumerating all solutions in multi-thread works but might "
+          "lead to the same solution being found up to num_workers times.");
     }
-    params->set_num_workers(1);
 
-    // TODO(user): This was the old behavior, but consider switching this to
-    // just a warning? it might be a valid usage to enumerate all solution of
-    // a presolved model.
-    if (!params->keep_all_feasible_solutions_in_presolve()) {
+    if (!params->has_keep_all_feasible_solutions_in_presolve()) {
       SOLVER_LOG(logger,
                  "Forcing presolve to keep all feasible solution given that "
-                 "enumerate_all_solutions is true");
+                 "enumerate_all_solutions is true and that option is unset.");
+      params->set_keep_all_feasible_solutions_in_presolve(true);
     }
-    params->set_keep_all_feasible_solutions_in_presolve(true);
   }
 
   if (!model_proto.assumptions().empty()) {
@@ -2094,17 +2096,17 @@ void AdaptGlobalParameters(const CpModelProto& model_proto, Model* model) {
 
   if (params->shared_tree_num_workers() == -1) {
     int num_shared_tree_workers = 0;
-    if (params->num_workers() >= 16) {
-      if (model_proto.has_objective() ||
-          model_proto.has_floating_point_objective()) {
-        num_shared_tree_workers = (params->num_workers() - 8) / 2;
-      } else {
-        num_shared_tree_workers = (params->num_workers() - 8) * 3 / 4;
-      }
+    if (model_proto.has_objective() ||
+        model_proto.has_floating_point_objective()) {
+      num_shared_tree_workers = (params->num_workers() - 16) / 2;
+    } else {
+      num_shared_tree_workers = (params->num_workers() - 8) * 3 / 4;
+    }
+    if (num_shared_tree_workers > 4) {
+      SOLVER_LOG(logger, "Setting number of shared tree workers to ",
+                 num_shared_tree_workers);
+      params->set_shared_tree_num_workers(num_shared_tree_workers);
     }
-    SOLVER_LOG(logger, "Setting number of shared tree workers to ",
-               num_shared_tree_workers);
-    params->set_shared_tree_num_workers(num_shared_tree_workers);
   }
 
   // We currently only use the feasibility pump or rins/rens if it is enabled
diff --git a/ortools/sat/cp_model_solver_test.cc b/ortools/sat/cp_model_solver_test.cc
index a1ba69d2f1..01419321e3 100644
--- a/ortools/sat/cp_model_solver_test.cc
+++ b/ortools/sat/cp_model_solver_test.cc
@@ -17,12 +17,14 @@
 #include <string>
 #include <vector>
 
+#include "absl/container/flat_hash_set.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_join.h"
 #include "gtest/gtest.h"
 #include "ortools/base/gmock.h"
 #include "ortools/base/parse_test_proto.h"
 #include "ortools/linear_solver/linear_solver.pb.h"
+#include "ortools/port/os.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_checker.h"
 #include "ortools/sat/cp_model_test_utils.h"
@@ -274,6 +276,108 @@ TEST(SolveCpModelTest, SimpleOptionalIntervalInfeasible) {
   EXPECT_EQ(response.status(), CpSolverStatus::INFEASIBLE);
 }
 
+TEST(SolveCpModelTest, NoOverlapWithEnforcementLiteral) {
+  CpModelProto model_proto;
+  const int enforcement = AddVariable(0, 1, &model_proto);
+  const int i1 = AddInterval(0, 3, 5, &model_proto);
+  const int i2 = AddInterval(0, 2, 5, &model_proto);
+
+  ConstraintProto* no_overlap = model_proto.add_constraints();
+  no_overlap->add_enforcement_literal(enforcement);
+  no_overlap->mutable_no_overlap()->add_intervals(i1);
+  no_overlap->mutable_no_overlap()->add_intervals(i2);
+
+  Model model;
+  SatParameters params;
+  params.set_enumerate_all_solutions(true);
+  model.Add(NewSatParameters(params));
+  int count = 0;
+  model.Add(
+      NewFeasibleSolutionObserver([&count](const CpSolverResponse& response) {
+        LOG(INFO) << absl::StrJoin(response.solution(), " ");
+        ++count;
+      }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // Two solutions when the constraint is enforced (i1 before i2, or i2 before
+  // i1, tightly packed), and 3 * 4 otherwise -- 3 possible starts for i1, 4 for
+  // i2).
+  EXPECT_EQ(count, 2 + 3 * 4);
+}
+
+TEST(SolveCpModelTest, NoOverlap2DWithEnforcementLiteral) {
+  CpModelProto model_proto;
+  const int enforcement = AddVariable(0, 1, &model_proto);
+  const int i1 = AddInterval(0, 3, 5, &model_proto);
+  const int i2 = AddInterval(0, 2, 5, &model_proto);
+  const int i3 = AddInterval(0, 4, 5, &model_proto);
+  const int i4 = AddInterval(0, 1, 2, &model_proto);
+  const int i5 = AddInterval(0, 1, 2, &model_proto);
+  const int i6 = AddInterval(0, 1, 2, &model_proto);
+
+  ConstraintProto* no_overlap_2d = model_proto.add_constraints();
+  no_overlap_2d->add_enforcement_literal(enforcement);
+  no_overlap_2d->mutable_no_overlap_2d()->add_x_intervals(i1);
+  no_overlap_2d->mutable_no_overlap_2d()->add_x_intervals(i2);
+  no_overlap_2d->mutable_no_overlap_2d()->add_x_intervals(i3);
+  no_overlap_2d->mutable_no_overlap_2d()->add_y_intervals(i4);
+  no_overlap_2d->mutable_no_overlap_2d()->add_y_intervals(i5);
+  no_overlap_2d->mutable_no_overlap_2d()->add_y_intervals(i6);
+
+  Model model;
+  SatParameters params;
+  params.set_enumerate_all_solutions(true);
+  model.Add(NewSatParameters(params));
+  int count = 0;
+  model.Add(
+      NewFeasibleSolutionObserver([&count](const CpSolverResponse& response) {
+        LOG(INFO) << absl::StrJoin(response.solution(), " ");
+        ++count;
+      }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // Eight solutions when the constraint is enforced (i1 before i2 on x, or i2
+  // before i1 on x, tightly packed, each with 2 possible x starts for i3, and
+  // two vertical placements -- i1 and i2 above or below i4), and 3 * 4 * 2^4
+  // otherwise -- 3 possible starts for i1, 4 for i2, 2 for i3, i4, i5, and i6).
+  EXPECT_EQ(count, 8 + 3 * 4 * 2 * 2 * 2 * 2);
+}
+
+TEST(SolveCpModelTest, CumulativeWithEnforcementLiteral) {
+  CpModelProto model_proto;
+  const int enforcement = AddVariable(0, 1, &model_proto);
+  const int i1 = AddInterval(0, 3, 5, &model_proto);
+  const int i2 = AddInterval(0, 2, 5, &model_proto);
+  const int i3 = AddInterval(0, 4, 5, &model_proto);
+
+  ConstraintProto* cumulative = model_proto.add_constraints();
+  cumulative->add_enforcement_literal(enforcement);
+  cumulative->mutable_cumulative()->add_intervals(i1);
+  cumulative->mutable_cumulative()->add_intervals(i2);
+  cumulative->mutable_cumulative()->add_intervals(i3);
+  cumulative->mutable_cumulative()->add_demands()->set_offset(1);
+  cumulative->mutable_cumulative()->add_demands()->set_offset(1);
+  cumulative->mutable_cumulative()->add_demands()->set_offset(1);
+  cumulative->mutable_cumulative()->mutable_capacity()->set_offset(2);
+
+  Model model;
+  SatParameters params;
+  params.set_enumerate_all_solutions(true);
+  model.Add(NewSatParameters(params));
+  int count = 0;
+  model.Add(
+      NewFeasibleSolutionObserver([&count](const CpSolverResponse& response) {
+        LOG(INFO) << absl::StrJoin(response.solution(), " ");
+        ++count;
+      }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // Four solutions when the constraint is enforced (i1 before i2, or i2 before
+  // i1, tightly packed, each with 2 possible starts for i3), and 3 * 4 * 2
+  // otherwise -- 3 possible starts for i1, 4 for i2, 2 for i3).
+  EXPECT_EQ(count, 4 + 3 * 4 * 2);
+}
+
 TEST(SolveCpModelTest, NonInstantiatedVariables) {
   CpModelProto model_proto;
   const int a = AddVariable(0, 10, &model_proto);
@@ -330,7 +434,54 @@ TEST(SolveCpModelTest, TrivialModelWithCore) {
                                         response.solution().end())));
 }
 
-#if !defined(__EMBEDDED_PLATFORM__)
+#if ORTOOLS_TARGET_OS_SUPPORTS_THREADS
+
+TEST(SolveCpModelTest, IntervalsWithSeveralEnforcementLiterals) {
+  const CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: [ 0, 1 ]
+      interval {
+        start { offset: 0 }
+        end { offset: 1 }
+        size { offset: 1 }
+      }
+    }
+    constraints {
+      enforcement_literal: [ 1, 2 ]
+      interval {
+        start { offset: 0 }
+        end { offset: 1 }
+        size { offset: 1 }
+      }
+    }
+    constraints {
+      enforcement_literal: [ 2, 0 ]
+      interval {
+        start { offset: 0 }
+        end { offset: 1 }
+        size { offset: 1 }
+      }
+    }
+    constraints { no_overlap { intervals: [ 0, 1, 2 ] } }
+  )pb");
+
+  Model model;
+  model.Add(NewSatParameters("enumerate_all_solutions:true"));
+  int count = 0;
+  model.Add(
+      NewFeasibleSolutionObserver([&count](const CpSolverResponse& response) {
+        LOG(INFO) << absl::StrJoin(response.solution(), " ");
+        ++count;
+      }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // All combinations except (1, 1, 1) are feasible.
+  EXPECT_EQ(count, 7);
+}
+
 TEST(SolveCpModelTest, TrivialLinearTranslatedModel) {
   const CpModelProto model_proto = ParseTestProto(R"pb(
     variables { domain: -10 domain: 10 }
@@ -870,7 +1021,7 @@ TEST(SolveCpModelTest, IntProdWithEnforcementLiteral) {
 }
 
 TEST(SolveCpModelTest, SquareIntProdWithEnforcementLiteral) {
-  // not(b) => x.y.z = 17
+  // not(b) => x^2 = 17
   CpModelProto model_proto = ParseTestProto(R"pb(
     variables { domain: [ 0, 1 ] }
     variables { domain: [ 2, 20 ] }
@@ -889,6 +1040,20 @@ TEST(SolveCpModelTest, SquareIntProdWithEnforcementLiteral) {
   EXPECT_EQ(response.solution(0), 1);
 }
 
+TEST(SolveCpModelTest, IntProdWithEnforcementLiteralButNoTerms) {
+  const CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: 0 domain: 1 }
+    constraints {
+      enforcement_literal: 0
+      int_prod { target { vars: 0 coeffs: -4096 offset: 4096 } }
+    }
+  )pb");
+  Model model;
+  model.Add(NewSatParameters("cp_model_presolve:false"));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+}
+
 TEST(SolveCpModelTest, LinMaxObjectiveDomainLowerBoundInfeasible) {
   const CpModelProto model_proto = ParseTestProto(R"pb(
     variables { domain: [ 0, 5 ] }
@@ -987,6 +1152,202 @@ TEST(SolveCpModelTest, LinMaxUniqueTarget) {
   EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
 }
 
+TEST(SolveCpModelTest, LinMaxWithEnforcementLiteral) {
+  // not(b) => z = max(x, y), x in [2, 5], y in [0, 4], z in [6, 9].
+  CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 2, 5 ] }
+    variables { domain: [ 0, 4 ] }
+    variables { domain: [ 6, 9 ] }
+    constraints {
+      enforcement_literal: -1
+      lin_max {
+        target { vars: 3 coeffs: 1 }
+        exprs { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 }
+      }
+    })pb");
+  Model model;
+  model.Add(NewSatParameters("cp_model_presolve:false"));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  EXPECT_EQ(response.solution(0), 1);
+}
+
+TEST(SolveCpModelTest, AllDifferentWithEnforcementLiteral) {
+  // not(b) => all_diff(x, y+1, 2-z), x,y+1,3-z in [1, 2].
+  CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 1, 2 ] }
+    variables { domain: [ 0, 1 ] }
+    variables { domain: [ 1, 2 ] }
+    constraints {
+      enforcement_literal: -1
+      all_diff {
+        exprs { vars: 1 coeffs: 1 }
+        exprs { vars: 2 coeffs: 1 offset: 1 }
+        exprs { vars: 3 coeffs: -1 offset: 3 }
+      }
+    })pb");
+  Model model;
+  model.Add(NewSatParameters("cp_model_presolve:false"));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  EXPECT_EQ(response.solution(0), 1);
+}
+
+TEST(SolveCpModelTest, FeasibleCircuitWithEnforcementLiteral) {
+  const CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    constraints {
+      enforcement_literal: 3
+      circuit {
+        tails: [ 0, 1, 2, 3, 0, 2, 1 ]
+        heads: [ 1, 2, 3, 0, 2, 1, 3 ]
+        literals: [ 0, 1, 2, 3, 4, 5, 6 ]
+      }
+    }
+  )pb");
+
+  Model model;
+  model.Add(NewSatParameters("enumerate_all_solutions:true"));
+  int count = 0;
+  model.Add(NewFeasibleSolutionObserver([&](const CpSolverResponse& response) {
+    LOG(INFO) << absl::StrJoin(response.solution(), " ");
+    EXPECT_TRUE(SolutionIsFeasible(
+        model_proto, std::vector<int64_t>(response.solution().begin(),
+                                          response.solution().end())));
+    ++count;
+  }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // Two feasible circuits (0, 1, 2, 3) and (0, 2, 1, 3), plus 2^6 solutions
+  // when the circuit constraint is not enforced.
+  EXPECT_EQ(count, 2 + 2 * 2 * 2 * 2 * 2 * 2);
+}
+
+TEST(SolveCpModelTest, InfeasibleCircuitDueToMultiArcsWithEnforcementLiteral) {
+  const CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: 1 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    constraints {
+      enforcement_literal: 2
+      circuit {
+        tails: [ 0, 0, 1 ]
+        heads: [ 1, 1, 0 ]
+        literals: [ 0, 0, 1 ]
+      }
+    }
+  )pb");
+
+  Model model;
+  model.Add(NewSatParameters("enumerate_all_solutions:true"));
+  int count = 0;
+  model.Add(NewFeasibleSolutionObserver([&](const CpSolverResponse& response) {
+    LOG(INFO) << absl::StrJoin(response.solution(), " ");
+    EXPECT_TRUE(SolutionIsFeasible(
+        model_proto, std::vector<int64_t>(response.solution().begin(),
+                                          response.solution().end())));
+    ++count;
+  }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // No feasible circuit, but 2 solutions with a false enforcement literal.
+  EXPECT_EQ(count, 2);
+}
+
+TEST(SolveCpModelTest,
+     InfeasibleCircuitDueToMissingArcsWithEnforcementLiteral) {
+  const CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    constraints {
+      enforcement_literal: 4
+      circuit {
+        tails: [ 0, 1, 0, 2 ]
+        heads: [ 1, 1, 2, 2 ]
+        literals: [ 0, 1, 2, 3 ]
+      }
+    }
+  )pb");
+
+  Model model;
+  model.Add(NewSatParameters("enumerate_all_solutions:true"));
+  int count = 0;
+  model.Add(NewFeasibleSolutionObserver([&](const CpSolverResponse& response) {
+    LOG(INFO) << absl::StrJoin(response.solution(), " ");
+    EXPECT_TRUE(SolutionIsFeasible(
+        model_proto, std::vector<int64_t>(response.solution().begin(),
+                                          response.solution().end())));
+    ++count;
+  }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // No feasible circuit, but 2^4 solutions with a false enforcement literal.
+  EXPECT_EQ(count, 2 * 2 * 2 * 2);
+}
+
+// The graph look like this with a self-loop at 2. If 2 is not selected
+// (self-loop) then there is one solution (0,1,3,0) and (0,3,5,0). Otherwise,
+// there is 2 more solutions with 2 inserted in one of the two routes.
+//
+//   0  ---> 1 ---> 4 -------------
+//   |       |      ^             |
+//   |       -----> 2* --> 5 ---> 0
+//   |              ^      ^
+//   |              |      |
+//   -------------> 3 ------
+//
+TEST(CircuitConstraintTest, RouteConstraintWithEnforcementLiteral) {
+  const CpModelProto model_proto = ParseTestProto(R"pb(
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    variables { domain: 0 domain: 1 }
+    constraints {
+      enforcement_literal: 11
+      routes {
+        tails: [ 0, 0, 1, 1, 2, 2, 2, 3, 3, 4, 5 ]
+        heads: [ 1, 3, 2, 4, 2, 4, 5, 2, 5, 0, 0 ]
+        literals: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
+      }
+    }
+  )pb");
+
+  Model model;
+  model.Add(NewSatParameters("enumerate_all_solutions:true"));
+  int count = 0;
+  model.Add(NewFeasibleSolutionObserver([&](const CpSolverResponse& response) {
+    LOG(INFO) << absl::StrJoin(response.solution(), " ");
+    EXPECT_TRUE(SolutionIsFeasible(
+        model_proto, std::vector<int64_t>(response.solution().begin(),
+                                          response.solution().end())));
+    ++count;
+  }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  // 3 solutions when the constraint is enforced, 2^11 otherwise.
+  EXPECT_EQ(count, 3 + 2048);
+}
+
 TEST(SolveCpModelTest, HintWithCore) {
   const CpModelProto model_proto = ParseTestProto(R"pb(
     variables { domain: [ 0, 5 ] }
@@ -1358,6 +1719,61 @@ TEST(SolveCpModelTest, MultipleEnforcementLiteral) {
   EXPECT_EQ(count, 25 + 25 + 25 + /*when enforced*/ 5);
 }
 
+TEST(SolveCpModelTest, IntProdWithNonAffineExpressions) {
+  // z = (x-2y-1)^2 = (3-x)(1+x)
+  const CpModelProto model_proto = ParseTestProto(R"pb(
+    variables {
+      name: "x"
+      domain: [ -5, 5 ]
+    }
+    variables {
+      name: "y"
+      domain: [ -5, 5 ]
+    }
+    variables {
+      name: "z"
+      domain: [ -5, 5 ]
+    }
+    constraints {
+      int_prod {
+        target { vars: 2 coeffs: 1 }
+        exprs {
+          vars: [ 0, 1 ]
+          coeffs: [ 1, -2 ]
+          offset: -1
+        }
+        exprs {
+          vars: [ 0, 1 ]
+          coeffs: [ 1, -2 ]
+          offset: -1
+        }
+      }
+    }
+    constraints {
+      int_prod {
+        target { vars: 2 coeffs: 1 }
+        exprs { vars: 0 coeffs: -1 offset: 3 }
+        exprs { vars: 0 coeffs: 1 offset: 1 }
+      }
+    }
+  )pb");
+
+  Model model;
+  model.Add(NewSatParameters("enumerate_all_solutions:true"));
+  absl::flat_hash_set<std::vector<int>> solutions;
+  model.Add(NewFeasibleSolutionObserver([&solutions](
+                                            const CpSolverResponse& response) {
+    solutions.insert({response.solution().begin(), response.solution().end()});
+  }));
+  const CpSolverResponse response = SolveCpModel(model_proto, &model);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+  EXPECT_THAT(solutions,
+              testing::UnorderedElementsAre(testing::ElementsAre(-1, -1, 0),
+                                            testing::ElementsAre(1, -1, 4),
+                                            testing::ElementsAre(1, 1, 4),
+                                            testing::ElementsAre(3, 1, 0)));
+}
+
 TEST(SolveCpModelTest, TightenedDomains) {
   const CpModelProto model_proto = ParseTestProto(R"pb(
     variables { domain: 0 domain: 10 }
@@ -4956,7 +5372,86 @@ TEST(PresolveCpModelTest, CumulativeBug4) {
   response = SolveWithParameters(cp_model, params);
   EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
 }
-#endif  // !defined(__EMBEDDED_PLATFORM__)
+
+TEST(PresolveCpModelTest, AutomatonNonCanonical) {
+  const CpModelProto cp_model = ParseTestProto(
+      R"pb(
+        variables { domain: [ 0, 1 ] }
+        variables { domain: [ 0, 1 ] }
+        variables { domain: [ 0, 1 ] }
+        variables { domain: [ 0, 1 ] }
+        constraints {
+          automaton {
+            final_states: [ 3 ]
+            transition_tail: [ 0, 0, 1, 2, 1, 2 ]
+            transition_head: [ 1, 2, 1, 2, 3, 3 ]
+            transition_label: [ 0, 1, 0, 1, 1, 0 ]
+            exprs {
+              vars: [ 0 ]
+              coeffs: [ 1 ]
+            }
+            exprs {
+              vars: [ 1 ]
+              coeffs: [ 0 ]
+            }
+            exprs {
+              vars: [ 2 ]
+              coeffs: [ 1 ]
+            }
+            exprs {
+              vars: [ 3 ]
+              coeffs: [ 1 ]
+            }
+          }
+        })pb");
+
+  SatParameters params;
+  params.set_log_search_progress(true);
+  params.set_debug_crash_if_presolve_breaks_hint(true);
+  params.set_cp_model_presolve(false);
+  params.set_cp_model_probing_level(0);
+  params.set_symmetry_level(0);
+
+  CpSolverResponse response = SolveWithParameters(cp_model, params);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+
+  params.set_cp_model_presolve(true);
+  response = SolveWithParameters(cp_model, params);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+}
+
+TEST(PresolveCpModelTest, SolutionCrushBug) {
+  const CpModelProto cp_model = ParseTestProto(
+      R"pb(
+        variables { domain: 0 domain: 2 }
+        variables { domain: 0 domain: 2 }
+        constraints {
+          int_mod {
+            target {}
+            exprs { offset: -1 }
+            exprs { vars: 1 coeffs: 1 offset: 2647 }
+          }
+        }
+        constraints { at_most_one {} }
+        floating_point_objective { vars: 0 coeffs: 1 offset: 5.12549424074614 }
+      )pb");
+
+  SatParameters params;
+  params.set_log_search_progress(true);
+  params.set_debug_crash_if_presolve_breaks_hint(true);
+  params.set_cp_model_presolve(false);
+  params.set_cp_model_probing_level(0);
+  params.set_symmetry_level(0);
+
+  CpSolverResponse response = SolveWithParameters(cp_model, params);
+  EXPECT_EQ(response.status(), CpSolverStatus::INFEASIBLE);
+
+  params.set_cp_model_presolve(true);
+  response = SolveWithParameters(cp_model, params);
+  EXPECT_EQ(response.status(), CpSolverStatus::INFEASIBLE);
+}
+
+#endif  // ORTOOLS_TARGET_OS_SUPPORTS_THREADS
 
 }  // namespace
 }  // namespace sat
diff --git a/ortools/sat/cp_model_symmetries.cc b/ortools/sat/cp_model_symmetries.cc
index a93b81c067..f45495f9b6 100644
--- a/ortools/sat/cp_model_symmetries.cc
+++ b/ortools/sat/cp_model_symmetries.cc
@@ -379,7 +379,8 @@ std::unique_ptr<Graph> GenerateGraphForSymmetryDetection(
         break;
       }
       case ConstraintProto::kAtMostOne: {
-        if (constraint.at_most_one().literals().size() == 2) {
+        if (constraint.at_most_one().literals().size() == 2 &&
+            constraint.enforcement_literal().empty()) {
           // Treat it as an implication to avoid creating a node.
           add_implication(constraint.at_most_one().literals(0),
                           NegatedRef(constraint.at_most_one().literals(1)));
@@ -427,6 +428,7 @@ std::unique_ptr<Graph> GenerateGraphForSymmetryDetection(
             constraint.lin_max().target();
 
         const int target_node = make_linear_expr_node(target_expr, color);
+        CHECK_EQ(constraint_node, target_node);
 
         for (int i = 0; i < constraint.lin_max().exprs_size(); ++i) {
           const LinearExpressionProto& expr = constraint.lin_max().exprs(i);
@@ -538,9 +540,13 @@ std::unique_ptr<Graph> GenerateGraphForSymmetryDetection(
       case ConstraintProto::kCircuit: {
         // Note that this implementation will generate the same graph for a
         // circuit constraint with two disconnected components and two circuit
-        // constraints with one component each.
+        // constraints with one component each, unless there is an enforcement
+        // literal.
         const int num_arcs = constraint.circuit().literals().size();
         absl::flat_hash_map<int, int> circuit_node_to_symmetry_node;
+        if (!constraint.enforcement_literal().empty()) {
+          CHECK_EQ(constraint_node, new_node(color));
+        }
         std::vector<int64_t> arc_color = color;
         arc_color.push_back(1);
         for (int i = 0; i < num_arcs; ++i) {
@@ -558,6 +564,9 @@ std::unique_ptr<Graph> GenerateGraphForSymmetryDetection(
           const int tail_node = circuit_node_to_symmetry_node[tail];
           // To make the graph directed, we add two arcs on the head but not on
           // the tail.
+          if (!constraint.enforcement_literal().empty()) {
+            graph->AddArc(constraint_node, arc_node);
+          }
           graph->AddArc(tail_node, arc_node);
           graph->AddArc(arc_node, get_literal_node(literal));
           graph->AddArc(arc_node, head_node);
@@ -583,6 +592,9 @@ std::unique_ptr<Graph> GenerateGraphForSymmetryDetection(
     // part. This way we can reuse the same get_literal_node() function.
     if (constraint.constraint_case() != ConstraintProto::kBoolAnd ||
         constraint.enforcement_literal().size() > 1) {
+      if (!constraint.enforcement_literal().empty()) {
+        CHECK_LT(constraint_node, initial_equivalence_classes->size());
+      }
       for (const int ref : constraint.enforcement_literal()) {
         graph->AddArc(constraint_node, get_literal_node(ref));
       }
diff --git a/ortools/sat/cp_model_utils.cc b/ortools/sat/cp_model_utils.cc
index 6af621ec36..fb49d7f798 100644
--- a/ortools/sat/cp_model_utils.cc
+++ b/ortools/sat/cp_model_utils.cc
@@ -678,6 +678,24 @@ void AddWeightedLiteralToLinearConstraint(int lit, int64_t coeff,
   }
 }
 
+void LiteralsToLinear(absl::Span<const int> literals, int64_t lb, int64_t ub,
+                      LinearConstraintProto* linear) {
+  linear->Clear();
+  for (const int lit : literals) {
+    if (RefIsPositive(lit)) {
+      linear->add_vars(lit);
+      linear->add_coeffs(1);
+    } else {
+      linear->add_vars(NegatedRef(lit));
+      linear->add_coeffs(-1);
+      lb -= 1;
+      ub -= 1;
+    }
+  }
+  linear->add_domain(lb);
+  linear->add_domain(ub);
+}
+
 bool SafeAddLinearExpressionToLinearConstraint(
     const LinearExpressionProto& expr, int64_t coefficient,
     LinearConstraintProto* linear) {
diff --git a/ortools/sat/cp_model_utils.h b/ortools/sat/cp_model_utils.h
index e00d556306..c0ae192598 100644
--- a/ortools/sat/cp_model_utils.h
+++ b/ortools/sat/cp_model_utils.h
@@ -145,6 +145,22 @@ void FillDomainInProto(const Domain& domain, ProtoWithDomain* proto) {
   }
 }
 
+template <typename ProtoWithDomain>
+void FillDomainInProto(int64_t lb, int64_t ub, ProtoWithDomain* proto) {
+  proto->clear_domain();
+  proto->mutable_domain()->Reserve(2);
+  proto->add_domain(lb);
+  proto->add_domain(ub);
+}
+
+template <typename ProtoWithDomain>
+void FillDomainInProto(int64_t value, ProtoWithDomain* proto) {
+  proto->clear_domain();
+  proto->mutable_domain()->Reserve(2);
+  proto->add_domain(value);
+  proto->add_domain(value);
+}
+
 // Reads a Domain from the domain field of a proto.
 template <typename ProtoWithDomain>
 Domain ReadDomainFromProto(const ProtoWithDomain& proto) {
@@ -261,6 +277,10 @@ void AddWeightedLiteralToLinearConstraint(int lit, int64_t coeff,
                                           LinearConstraintProto* linear,
                                           int64_t* offset);
 
+// Sets `linear` to the constraint "lb <= sum(`literals`) <= ub".
+void LiteralsToLinear(absl::Span<const int> literals, int64_t lb, int64_t ub,
+                      LinearConstraintProto* linear);
+
 // Same method, but returns if the addition was possible without overflowing.
 bool SafeAddLinearExpressionToLinearConstraint(
     const LinearExpressionProto& expr, int64_t coefficient,
diff --git a/ortools/sat/cumulative.cc b/ortools/sat/cumulative.cc
index 8cde3428c0..6bda10a64b 100644
--- a/ortools/sat/cumulative.cc
+++ b/ortools/sat/cumulative.cc
@@ -34,6 +34,7 @@
 #include "ortools/sat/sat_base.h"
 #include "ortools/sat/sat_parameters.pb.h"
 #include "ortools/sat/sat_solver.h"
+#include "ortools/sat/scheduling_helpers.h"
 #include "ortools/sat/timetable.h"
 #include "ortools/sat/timetable_edgefinding.h"
 #include "ortools/util/strong_integers.h"
@@ -42,6 +43,7 @@ namespace operations_research {
 namespace sat {
 
 std::function<void(Model*)> Cumulative(
+    const std::vector<Literal>& enforcement_literals,
     const std::vector<IntervalVariable>& vars,
     absl::Span<const AffineExpression> demands, AffineExpression capacity,
     SchedulingConstraintHelper* helper) {
@@ -53,8 +55,15 @@ std::function<void(Model*)> Cumulative(
     auto* watcher = model->GetOrCreate<GenericLiteralWatcher>();
     SatSolver* sat_solver = model->GetOrCreate<SatSolver>();
 
-    if (!integer_trail->SafeEnqueue(capacity.GreaterOrEqual(0), {})) {
-      sat_solver->NotifyThatModelIsUnsat();
+    if (enforcement_literals.empty()) {
+      if (!integer_trail->SafeEnqueue(capacity.GreaterOrEqual(0), {})) {
+        sat_solver->NotifyThatModelIsUnsat();
+      }
+    } else {
+      LinearConstraintBuilder builder(model, IntegerValue(0), kMaxIntegerValue);
+      builder.AddTerm(capacity, IntegerValue(1));
+      LoadConditionalLinearConstraint(enforcement_literals, builder.Build(),
+                                      model);
     }
     if (demands.empty()) {
       // If there is no demand, since we already added a constraint that the
@@ -74,23 +83,25 @@ std::function<void(Model*)> Cumulative(
       builder.AddTerm(capacity, IntegerValue(-1));
       LinearConstraint ct = builder.Build();
 
-      std::vector<Literal> enforcement_literals;
+      std::vector<Literal> task_enforcement_literals = enforcement_literals;
       if (intervals->IsOptional(vars[i])) {
-        enforcement_literals.push_back(intervals->PresenceLiteral(vars[i]));
+        task_enforcement_literals.push_back(
+            intervals->PresenceLiteral(vars[i]));
       }
 
       // If the interval can be of size zero, it currently do not count towards
       // the capacity. TODO(user): Change that since we have optional interval
       // for this.
       if (intervals->MinSize(vars[i]) <= 0) {
-        enforcement_literals.push_back(encoder->GetOrCreateAssociatedLiteral(
-            intervals->Size(vars[i]).GreaterOrEqual(IntegerValue(1))));
+        task_enforcement_literals.push_back(
+            encoder->GetOrCreateAssociatedLiteral(
+                intervals->Size(vars[i]).GreaterOrEqual(IntegerValue(1))));
       }
 
-      if (enforcement_literals.empty()) {
+      if (task_enforcement_literals.empty()) {
         LoadLinearConstraint(ct, model);
       } else {
-        LoadConditionalLinearConstraint(enforcement_literals, ct, model);
+        LoadConditionalLinearConstraint(task_enforcement_literals, ct, model);
       }
     }
 
@@ -154,12 +165,13 @@ std::function<void(Model*)> Cumulative(
       //
       // TODO(user): A better place for stuff like this could be in the
       // presolver so that it is easier to disable and play with alternatives.
-      if (in_disjunction.size() > 1) AddDisjunctive(in_disjunction, model);
+      if (in_disjunction.size() > 1)
+        AddDisjunctive(enforcement_literals, in_disjunction, model);
       if (in_disjunction.size() == vars.size()) return;
     }
 
     if (helper == nullptr) {
-      helper = intervals->GetOrCreateHelper(vars);
+      helper = intervals->GetOrCreateHelper(enforcement_literals, vars);
     }
     SchedulingDemandHelper* demands_helper =
         intervals->GetOrCreateDemandHelper(helper, demands);
@@ -292,9 +304,11 @@ std::function<void(Model*)> Cumulative(
 }
 
 std::function<void(Model*)> CumulativeTimeDecomposition(
+    absl::Span<const Literal> enforcement_literals,
     absl::Span<const IntervalVariable> vars,
     absl::Span<const AffineExpression> demands, AffineExpression capacity,
-    SchedulingConstraintHelper* helper) {
+    SchedulingConstraintHelper* /*helper*/) {
+  CHECK(enforcement_literals.empty());
   return [=, vars = std::vector<IntervalVariable>(vars.begin(), vars.end()),
           demands = std::vector<AffineExpression>(
               demands.begin(), demands.end())](Model* model) {
@@ -376,9 +390,10 @@ std::function<void(Model*)> CumulativeTimeDecomposition(
 }
 
 std::function<void(Model*)> CumulativeUsingReservoir(
+    absl::Span<const Literal> enforcement_literals,
     absl::Span<const IntervalVariable> vars,
     absl::Span<const AffineExpression> demands, AffineExpression capacity,
-    SchedulingConstraintHelper* helper) {
+    SchedulingConstraintHelper* /*helper*/) {
   return [=, vars = std::vector<IntervalVariable>(vars.begin(), vars.end()),
           demands = std::vector<AffineExpression>(
               demands.begin(), demands.end())](Model* model) {
@@ -411,8 +426,8 @@ std::function<void(Model*)> CumulativeUsingReservoir(
         presences.push_back(encoder->GetTrueLiteral());
       }
     }
-    AddReservoirConstraint(times, deltas, presences, 0, fixed_capacity.value(),
-                           model);
+    AddReservoirConstraint(enforcement_literals, times, deltas, presences, 0,
+                           fixed_capacity.value(), model);
   };
 }
 
diff --git a/ortools/sat/cumulative.h b/ortools/sat/cumulative.h
index 209532f803..5079f64fba 100644
--- a/ortools/sat/cumulative.h
+++ b/ortools/sat/cumulative.h
@@ -21,6 +21,8 @@
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/intervals.h"
 #include "ortools/sat/model.h"
+#include "ortools/sat/sat_base.h"
+#include "ortools/sat/scheduling_helpers.h"
 
 namespace operations_research {
 namespace sat {
@@ -44,6 +46,7 @@ namespace sat {
 // Optimization: If one already have an helper constructed from the interval
 // variable, it can be passed as last argument.
 std::function<void(Model*)> Cumulative(
+    const std::vector<Literal>& enforcement_literals,
     const std::vector<IntervalVariable>& vars,
     absl::Span<const AffineExpression> demands, AffineExpression capacity,
     SchedulingConstraintHelper* helper = nullptr);
@@ -54,12 +57,14 @@ std::function<void(Model*)> Cumulative(
 // This constraint assumes that task demands and the resource capacity are fixed
 // to non-negative number.
 std::function<void(Model*)> CumulativeTimeDecomposition(
+    absl::Span<const Literal> enforcement_literals,
     absl::Span<const IntervalVariable> vars,
     absl::Span<const AffineExpression> demands, AffineExpression capacity,
     SchedulingConstraintHelper* helper = nullptr);
 
 // Another testing code, same assumptions as the CumulativeTimeDecomposition().
 std::function<void(Model*)> CumulativeUsingReservoir(
+    absl::Span<const Literal> enforcement_literals,
     absl::Span<const IntervalVariable> vars,
     absl::Span<const AffineExpression> demands, AffineExpression capacity,
     SchedulingConstraintHelper* helper = nullptr);
diff --git a/ortools/sat/cumulative_energy.cc b/ortools/sat/cumulative_energy.cc
index 38fcbd7a93..f3e6845156 100644
--- a/ortools/sat/cumulative_energy.cc
+++ b/ortools/sat/cumulative_energy.cc
@@ -84,6 +84,7 @@ void CumulativeEnergyConstraint::RegisterWith(GenericLiteralWatcher* watcher) {
 }
 
 bool CumulativeEnergyConstraint::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   // This only uses one time direction, but the helper might be used elsewhere.
   // TODO(user): just keep the current direction?
   if (!helper_->SynchronizeAndSetTimeDirection(true)) return false;
@@ -163,7 +164,7 @@ bool CumulativeEnergyConstraint::Propagate() {
       // a lower one, we could maybe have propagated more the minimum capacity.
       // investigate.
       if (new_capacity_min > integer_trail_->LowerBound(capacity_)) {
-        helper_->ClearReason();
+        helper_->ResetReason();
         for (int event = critical_event; event < num_events; event++) {
           if (start_event_is_present_[event]) {
             const int task = start_event_task_time_[event].task_index;
@@ -196,7 +197,7 @@ bool CumulativeEnergyConstraint::Propagate() {
       // several times, making this algorithm O(n^2 log n). Is there a way
       // to get the best pruning in one go? This looks like edge-finding not
       // being able to converge in one pass, so it might not be easy.
-      helper_->ClearReason();
+      helper_->ResetReason();
       int critical_event;
       int event_with_new_energy_max;
       IntegerValue new_energy_max;
@@ -220,7 +221,7 @@ bool CumulativeEnergyConstraint::Propagate() {
         }
       }
       if (capacity_.var != kNoIntegerVariable) {
-        helper_->MutableIntegerReason()->push_back(
+        helper_->AddIntegerReason(
             integer_trail_->UpperBoundAsLiteral(capacity_.var));
       }
 
@@ -267,6 +268,7 @@ CumulativeIsAfterSubsetConstraint::CumulativeIsAfterSubsetConstraint(
 }
 
 bool CumulativeIsAfterSubsetConstraint::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   if (!helper_->SynchronizeAndSetTimeDirection(true)) return false;
 
   IntegerValue best_time = kMaxIntegerValue;
@@ -349,7 +351,7 @@ bool CumulativeIsAfterSubsetConstraint::Propagate() {
   if (best_bound > integer_trail_->LowerBound(var_to_push_)) {
     // Compute the reason.
     // It is just the reason for the energy after time.
-    helper_->ClearReason();
+    helper_->ResetReason();
     for (int t = 0; t < helper_->NumTasks(); ++t) {
       if (!is_in_subtasks_[t]) continue;
       if (!helper_->IsPresent(t)) continue;
@@ -369,7 +371,7 @@ bool CumulativeIsAfterSubsetConstraint::Propagate() {
       demands_->AddDemandMinReason(t);
     }
     if (capacity_.var != kNoIntegerVariable) {
-      helper_->MutableIntegerReason()->push_back(
+      helper_->AddIntegerReason(
           integer_trail_->UpperBoundAsLiteral(capacity_.var));
     }
 
@@ -492,7 +494,7 @@ bool CumulativeDualFeasibleEnergyConstraint::FindAndPropagateConflict(
                                        OrthogonalPackingResult::Coord::kCoordY,
                                        demands_->LevelZeroDemandMin(task));
   }
-  helper_->ClearReason();
+  helper_->ResetReason();
   for (const auto& item : result.GetItemsParticipatingOnConflict()) {
     const int task = index_to_task[item.index];
 
@@ -508,13 +510,14 @@ bool CumulativeDualFeasibleEnergyConstraint::FindAndPropagateConflict(
     demands_->AddDemandMinReason(task, item.size_y);
   }
   if (capacity_.var != kNoIntegerVariable) {
-    helper_->MutableIntegerReason()->push_back(
+    helper_->AddIntegerReason(
         integer_trail_->UpperBoundAsLiteral(capacity_.var));
   }
   return helper_->ReportConflict();
 }
 
 bool CumulativeDualFeasibleEnergyConstraint::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   if (!helper_->SynchronizeAndSetTimeDirection(true)) return false;
   if (!demands_->CacheAllEnergyValues()) return true;
 
@@ -594,13 +597,13 @@ bool CumulativeDualFeasibleEnergyConstraint::Propagate() {
       demands_->AddDemandMinReason(current_task);
 
       if (capacity_.var != kNoIntegerVariable) {
-        helper_->MutableIntegerReason()->push_back(
+        helper_->AddIntegerReason(
             integer_trail_->UpperBoundAsLiteral(capacity_));
       }
 
       const AffineExpression size = helper_->Sizes()[current_task];
       if (size.var != kNoIntegerVariable) {
-        helper_->MutableIntegerReason()->push_back(size.GreaterOrEqual(1));
+        helper_->AddIntegerReason(size.GreaterOrEqual(1));
       }
 
       return helper_->ReportConflict();
diff --git a/ortools/sat/cumulative_energy_test.cc b/ortools/sat/cumulative_energy_test.cc
index 27f4cb929c..a75669640b 100644
--- a/ortools/sat/cumulative_energy_test.cc
+++ b/ortools/sat/cumulative_energy_test.cc
@@ -113,7 +113,8 @@ bool SolveUsingConstraint(const EnergyInstance& instance) {
       model.Add(ConstantIntegerVariable(instance.capacity)));
 
   auto* repo = model.GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper(intervals);
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, intervals);
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({}, helper, &model);
   demands_helper->OverrideDecomposedEnergies(decomposed_energies);
@@ -223,7 +224,7 @@ bool SolveUsingNaiveModel(const EnergyInstance& instance) {
 
   SatParameters params =
       model.Add(NewSatParameters("use_overload_checker_in_cumulative:true"));
-  model.Add(Cumulative(intervals, consumptions,
+  model.Add(Cumulative(/*enforcement_literals=*/{}, intervals, consumptions,
                        AffineExpression(IntegerValue(instance.capacity))));
 
   return SolveIntegerProblemWithLazyEncoding(&model) ==
@@ -303,7 +304,8 @@ bool TestOverloadCheckerPropagation(
 
   // Propagator responsible for filtering the capacity variable.
   auto* repo = model.GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper(interval_vars);
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, interval_vars);
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper(demands, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -412,7 +414,8 @@ TEST(OverloadCheckerTest, OptionalTaskPropagatedToAbsent) {
       model.Add(NewOptionalInterval(0, 10, /*size=*/8, is_present));
 
   auto* repo = model.GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({i1, i2});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {i1, i2});
   const AffineExpression cte(IntegerValue(2));
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({cte, cte}, helper, &model);
@@ -432,7 +435,8 @@ TEST(OverloadCheckerTest, OptionalTaskMissedPropagationCase) {
       model.Add(NewOptionalInterval(0, 10, /*size=*/8, is_present));
 
   auto* repo = model.GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({i1, i2});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {i1, i2});
   const AffineExpression cte(IntegerValue(2));
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({cte, cte}, helper, &model);
@@ -515,7 +519,8 @@ bool TestIsAfterCumulative(absl::Span<const CumulativeTasks> tasks,
 
   // Propagator responsible for filtering the capacity variable.
   auto* repo = model.GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper(interval_vars);
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, interval_vars);
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper(demands, helper, &model);
   model.TakeOwnership(demands_helper);
diff --git a/ortools/sat/cumulative_test.cc b/ortools/sat/cumulative_test.cc
index 28eec136ac..7577c45eeb 100644
--- a/ortools/sat/cumulative_test.cc
+++ b/ortools/sat/cumulative_test.cc
@@ -41,7 +41,7 @@ namespace {
 // RcpspInstance contains the data to define an instance of the Resource
 // Constrained Project Scheduling Problem (RCPSP). We only consider a restricted
 // variant of the RCPSP which is the problem of scheduling a set of
-// non-premptive tasks that consume a given quantity of a resource without
+// non-preemptive tasks that consume a given quantity of a resource without
 // exceeding the resource's capacity. We assume that the duration of a task, its
 // demand, and the resource capacity are fixed.
 struct RcpspInstance {
@@ -135,7 +135,8 @@ int CountAllSolutions(const RcpspInstance& instance, SatParameters parameters,
     demands[t] = IntegerValue(instance.demands[t]);
   }
 
-  model.Add(cumulative(intervals, demands, capacity, nullptr));
+  model.Add(cumulative(/*enforcement_literals=*/{}, intervals, demands,
+                       capacity, nullptr));
 
   // Make sure that every Boolean variable is considered as a decision variable
   // to be fixed.
@@ -270,8 +271,8 @@ TEST(CumulativeTest, CapacityAndDemand) {
   const IntegerVariable demand = model.Add(NewIntegerVariable(5, 15));
   const IntegerVariable capacity = model.Add(NewIntegerVariable(0, 10));
   const IntegerTrail* integer_trail = model.GetOrCreate<IntegerTrail>();
-  model.Add(Cumulative({interval}, {AffineExpression(demand)},
-                       AffineExpression(capacity)));
+  model.Add(Cumulative(/*enforcement_literals=*/{}, {interval},
+                       {AffineExpression(demand)}, AffineExpression(capacity)));
   ASSERT_TRUE(sat_solver->Propagate());
   ASSERT_EQ(integer_trail->LowerBound(capacity), 5);
   ASSERT_EQ(integer_trail->UpperBound(capacity), 10);
@@ -291,8 +292,8 @@ TEST(CumulativeTest, CapacityAndZeroDemand) {
   const IntegerVariable demand = model.Add(NewIntegerVariable(11, 15));
   const IntegerVariable capacity = model.Add(NewIntegerVariable(0, 10));
   const IntegerTrail* integer_trail = model.GetOrCreate<IntegerTrail>();
-  model.Add(Cumulative({interval}, {AffineExpression(demand)},
-                       AffineExpression(capacity)));
+  model.Add(Cumulative(/*enforcement_literals=*/{}, {interval},
+                       {AffineExpression(demand)}, AffineExpression(capacity)));
   ASSERT_TRUE(sat_solver->Propagate());
   ASSERT_EQ(integer_trail->LowerBound(capacity), 0);
   ASSERT_EQ(integer_trail->UpperBound(capacity), 10);
@@ -311,8 +312,8 @@ TEST(CumulativeTest, CapacityAndOptionalTask) {
       model.Add(NewOptionalInterval(-1000, 1000, 1, l));
   const IntegerVariable demand = model.Add(ConstantIntegerVariable(15));
   const IntegerVariable capacity = model.Add(ConstantIntegerVariable(10));
-  model.Add(Cumulative({interval}, {AffineExpression(demand)},
-                       AffineExpression(capacity)));
+  model.Add(Cumulative(/*enforcement_literals=*/{}, {interval},
+                       {AffineExpression(demand)}, AffineExpression(capacity)));
   ASSERT_TRUE(sat_solver->Propagate());
   ASSERT_FALSE(model.Get(Value(l)));
 }
diff --git a/ortools/sat/diffn.cc b/ortools/sat/diffn.cc
index fde8ee6a46..03faa7f93e 100644
--- a/ortools/sat/diffn.cc
+++ b/ortools/sat/diffn.cc
@@ -32,7 +32,6 @@
 #include "absl/log/vlog_is_on.h"
 #include "absl/numeric/bits.h"
 #include "absl/types/span.h"
-#include "ortools/base/stl_util.h"
 #include "ortools/sat/2d_distances_propagator.h"
 #include "ortools/sat/2d_mandatory_overlap_propagator.h"
 #include "ortools/sat/2d_orthogonal_packing.h"
@@ -101,9 +100,10 @@ IntegerVariable CreateVariableAtOrBelowMaxOf(
 
 // Add a cumulative relaxation. That is, on one dimension, it does not enforce
 // the rectangle aspect, allowing vertical slices to move freely.
-void AddDiffnCumulativeRelationOnX(SchedulingConstraintHelper* x,
-                                   SchedulingConstraintHelper* y,
-                                   Model* model) {
+void AddDiffnCumulativeRelationOnX(
+    absl::Span<const Literal> enforcement_literals,
+    SchedulingConstraintHelper* x, SchedulingConstraintHelper* y,
+    Model* model) {
   // Note that we only need one side!
   // We want something <= max_end - min_start
   //
@@ -148,15 +148,19 @@ void AddDiffnCumulativeRelationOnX(SchedulingConstraintHelper* x,
         0, CapSub(integer_trail->UpperBound(max_end_var).value(),
                   integer_trail->LowerBound(min_start_var).value())));
     const std::vector<int64_t> coeffs = {-capacity.coeff.value(), -1, 1};
-    model->Add(
-        WeightedSumGreaterOrEqual({capacity.var, min_start_var, max_end_var},
-                                  coeffs, capacity.constant.value()));
+    // TODO(user): is the conditional really needed?
+    model->Add(ConditionalWeightedSumGreaterOrEqual(
+        enforcement_literals, {capacity.var, min_start_var, max_end_var},
+        coeffs, capacity.constant.value()));
   }
 
   SchedulingDemandHelper* demands =
       model->GetOrCreate<IntervalsRepository>()->GetOrCreateDemandHelper(
           x, y->Sizes());
 
+  model->GetOrCreate<IntervalsRepository>()->RegisterCumulative(
+      {.capacity = capacity, .task_helper = x, .demand_helper = demands});
+
   // Propagator responsible for applying Timetabling filtering rule. It
   // increases the minimum of the start variables, decrease the maximum of the
   // end variables, and increase the minimum of the capacity variable.
@@ -177,12 +181,13 @@ void AddDiffnCumulativeRelationOnX(SchedulingConstraintHelper* x,
 
 }  // namespace
 
-void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
-                                 const std::vector<IntervalVariable>& y,
-                                 Model* model) {
+void AddNonOverlappingRectangles(
+    const std::vector<Literal>& enforcement_literals,
+    const std::vector<IntervalVariable>& x,
+    const std::vector<IntervalVariable>& y, Model* model) {
   IntervalsRepository* repository = model->GetOrCreate<IntervalsRepository>();
   NoOverlap2DConstraintHelper* helper_2d =
-      repository->GetOrCreate2DHelper(x, y);
+      repository->GetOrCreate2DHelper(enforcement_literals, x, y);
 
   GenericLiteralWatcher* const watcher =
       model->GetOrCreate<GenericLiteralWatcher>();
@@ -212,8 +217,10 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
       params.use_energetic_reasoning_in_no_overlap_2d();
 
   if (add_cumulative_relaxation) {
-    SchedulingConstraintHelper* x_helper = repository->GetOrCreateHelper(x);
-    SchedulingConstraintHelper* y_helper = repository->GetOrCreateHelper(y);
+    SchedulingConstraintHelper* x_helper =
+        repository->GetOrCreateHelper(enforcement_literals, x);
+    SchedulingConstraintHelper* y_helper =
+        repository->GetOrCreateHelper(enforcement_literals, y);
 
     // We must first check if the cumulative relaxation is possible.
     bool some_boxes_are_only_optional_on_x = false;
@@ -236,10 +243,12 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
       }
     }
     if (!some_boxes_are_only_optional_on_y) {
-      AddDiffnCumulativeRelationOnX(x_helper, y_helper, model);
+      AddDiffnCumulativeRelationOnX(enforcement_literals, x_helper, y_helper,
+                                    model);
     }
     if (!some_boxes_are_only_optional_on_x) {
-      AddDiffnCumulativeRelationOnX(y_helper, x_helper, model);
+      AddDiffnCumulativeRelationOnX(enforcement_literals, y_helper, x_helper,
+                                    model);
     }
   }
 
@@ -258,19 +267,29 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
 
   // Create all 2D "precedence" Booleans.
   //
-  // TODO(user): For now we only deal with mandatory boxes.
+  // The code will be sub-optimal for optional box with non-fixed sizes as we
+  // miss some constraint in that case.
+  //  TODO(user): For now we do not deal with optional boxes with
+  //  variable sizes.
   //
-  // TODO(user): Like we do for 1D, one way to scale this is to only create such
-  // Boolean dynamically as we need to take a decision, and the previously
-  // created one are all assigned. It is a bit trickier though because of
-  // the extra constraints between these Booleans. Maybe one easy step is to
-  // create all 4 Booleans for a given pair of boxes at once.
+  // TODO(user): Like we do for 1D, one way to scale this is to only
+  // create such Boolean dynamically as we need to take a decision, and
+  // the previously created one are all assigned. It is a bit trickier
+  // though because of the extra constraints between these Booleans. Maybe
+  // one easy step is to create all 4 Booleans for a given pair of boxes
+  // at once.
   //
-  // TODO(user): Tricky, it would be better to use the helper_2d instead of the
-  // general repository, however, as we add constraints, this propagates which
-  // might swap/change the underlying x_helper and y_helper...
+  // TODO(user): Tricky, it would be better to use the helper_2d instead
+  // of the general repository, however, as we add constraints, this
+  // propagates which might swap/change the underlying x_helper and
+  // y_helper...
+  //
+  // TODO(user): add support for enforcement_literals. The
+  // AddProblemClause below is easy to extend, but the AddAtMostOne calls
+  // are trickier...
   const int num_boxes = x.size();
-  if (num_boxes < params.no_overlap_2d_boolean_relations_limit()) {
+  if (num_boxes < params.no_overlap_2d_boolean_relations_limit() &&
+      enforcement_literals.empty()) {
     auto* implications = model->GetOrCreate<BinaryImplicationGraph>();
     auto* sat_solver = model->GetOrCreate<SatSolver>();
     auto* integer_trail = model->GetOrCreate<IntegerTrail>();
@@ -279,11 +298,22 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
     for (int i = 0; i < num_boxes; ++i) {
       if (repository->IsAbsent(x[i])) continue;
       if (repository->IsAbsent(y[i])) continue;
+      if ((repository->IsOptional(x[i]) || repository->IsOptional(y[i])) &&
+          (!integer_trail->IsFixed(repository->Size(x[i])) ||
+           !integer_trail->IsFixed(repository->Size(y[i])))) {
+        continue;
+      }
       for (int j = i + 1; j < num_boxes; ++j) {
         if (repository->IsAbsent(x[j])) continue;
         if (repository->IsAbsent(y[j])) continue;
+        if ((repository->IsOptional(x[j]) || repository->IsOptional(y[j])) &&
+            (!integer_trail->IsFixed(repository->Size(x[j])) ||
+             !integer_trail->IsFixed(repository->Size(y[j])))) {
+          continue;
+        }
 
-        // At most one of these two x options is true.
+        // At most one of these two x options is true if the sizes are fixed or
+        // if the boxes are not optional.
         const Literal x_ij = repository->GetOrCreatePrecedenceLiteral(
             repository->End(x[i]), repository->Start(x[j]));
         const Literal x_ji = repository->GetOrCreatePrecedenceLiteral(
@@ -295,7 +325,8 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
           return;
         }
 
-        // At most one of these two y options is true.
+        // At most one of these two y options is true if the sizes are fixed or
+        // if the boxes are not optional.
         const Literal y_ij = repository->GetOrCreatePrecedenceLiteral(
             repository->End(y[i]), repository->Start(y[j]));
         const Literal y_ji = repository->GetOrCreatePrecedenceLiteral(
@@ -321,7 +352,6 @@ void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
         if (repository->IsOptional(y[j])) {
           clause.push_back(repository->PresenceLiteral(y[j]).Negated());
         }
-        gtl::STLSortAndRemoveDuplicates(&clause);
         if (!sat_solver->AddProblemClause(clause)) {
           return;
         }
@@ -355,7 +385,7 @@ NonOverlappingRectanglesEnergyPropagator::
 
 bool NonOverlappingRectanglesEnergyPropagator::Propagate() {
   // TODO(user): double-check/revisit the algo for box of variable sizes.
-  const int num_boxes = helper_.NumBoxes();
+  if (!helper_.IsEnforced()) return true;
   if (!helper_.SynchronizeAndSetDirection()) return false;
 
   Rectangle bounding_box = {.x_min = std::numeric_limits<IntegerValue>::max(),
@@ -363,6 +393,7 @@ bool NonOverlappingRectanglesEnergyPropagator::Propagate() {
                             .y_min = std::numeric_limits<IntegerValue>::max(),
                             .y_max = std::numeric_limits<IntegerValue>::min()};
   std::vector<RectangleInRange> active_box_ranges;
+  const int num_boxes = helper_.NumBoxes();
   active_box_ranges.reserve(num_boxes);
   for (int box = 0; box < num_boxes; ++box) {
     if (!helper_.IsPresent(box)) continue;
@@ -869,7 +900,7 @@ bool NonOverlappingRectanglesDisjunctivePropagator::
     // propagation, so we can skip it here.
     if (!fast_propagation && boxes.size() <= 2) continue;
 
-    x_.ClearOtherHelper();
+    x_.SetExtraExplanationForItemCallback(nullptr);
     if (!x_.ResetFromSubset(*x, boxes)) return false;
 
     // Collect the common overlapping coordinates of all boxes.
@@ -891,8 +922,32 @@ bool NonOverlappingRectanglesDisjunctivePropagator::
     // it.
     const IntegerValue line_to_use_for_reason = FindCanonicalValue(lb, ub);
 
-    // Setup x_dim for propagation.
-    x_.SetOtherHelper(y, boxes, line_to_use_for_reason);
+    // Make sure we always add the reason for the line when propagating x.
+    x_.SetExtraExplanationForItemCallback(
+        [&boxes, y, line_to_use_for_reason](
+            absl::Span<const int> items, std::vector<Literal>* literal_reason,
+            std::vector<IntegerLiteral>* integer_reason) {
+          y->ResetReason();
+          if (items.size() > 5) {
+            // Build an explanation for all the boxes intersecting the line.
+            for (const int t : items) {
+              y->AddStartMaxReason(boxes[t], line_to_use_for_reason);
+              y->AddEndMinReason(boxes[t], line_to_use_for_reason + 1);
+            }
+          } else {
+            // For small problems we can build a stronger explanation that only
+            // requires that each box must overlap on y with all the others.
+            for (int i = 0; i < items.size(); ++i) {
+              for (int j = i + 1; j < items.size(); ++j) {
+                const int t = items[i];
+                const int u = items[j];
+                y->AddReasonForBeingBeforeAssumingNoOverlap(boxes[t], boxes[u]);
+                y->AddReasonForBeingBeforeAssumingNoOverlap(boxes[u], boxes[t]);
+              }
+            }
+          }
+          y->AppendAndResetReason(integer_reason, literal_reason);
+        });
 
     if (fast_propagation) {
       if (x_.NumTasks() == 2) {
@@ -922,6 +977,7 @@ bool NonOverlappingRectanglesDisjunctivePropagator::
 // - large problem with many 1000s boxes, but with only a small subset that is
 //   not fixed (mainly coming from LNS).
 bool NonOverlappingRectanglesDisjunctivePropagator::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   if (!helper_->SynchronizeAndSetDirection(true, true, false)) return false;
 
   // If we are "diving" we maintain the set of fixed boxes for which we know
@@ -978,6 +1034,7 @@ RectanglePairwisePropagator::~RectanglePairwisePropagator() {
 }
 
 bool RectanglePairwisePropagator::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   if (!helper_->SynchronizeAndSetDirection()) return false;
 
   num_calls_++;
diff --git a/ortools/sat/diffn.h b/ortools/sat/diffn.h
index b0fe1b09cb..9c63081cef 100644
--- a/ortools/sat/diffn.h
+++ b/ortools/sat/diffn.h
@@ -27,6 +27,7 @@
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/no_overlap_2d_helper.h"
+#include "ortools/sat/sat_base.h"
 #include "ortools/sat/sat_parameters.pb.h"
 #include "ortools/sat/scheduling_helpers.h"
 #include "ortools/sat/synchronization.h"
@@ -85,9 +86,10 @@ class NonOverlappingRectanglesEnergyPropagator : public PropagatorInterface {
 
 // Enforces that the boxes with corners in (x, y), (x + dx, y), (x, y + dy)
 // and (x + dx, y + dy) do not overlap.
-void AddNonOverlappingRectangles(const std::vector<IntervalVariable>& x,
-                                 const std::vector<IntervalVariable>& y,
-                                 Model* model);
+void AddNonOverlappingRectangles(
+    const std::vector<Literal>& enforcement_literals,
+    const std::vector<IntervalVariable>& x,
+    const std::vector<IntervalVariable>& y, Model* model);
 
 // Non overlapping rectangles. This includes box with zero-areas.
 // The following is forbidden:
diff --git a/ortools/sat/diffn_test.cc b/ortools/sat/diffn_test.cc
index 13f6b18874..cc8c07664f 100644
--- a/ortools/sat/diffn_test.cc
+++ b/ortools/sat/diffn_test.cc
@@ -62,7 +62,7 @@ int CountAllTwoBoxesSolutions(int n) {
   // fixed. So to not count too many solution with our code here, we disable
   // that. Note that alternatively, we could have used the cp_model.proto API
   // to do the same, and that should works even with this on.
-  AddNonOverlappingRectangles(x, y, &model);
+  AddNonOverlappingRectangles(/*enforcement_literals=*/{}, x, y, &model);
 
   int num_solutions_found = 0;
   auto* integer_trail = model.GetOrCreate<IntegerTrail>();
@@ -129,7 +129,7 @@ TEST(NonOverlappingRectanglesTest, SimpleCountingWithOptional) {
   // that. Note that alternatively, we could have used the cp_model.proto API
   // to do the same, and that should works even with this on.
   // TODO(user): Fix and run with add_cumulative_relaxation = true.
-  AddNonOverlappingRectangles(x, y, &model);
+  AddNonOverlappingRectangles(/*enforcement_literals=*/{}, x, y, &model);
 
   int num_solutions_found = 0;
   while (true) {
diff --git a/ortools/sat/diffn_util.cc b/ortools/sat/diffn_util.cc
index ad2f054b93..7bb8e668d9 100644
--- a/ortools/sat/diffn_util.cc
+++ b/ortools/sat/diffn_util.cc
@@ -40,7 +40,6 @@
 #include "absl/log/log.h"
 #include "absl/log/vlog_is_on.h"
 #include "absl/random/bit_gen_ref.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
 #include "ortools/base/stl_util.h"
@@ -48,6 +47,7 @@
 #include "ortools/graph/connected_components.h"
 #include "ortools/graph/strongly_connected_components.h"
 #include "ortools/sat/integer_base.h"
+#include "ortools/sat/scheduling_helpers.h"
 #include "ortools/sat/util.h"
 #include "ortools/util/fixed_shape_binary_tree.h"
 #include "ortools/util/integer_pq.h"
@@ -139,8 +139,8 @@ CompactVectorVector<int> GetOverlappingRectangleComponents(
 bool ReportEnergyConflict(Rectangle bounding_box, absl::Span<const int> boxes,
                           SchedulingConstraintHelper* x,
                           SchedulingConstraintHelper* y) {
-  x->ClearReason();
-  y->ClearReason();
+  x->ResetReason();
+  y->ResetReason();
   IntegerValue total_energy(0);
   for (const int b : boxes) {
     const IntegerValue x_min = x->ShiftedStartMin(b);
@@ -164,7 +164,7 @@ bool ReportEnergyConflict(Rectangle bounding_box, absl::Span<const int> boxes,
   }
 
   CHECK_GT(total_energy, bounding_box.Area());
-  x->ImportOtherReasons(*y);
+  x->ImportReasonsFromOther(*y);
   return x->ReportConflict();
 }
 
diff --git a/ortools/sat/disjunctive.cc b/ortools/sat/disjunctive.cc
index 869cf1b07e..ccc82cfdb7 100644
--- a/ortools/sat/disjunctive.cc
+++ b/ortools/sat/disjunctive.cc
@@ -19,6 +19,7 @@
 #include <vector>
 
 #include "absl/algorithm/container.h"
+#include "absl/base/log_severity.h"
 #include "absl/cleanup/cleanup.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
@@ -32,6 +33,7 @@
 #include "ortools/sat/precedences.h"
 #include "ortools/sat/sat_base.h"
 #include "ortools/sat/sat_parameters.pb.h"
+#include "ortools/sat/scheduling_helpers.h"
 #include "ortools/sat/timetable.h"
 #include "ortools/util/scheduling.h"
 #include "ortools/util/sort.h"
@@ -40,14 +42,16 @@
 namespace operations_research {
 namespace sat {
 
-void AddDisjunctive(const std::vector<IntervalVariable>& intervals,
+void AddDisjunctive(const std::vector<Literal>& enforcement_literals,
+                    const std::vector<IntervalVariable>& intervals,
                     Model* model) {
   // Depending on the parameters, create all pair of conditional precedences.
   // TODO(user): create them dynamically instead?
   const auto& params = *model->GetOrCreate<SatParameters>();
   if (intervals.size() <=
           params.max_size_to_create_precedence_literals_in_disjunctive() &&
-      params.use_strong_propagation_in_disjunctive()) {
+      params.use_strong_propagation_in_disjunctive() &&
+      enforcement_literals.empty()) {
     AddDisjunctiveWithBooleanPrecedencesOnly(intervals, model);
   }
 
@@ -66,22 +70,23 @@ void AddDisjunctive(const std::vector<IntervalVariable>& intervals,
     for (const IntervalVariable interval : intervals) {
       starts.push_back(repository->Start(interval));
     }
-    model->Add(AllDifferentOnBounds(starts));
+    model->Add(AllDifferentOnBounds(enforcement_literals, starts));
     return;
   }
 
   auto* watcher = model->GetOrCreate<GenericLiteralWatcher>();
-  if (intervals.size() > 2 && params.use_combined_no_overlap()) {
+  if (intervals.size() > 2 && params.use_combined_no_overlap() &&
+      enforcement_literals.empty()) {
     model->GetOrCreate<CombinedDisjunctive<true>>()->AddNoOverlap(intervals);
     model->GetOrCreate<CombinedDisjunctive<false>>()->AddNoOverlap(intervals);
     return;
   }
 
   SchedulingConstraintHelper* helper = repository->GetOrCreateHelper(
-      intervals, /*register_as_disjunctive_helper=*/true);
+      enforcement_literals, intervals, /*register_as_disjunctive_helper=*/true);
 
   // Experiments to use the timetable only to propagate the disjunctive.
-  if (/*DISABLES_CODE*/ (false)) {
+  if (/*DISABLES_CODE*/ (false && enforcement_literals.empty())) {
     const AffineExpression one(IntegerValue(1));
     std::vector<AffineExpression> demands(intervals.size(), one);
     SchedulingDemandHelper* demands_helper =
@@ -258,11 +263,15 @@ IntegerValue TaskSet::ComputeEndMin(int task_to_ignore,
 
 bool DisjunctiveWithTwoItems::Propagate() {
   DCHECK_EQ(helper_->NumTasks(), 2);
+  if (!helper_->IsEnforced()) return true;
   if (!helper_->SynchronizeAndSetTimeDirection(true)) return false;
 
   // We can't propagate anything if one of the interval is absent for sure.
   if (helper_->IsAbsent(0) || helper_->IsAbsent(1)) return true;
 
+  // We can't propagate anything for two intervals if neither are present.
+  if (!helper_->IsPresent(0) && !helper_->IsPresent(0)) return true;
+
   // Note that this propagation also take care of the "overload checker" part.
   // It also propagates as much as possible, even in the presence of task with
   // variable sizes.
@@ -274,12 +283,12 @@ bool DisjunctiveWithTwoItems::Propagate() {
   int task_before = 0;
   int task_after = 1;
 
-  const bool task_0_before_task_1 = helper_->StartMax(0) < helper_->EndMin(1);
-  const bool task_1_before_task_0 = helper_->StartMax(1) < helper_->EndMin(0);
+  const bool task_0_before_task_1 = helper_->TaskIsBeforeOrIsOverlapping(0, 1);
+  const bool task_1_before_task_0 = helper_->TaskIsBeforeOrIsOverlapping(1, 0);
 
   if (task_0_before_task_1 && task_1_before_task_0 &&
       helper_->IsPresent(task_before) && helper_->IsPresent(task_after)) {
-    helper_->ClearReason();
+    helper_->ResetReason();
     helper_->AddPresenceReason(task_before);
     helper_->AddPresenceReason(task_after);
     helper_->AddReasonForBeingBeforeAssumingNoOverlap(task_before, task_after);
@@ -296,40 +305,11 @@ bool DisjunctiveWithTwoItems::Propagate() {
     return true;
   }
 
-  if (helper_->IsPresent(task_before)) {
-    const IntegerValue end_min_before = helper_->EndMin(task_before);
-    if (helper_->StartMin(task_after) < end_min_before) {
-      // Reason for precedences if both present.
-      helper_->ClearReason();
-      helper_->AddReasonForBeingBeforeAssumingNoOverlap(task_before,
-                                                        task_after);
-
-      // Reason for the bound push.
-      helper_->AddPresenceReason(task_before);
-      helper_->AddEndMinReason(task_before, end_min_before);
-      if (!helper_->IncreaseStartMin(task_after, end_min_before)) {
-        return false;
-      }
-    }
+  helper_->ResetReason();
+  helper_->AddReasonForBeingBeforeAssumingNoOverlap(task_before, task_after);
+  if (!helper_->PushTaskOrderWhenPresent(task_before, task_after)) {
+    return false;
   }
-
-  if (helper_->IsPresent(task_after)) {
-    const IntegerValue start_max_after = helper_->StartMax(task_after);
-    if (helper_->EndMax(task_before) > start_max_after) {
-      // Reason for precedences if both present.
-      helper_->ClearReason();
-      helper_->AddReasonForBeingBeforeAssumingNoOverlap(task_before,
-                                                        task_after);
-
-      // Reason for the bound push.
-      helper_->AddPresenceReason(task_after);
-      helper_->AddStartMaxReason(task_after, start_max_after);
-      if (!helper_->DecreaseEndMax(task_before, start_max_after)) {
-        return false;
-      }
-    }
-  }
-
   return true;
 }
 
@@ -343,6 +323,7 @@ int DisjunctiveWithTwoItems::RegisterWith(GenericLiteralWatcher* watcher) {
 template <bool time_direction>
 CombinedDisjunctive<time_direction>::CombinedDisjunctive(Model* model)
     : helper_(model->GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{},
           model->GetOrCreate<IntervalsRepository>()->AllIntervals())) {
   task_to_disjunctives_.resize(helper_->NumTasks());
 
@@ -445,7 +426,7 @@ bool CombinedDisjunctive<time_direction>::Propagate() {
     // Same reason as DisjunctiveDetectablePrecedences.
     // TODO(user): Maybe factor out the code? It does require a function with a
     // lot of arguments though.
-    helper_->ClearReason();
+    helper_->ResetReason();
     const absl::Span<const TaskSet::Entry> sorted_tasks =
         task_sets_[best_d_index].SortedTasks();
     const IntegerValue window_start =
@@ -484,6 +465,7 @@ bool CombinedDisjunctive<time_direction>::Propagate() {
 }
 
 bool DisjunctiveOverloadChecker::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   stats_.OnPropagate();
   if (!helper_->SynchronizeAndSetTimeDirection(/*is_forward=*/true)) {
     ++stats_.num_conflicts;
@@ -493,18 +475,29 @@ bool DisjunctiveOverloadChecker::Propagate() {
   // We use this to detect precedence between task that must cause a push.
   TaskTime task_with_max_end_min = {0, kMinIntegerValue};
 
+  // We will process the task by increasing shifted_end_max, thus consuming task
+  // from the end of that vector.
+  absl::Span<const CachedTaskBounds>
+      task_by_increasing_negated_shifted_end_max =
+          helper_->TaskByIncreasingNegatedShiftedEndMax();
+
   // Split problem into independent part.
   //
   // Many propagators in this file use the same approach, we start by processing
-  // the task by increasing start-min, packing everything to the left. We then
-  // process each "independent" set of task separately. A task is independent
-  // from the one before it, if its start-min wasn't pushed.
+  // the task by increasing shifted start-min, packing everything to the left.
+  // We then process each "independent" set of task separately. A task is
+  // independent from the one before it, if its start-min wasn't pushed.
   //
   // This way, we get one or more window [window_start, window_end] so that for
   // all task in the window, [start_min, end_min] is inside the window, and the
   // end min of any set of task to the left is <= window_start, and the
-  // start_min of any task to the right is >= end_min.
-  IntegerValue window_end = kMinIntegerValue;
+  // start_min of any task to the right is >= window_end.
+
+  // We keep the best end_min for present task only and present task plus at
+  // most a single optional task.
+  IntegerValue end_min_of_present = kMinIntegerValue;
+  IntegerValue end_min_with_one_optional = kMinIntegerValue;
+
   IntegerValue relevant_end;
   int window_size = 0;
   int relevant_size = 0;
@@ -528,17 +521,12 @@ bool DisjunctiveOverloadChecker::Propagate() {
       // TODO(user): Actually, we just inferred a "not last" so we could check
       // for relevant_size > 2 potential propagation?
       //
-      // TODO(user): Can we detect and propagate all such relations easily and
-      // do a pass before this maybe? On a related note, because this
-      // propagator is not instantiated in both direction, we might miss some
-      // easy propag.
+      // Note that the DisjunctiveSimplePrecedences propagators will also
+      // detects such precedences between two tasks.
       const int to_push = task_with_max_end_min.task_index;
-      helper_->ClearReason();
-      helper_->AddPresenceReason(task);
+      helper_->ResetReason();
       helper_->AddReasonForBeingBeforeAssumingNoOverlap(task, to_push);
-      helper_->AddEndMinReason(task, end_min);
-
-      if (!helper_->IncreaseStartMin(to_push, end_min)) {
+      if (!helper_->PushTaskOrderWhenPresent(task, to_push)) {
         ++stats_.num_conflicts;
         return false;
       }
@@ -559,14 +547,29 @@ bool DisjunctiveOverloadChecker::Propagate() {
     }
 
     // Extend window.
-    if (start_min < window_end) {
+    const IntegerValue old_value = end_min_with_one_optional;
+    if (start_min < end_min_with_one_optional) {
       window[window_size++] = {task, start_min};
-      if (window_end > start_max) {
-        window_end += size_min;
-        relevant_size = window_size;
-        relevant_end = window_end;
+
+      if (helper_->IsPresent(presence_lit)) {
+        end_min_of_present =
+            std::max(start_min + size_min, end_min_of_present + size_min);
+        end_min_with_one_optional += size_min;
       } else {
-        window_end += size_min;
+        if (end_min_of_present == kMinIntegerValue) {
+          // only optional:
+          end_min_with_one_optional =
+              std::max(end_min_with_one_optional, start_min + size_min);
+        } else {
+          end_min_with_one_optional =
+              std::max(end_min_with_one_optional,
+                       std::max(end_min_of_present, start_min) + size_min);
+        }
+      }
+
+      if (old_value > start_max) {
+        relevant_size = window_size;
+        relevant_end = end_min_with_one_optional;
       }
       continue;
     }
@@ -574,7 +577,9 @@ bool DisjunctiveOverloadChecker::Propagate() {
     // Process current window.
     // We don't need to process the end of the window (after relevant_size)
     // because these interval can be greedily assembled in a feasible solution.
-    if (relevant_size > 0 && !PropagateSubwindow(relevant_size, relevant_end)) {
+    if (relevant_size > 0 &&
+        !PropagateSubwindow(relevant_size, relevant_end,
+                            &task_by_increasing_negated_shifted_end_max)) {
       ++stats_.num_conflicts;
       return false;
     }
@@ -588,16 +593,50 @@ bool DisjunctiveOverloadChecker::Propagate() {
     // Start of the next window.
     window_size = 0;
     window[window_size++] = {task, start_min};
-    window_end = start_min + size_min;
+
+    if (helper_->IsPresent(presence_lit)) {
+      end_min_of_present = start_min + size_min;
+      end_min_with_one_optional = end_min_of_present;
+    } else {
+      end_min_of_present = kMinIntegerValue;
+      end_min_with_one_optional = start_min + size_min;
+    }
+
     relevant_size = 0;
   }
 
   // Process last window.
-  if (relevant_size > 0 && !PropagateSubwindow(relevant_size, relevant_end)) {
+  if (relevant_size > 0 &&
+      !PropagateSubwindow(relevant_size, relevant_end,
+                          &task_by_increasing_negated_shifted_end_max)) {
     ++stats_.num_conflicts;
     return false;
   }
 
+  if (DEBUG_MODE) {
+    // This test that our "subwindow" logic is sound and we don't miss any
+    // conflict or propagation by splitting the intervals like this.
+    //
+    // TODO(user): I think we can come up with corner case where pushing a task
+    // absence forces another one to be present, which might create more
+    // propagation. This is the same reason why we might not reach a fixed point
+    // in one go. However this should be rare and that piece of code allowed me
+    // to fix many bug. So I left it as is, we can revisit if we starts to see
+    // crashes on our tests.
+    window_size = 0;
+    task_by_increasing_negated_shifted_end_max =
+        helper_->TaskByIncreasingNegatedShiftedEndMax();
+    for (const auto [task, presence_lit, start_min] :
+         helper_->TaskByIncreasingShiftedStartMin()) {
+      if (helper_->IsAbsent(presence_lit)) continue;
+      window[window_size++] = {task, start_min};
+    }
+    const int64_t saved = helper_->PropagationTimestamp();
+    CHECK(PropagateSubwindow(window_size, kMaxIntegerValue,
+                             &task_by_increasing_negated_shifted_end_max));
+    CHECK_EQ(saved, helper_->PropagationTimestamp());
+  }
+
   stats_.EndWithoutConflicts();
   return true;
 }
@@ -610,22 +649,21 @@ bool DisjunctiveOverloadChecker::Propagate() {
 // overload after every insertion, but we could use an upper bound of the
 // theta envelope to save us from checking the actual value.
 bool DisjunctiveOverloadChecker::PropagateSubwindow(
-    int relevant_size, IntegerValue global_window_end) {
-  // Set up theta tree and task_by_increasing_end_max_.
+    int relevant_size, IntegerValue global_window_end,
+    absl::Span<const CachedTaskBounds>*
+        task_by_increasing_negated_shifted_end_max) {
+  // Set up theta tree.
   int num_events = 0;
-  task_by_increasing_end_max_.clear();
   for (int i = 0; i < relevant_size; ++i) {
     // No point adding a task if its end_max is too large.
     const TaskTime& task_time = window_[i];
     const int task = task_time.task_index;
 
-    // We use the shifted end-max.
-    const IntegerValue end_max =
-        helper_->StartMax(task) + helper_->SizeMin(task);
+    // We use the shifted end-max which might be < EndMax().
+    const IntegerValue end_max = helper_->ShiftedEndMax(task);
     if (end_max < global_window_end) {
       window_[num_events] = task_time;
       task_to_event_[task] = num_events;
-      task_by_increasing_end_max_.push_back({task, end_max});
       ++num_events;
     }
   }
@@ -633,22 +671,32 @@ bool DisjunctiveOverloadChecker::PropagateSubwindow(
   theta_tree_.Reset(num_events);
 
   // Introduce events by increasing end_max, check for overloads.
-  // If end_max is the same, we want to add high start-min first.
-  absl::c_reverse(task_by_increasing_end_max_);
-  absl::c_stable_sort(task_by_increasing_end_max_);
-  for (const auto task_time : task_by_increasing_end_max_) {
-    const int current_task = task_time.task_index;
+  while (!task_by_increasing_negated_shifted_end_max->empty()) {
+    const auto [current_task, presence_lit, minus_shifted_end_max] =
+        task_by_increasing_negated_shifted_end_max->back();
+    const IntegerValue current_end = -minus_shifted_end_max;
+    DCHECK_EQ(current_end, helper_->ShiftedEndMax(current_task));
+    if (current_end >= global_window_end) return true;  // go to next window.
+    task_by_increasing_negated_shifted_end_max->remove_suffix(1);  // consume.
+
+    // Ignore task not part of that window.
+    // Note that we never clear task_to_event_, so it might contains garbage
+    // for the values that we didn't set above. However, we can easily check
+    // if task_to_event_[current_task] point to an element that we set above.
+    // This is a bit faster than clearing task_to_event_ on exit.
+    const int current_event = task_to_event_[current_task];
+    if (current_event < 0 || current_event >= num_events) continue;
+    if (window_[current_event].task_index != current_task) continue;
 
     // We filtered absent task while constructing the subwindow, but it is
     // possible that as we propagate task absence below, other task also become
     // absent (if they share the same presence Boolean).
-    if (helper_->IsAbsent(current_task)) continue;
+    if (helper_->IsAbsent(presence_lit)) continue;
 
     DCHECK_NE(task_to_event_[current_task], -1);
     {
-      const int current_event = task_to_event_[current_task];
       const IntegerValue energy_min = helper_->SizeMin(current_task);
-      if (helper_->IsPresent(current_task)) {
+      if (helper_->IsPresent(presence_lit)) {
         // TODO(user): Add max energy deduction for variable
         // sizes by putting the energy_max here and modifying the code
         // dealing with the optional envelope greater than current_end below.
@@ -660,10 +708,9 @@ bool DisjunctiveOverloadChecker::PropagateSubwindow(
       }
     }
 
-    const IntegerValue current_end = task_time.time;
     if (theta_tree_.GetEnvelope() > current_end) {
       // Explain failure with tasks in critical interval.
-      helper_->ClearReason();
+      helper_->ResetReason();
       const int critical_event =
           theta_tree_.GetMaxEventWithEnvelopeGreaterThan(current_end);
       const IntegerValue window_start = window_[critical_event].time;
@@ -686,7 +733,7 @@ bool DisjunctiveOverloadChecker::PropagateSubwindow(
       // Explain exclusion with tasks present in the critical interval.
       // TODO(user): This could be done lazily, like most of the loop to
       // compute the reasons in this file.
-      helper_->ClearReason();
+      helper_->ResetReason();
       int critical_event;
       int optional_event;
       IntegerValue available_energy;
@@ -728,7 +775,9 @@ bool DisjunctiveOverloadChecker::PropagateSubwindow(
 }
 
 int DisjunctiveOverloadChecker::RegisterWith(GenericLiteralWatcher* watcher) {
-  // This propagator reach the fix point in one pass.
+  // This propagator should mostly reach the fix point in one pass, except if
+  // pushing a task absence make another task present... So we still prefer to
+  // re-run it as it is relatively fast.
   const int id = watcher->Register(this);
   helper_->SetTimeDirection(/*is_forward=*/true);
   watcher->NotifyThatPropagatorMayNotReachFixedPointInOnePass(id);
@@ -744,6 +793,7 @@ int DisjunctiveSimplePrecedences::RegisterWith(GenericLiteralWatcher* watcher) {
 }
 
 bool DisjunctiveSimplePrecedences::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   stats_.OnPropagate();
 
   const bool current_direction = helper_->CurrentTimeIsForward();
@@ -766,17 +816,9 @@ bool DisjunctiveSimplePrecedences::Push(TaskTime before, int t) {
   const int t_before = before.task_index;
 
   DCHECK_NE(t_before, t);
-  helper_->ClearReason();
-  helper_->AddPresenceReason(t_before);
+  helper_->ResetReason();
   helper_->AddReasonForBeingBeforeAssumingNoOverlap(t_before, t);
-  helper_->AddEndMinReason(t_before, before.time);
-  if (!helper_->IncreaseStartMin(t, before.time)) {
-    return false;
-  }
-  if (helper_->CurrentDecisionLevel() == 0 && helper_->IsPresent(t_before) &&
-      helper_->IsPresent(t)) {
-    if (!helper_->NotifyLevelZeroPrecedence(t_before, t)) return false;
-  }
+  if (!helper_->PushTaskOrderWhenPresent(t_before, t)) return false;
   ++stats_.num_propagations;
   return true;
 }
@@ -834,7 +876,7 @@ bool DisjunctiveSimplePrecedences::PropagateOneDirection() {
         current_end_min = end_min;
       } else if (blocking_task != -1 && blocking_start_max < end_min) {
         // Conflict! the task is after the blocking_task but also before.
-        helper_->ClearReason();
+        helper_->ResetReason();
         helper_->AddPresenceReason(blocking_task);
         helper_->AddPresenceReason(t);
         helper_->AddReasonForBeingBeforeAssumingNoOverlap(blocking_task, t);
@@ -880,6 +922,7 @@ bool DisjunctiveSimplePrecedences::PropagateOneDirection() {
 }
 
 bool DisjunctiveDetectablePrecedences::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   stats_.OnPropagate();
   if (!helper_->SynchronizeAndSetTimeDirection(time_direction_)) {
     ++stats_.num_conflicts;
@@ -928,7 +971,7 @@ bool DisjunctiveDetectablePrecedences::Push(IntegerValue task_set_end_min,
                                             int t) {
   const int critical_index = task_set_.GetCriticalIndex();
   const absl::Span<const TaskSet::Entry> sorted_tasks = task_set_.SortedTasks();
-  helper_->ClearReason();
+  helper_->ResetReason();
 
   // We need:
   // - StartMax(ct) < EndMin(t) for the detectable precedence.
@@ -965,6 +1008,11 @@ bool DisjunctiveDetectablePrecedences::Push(IntegerValue task_set_end_min,
       helper_->AddReasonForBeingBeforeAssumingNoOverlap(ct, t);
       energy_of_task_before += sorted_tasks[i].size_min;
       min_slack = std::min(min_slack, dist);
+
+      // TODO(user): The reason in AddReasonForBeingBeforeAssumingNoOverlap()
+      // only account for dist == 0 !! If we want to use a stronger strictly
+      // positive distance, we actually need to explain it. Fix this.
+      min_slack = 0;
     } else {
       all_already_before = false;
       helper_->AddStartMaxReason(ct, end_min_if_present - 1);
@@ -1067,7 +1115,7 @@ bool DisjunctiveDetectablePrecedences::PropagateWithRanks() {
         current_end_min = end_min;
       } else if (blocking_task != -1 && blocking_start_max < end_min) {
         // Conflict! the task is after the blocking_task but also before.
-        helper_->ClearReason();
+        helper_->ResetReason();
         helper_->AddPresenceReason(blocking_task);
         helper_->AddPresenceReason(t);
         helper_->AddReasonForBeingBeforeAssumingNoOverlap(blocking_task, t);
@@ -1157,6 +1205,7 @@ int DisjunctiveDetectablePrecedences::RegisterWith(
 }
 
 bool DisjunctivePrecedences::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   stats_.OnPropagate();
   if (!helper_->SynchronizeAndSetTimeDirection(time_direction_)) {
     ++stats_.num_conflicts;
@@ -1275,7 +1324,7 @@ bool DisjunctivePrecedences::PropagateSubwindow() {
     // Note that this needs the items in indices_before_ to be sorted by
     // their shifted start min (it should be the case).
     int best_index = -1;
-    const IntegerValue current_var_lb = integer_trail_->LowerBound(var);
+    const IntegerValue current_var_lb = integer_trail_.LowerBound(var);
     IntegerValue best_new_lb = current_var_lb;
     IntegerValue min_offset_at_best = kMinIntegerValue;
     IntegerValue min_offset = kMaxIntegerValue;
@@ -1330,7 +1379,7 @@ bool DisjunctivePrecedences::PropagateSubwindow() {
     // Push?
     if (best_new_lb > current_var_lb) {
       DCHECK_NE(best_index, -1);
-      helper_->ClearReason();
+      helper_->ResetReason();
       const IntegerValue window_start =
           window_[indices_before_[best_index].first].time;
       for (int i = best_index; i < num_before; ++i) {
@@ -1343,9 +1392,7 @@ bool DisjunctivePrecedences::PropagateSubwindow() {
         // This is okay if a bit slow since we only do that when we push.
         const auto [expr, ub] = EncodeDifferenceLowerThan(
             helper_->Ends()[ct], var, -min_offset_at_best);
-        linear2_bounds_->AddReasonForUpperBoundLowerThan(
-            expr, ub, helper_->MutableLiteralReason(),
-            helper_->MutableIntegerReason());
+        helper_->AddReasonForUpperBoundLowerThan(expr, ub);
       }
       ++stats_.num_propagations;
       if (!helper_->PushIntegerLiteral(
@@ -1372,6 +1419,7 @@ int DisjunctivePrecedences::RegisterWith(GenericLiteralWatcher* watcher) {
 }
 
 bool DisjunctiveNotLast::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   stats_.OnPropagate();
   if (!helper_->SynchronizeAndSetTimeDirection(time_direction_)) {
     ++stats_.num_conflicts;
@@ -1536,7 +1584,7 @@ bool DisjunctiveNotLast::PropagateSubwindow() {
     DCHECK(largest_ct_start_max == kMinIntegerValue ||
            end_max > largest_ct_start_max);
     if (end_max > largest_ct_start_max) {
-      helper_->ClearReason();
+      helper_->ResetReason();
 
       const IntegerValue window_start = sorted_tasks[critical_index].start_min;
       for (int i = critical_index; i < sorted_tasks_size; ++i) {
@@ -1580,6 +1628,7 @@ int DisjunctiveNotLast::RegisterWith(GenericLiteralWatcher* watcher) {
 }
 
 bool DisjunctiveEdgeFinding::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   stats_.OnPropagate();
   const int num_tasks = helper_->NumTasks();
   if (!helper_->SynchronizeAndSetTimeDirection(time_direction_)) {
@@ -1698,7 +1747,7 @@ bool DisjunctiveEdgeFinding::PropagateSubwindow(IntegerValue window_end_min) {
     // Overload checking.
     const IntegerValue non_gray_end_min = theta_tree_.GetEnvelope();
     if (non_gray_end_min > non_gray_end_max) {
-      helper_->ClearReason();
+      helper_->ResetReason();
 
       // We need the reasons for the critical tasks to fall in:
       const int critical_event =
@@ -1783,7 +1832,7 @@ bool DisjunctiveEdgeFinding::PropagateSubwindow(IntegerValue window_end_min) {
         CHECK_GE(window_end, non_gray_end_max);
 
         // The non-gray part of the explanation as detailed above.
-        helper_->ClearReason();
+        helper_->ResetReason();
         bool all_before = true;
         for (int event = first_event; event < window_size; event++) {
           const int task = window_[event].task_index;
diff --git a/ortools/sat/disjunctive.h b/ortools/sat/disjunctive.h
index 442c5ebfb6..b3c8810ecf 100644
--- a/ortools/sat/disjunctive.h
+++ b/ortools/sat/disjunctive.h
@@ -27,13 +27,15 @@
 #include "absl/types/span.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
-#include "ortools/sat/intervals.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/precedences.h"
+#include "ortools/sat/sat_base.h"
+#include "ortools/sat/scheduling_helpers.h"
 #include "ortools/sat/synchronization.h"
 #include "ortools/sat/util.h"
 #include "ortools/util/scheduling.h"
 #include "ortools/util/strong_integers.h"
+#include "ortools/util/time_limit.h"
 
 namespace operations_research {
 namespace sat {
@@ -44,7 +46,8 @@ namespace sat {
 //
 // TODO(user): This is not completely true for empty intervals (start == end).
 // Make sure such intervals are ignored by the constraint.
-void AddDisjunctive(const std::vector<IntervalVariable>& intervals,
+void AddDisjunctive(const std::vector<Literal>& enforcement_literals,
+                    const std::vector<IntervalVariable>& intervals,
                     Model* model);
 
 // Creates Boolean variables for all the possible precedences of the form (task
@@ -187,14 +190,18 @@ class DisjunctiveOverloadChecker : public PropagatorInterface {
         window_(new TaskTime[helper->NumTasks()]),
         task_to_event_(new int[helper->NumTasks()]),
         stats_("DisjunctiveOverloadChecker", model) {
-    task_by_increasing_end_max_.ClearAndReserve(helper->NumTasks());
+    // This is just needed to prevent use of uninitialized values.
+    std::fill(task_to_event_.get(), task_to_event_.get() + helper->NumTasks(),
+              -1);
   }
 
   bool Propagate() final;
   int RegisterWith(GenericLiteralWatcher* watcher);
 
  private:
-  bool PropagateSubwindow(int relevant_size, IntegerValue global_window_end);
+  bool PropagateSubwindow(int relevant_size, IntegerValue global_window_end,
+                          absl::Span<const CachedTaskBounds>*
+                              task_by_increasing_negated_shifted_end_max);
 
   SchedulingConstraintHelper* helper_;
 
@@ -202,8 +209,6 @@ class DisjunctiveOverloadChecker : public PropagatorInterface {
   std::unique_ptr<TaskTime[]> window_;
   std::unique_ptr<int[]> task_to_event_;
 
-  FixedCapacityVector<TaskTime> task_by_increasing_end_max_;
-
   ThetaLambdaTree<IntegerValue> theta_tree_;
   PropagationStatistics stats_;
 };
@@ -268,7 +273,7 @@ class CombinedDisjunctive : public PropagatorInterface {
   explicit CombinedDisjunctive(Model* model);
 
   // After creation, this must be called for all the disjunctive constraints
-  // in the model.
+  // in the model which have no enforcement literals.
   void AddNoOverlap(absl::Span<const IntervalVariable> var);
 
   bool Propagate() final;
@@ -352,7 +357,7 @@ class DisjunctivePrecedences : public PropagatorInterface {
                          SchedulingConstraintHelper* helper, Model* model)
       : time_direction_(time_direction),
         helper_(helper),
-        integer_trail_(model->GetOrCreate<IntegerTrail>()),
+        integer_trail_(*model->GetOrCreate<IntegerTrail>()),
         precedence_relations_(model->GetOrCreate<EnforcedLinear2Bounds>()),
         linear2_bounds_(model->GetOrCreate<Linear2Bounds>()),
         time_limit_(model->GetOrCreate<TimeLimit>()),
@@ -370,7 +375,7 @@ class DisjunctivePrecedences : public PropagatorInterface {
 
   const bool time_direction_;
   SchedulingConstraintHelper* helper_;
-  IntegerTrail* integer_trail_;
+  const IntegerTrail& integer_trail_;
   EnforcedLinear2Bounds* precedence_relations_;
   Linear2Bounds* linear2_bounds_;
   TimeLimit* time_limit_;
diff --git a/ortools/sat/disjunctive_test.cc b/ortools/sat/disjunctive_test.cc
index 5fa0063cf8..8efee100c4 100644
--- a/ortools/sat/disjunctive_test.cc
+++ b/ortools/sat/disjunctive_test.cc
@@ -157,7 +157,7 @@ bool TestDisjunctivePropagation(absl::Span<const TaskWithDuration> input,
   EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
 
   const int initial_num_enqueues = integer_trail->num_enqueues();
-  AddDisjunctive(ids, &model);
+  AddDisjunctive(/*enforcement_literals=*/{}, ids, &model);
   if (!model.GetOrCreate<SatSolver>()->Propagate()) return false;
   CHECK_EQ(input.size(), expected.size());
   for (int i = 0; i < input.size(); ++i) {
@@ -261,7 +261,7 @@ TEST(DisjunctiveConstraintTest, Precedences) {
   ids.push_back(model.Add(NewInterval(kStart, kHorizon, 10)));
   ids.push_back(model.Add(NewInterval(kStart, kHorizon, 10)));
   ids.push_back(model.Add(NewInterval(kStart, kHorizon, 10)));
-  AddDisjunctive(ids, &model);
+  AddDisjunctive(/*enforcement_literals=*/{}, ids, &model);
 
   EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
   for (const IntervalVariable i : ids) {
@@ -291,7 +291,7 @@ TEST(SchedulingTest, Permutations) {
         model.Add(NewInterval(0, kNumIntervals, 1));
     intervals.push_back(interval);
   }
-  AddDisjunctive(intervals, &model);
+  AddDisjunctive(/*enforcement_literals=*/{}, intervals, &model);
 
   IntegerTrail* integer_trail = model.GetOrCreate<IntegerTrail>();
   IntervalsRepository* repository = model.GetOrCreate<IntervalsRepository>();
@@ -337,8 +337,9 @@ TEST(SchedulingTest, Permutations) {
 // Random tests with comparison with a simple time-decomposition encoding.
 // ============================================================================
 
-void AddDisjunctiveTimeDecomposition(absl::Span<const IntervalVariable> vars,
-                                     Model* model) {
+void AddDisjunctiveTimeDecomposition(
+    absl::Span<const Literal> /*enforcement_literals*/,
+    absl::Span<const IntervalVariable> vars, Model* model) {
   const int num_tasks = vars.size();
   IntegerTrail* integer_trail = model->GetOrCreate<IntegerTrail>();
   IntegerEncoder* encoder = model->GetOrCreate<IntegerEncoder>();
@@ -414,7 +415,8 @@ std::vector<OptionalTasksWithDuration> GenerateRandomInstance(
 
 int CountAllSolutions(
     absl::Span<const OptionalTasksWithDuration> instance,
-    const std::function<void(const std::vector<IntervalVariable>&, Model*)>&
+    const std::function<void(const std::vector<Literal>&,
+                             const std::vector<IntervalVariable>&, Model*)>&
         add_disjunctive) {
   Model model;
   std::vector<IntervalVariable> intervals;
@@ -428,7 +430,7 @@ int CountAllSolutions(
           model.Add(NewInterval(task.min_start, task.max_end, task.duration)));
     }
   }
-  add_disjunctive(intervals, &model);
+  add_disjunctive(/*enforcement_literals=*/{}, intervals, &model);
 
   int num_solutions_found = 0;
   while (true) {
@@ -464,7 +466,12 @@ TEST(DisjunctiveTest, RandomComparisonWithSimpleEncoding) {
         << InstanceDebugString(instance);
     EXPECT_EQ(
         CountAllSolutions(instance, AddDisjunctive),
-        CountAllSolutions(instance, AddDisjunctiveWithBooleanPrecedencesOnly))
+        CountAllSolutions(
+            instance,
+            [](const std::vector<Literal>& /*enforcement_literals*/,
+               const std::vector<IntervalVariable>& intervals, Model* model) {
+              AddDisjunctiveWithBooleanPrecedencesOnly(intervals, model);
+            }))
         << InstanceDebugString(instance);
   }
 }
@@ -506,7 +513,7 @@ TEST(DisjunctiveTest, Precedences) {
   std::vector<IntervalVariable> ids;
   ids.push_back(model.Add(NewInterval(0, 7, 3)));
   ids.push_back(model.Add(NewInterval(0, 7, 2)));
-  AddDisjunctive(ids, &model);
+  AddDisjunctive(/*enforcement_literals=*/{}, ids, &model);
 
   const IntegerVariable var = model.Add(NewIntegerVariable(0, 10));
   IntervalsRepository* intervals = model.GetOrCreate<IntervalsRepository>();
@@ -527,7 +534,7 @@ TEST(DisjunctiveTest, OptionalIntervalsWithLinkedPresence) {
   intervals.push_back(model.Add(NewOptionalInterval(0, 6, 2, alternative)));
   intervals.push_back(
       model.Add(NewOptionalInterval(0, 6, 4, alternative.Negated())));
-  AddDisjunctive(intervals, &model);
+  AddDisjunctive(/*enforcement_literals=*/{}, intervals, &model);
 
   int num_solutions_found = 0;
   while (true) {
diff --git a/ortools/sat/docs/README.md b/ortools/sat/docs/README.md
index 0bb13b170a..9e4116e4e4 100644
--- a/ortools/sat/docs/README.md
+++ b/ortools/sat/docs/README.md
@@ -28,35 +28,35 @@ The Python interface to the CP-SAT solver is implemented using two classes.
     access the solution found by the solve.
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/simple_sat_program.py
 """Simple solve."""
 from ortools.sat.python import cp_model
 
 
 def simple_sat_program():
-    """Minimal CP-SAT example to showcase calling the solver."""
-    # Creates the model.
-    model = cp_model.CpModel()
+  """Minimal CP-SAT example to showcase calling the solver."""
+  # Creates the model.
+  model = cp_model.CpModel()
 
-    # Creates the variables.
-    num_vals = 3
-    x = model.new_int_var(0, num_vals - 1, "x")
-    y = model.new_int_var(0, num_vals - 1, "y")
-    z = model.new_int_var(0, num_vals - 1, "z")
+  # Creates the variables.
+  num_vals = 3
+  x = model.new_int_var(0, num_vals - 1, 'x')
+  y = model.new_int_var(0, num_vals - 1, 'y')
+  z = model.new_int_var(0, num_vals - 1, 'z')
 
-    # Creates the constraints.
-    model.add(x != y)
+  # Creates the constraints.
+  model.add(x != y)
 
-    # Creates a solver and solves the model.
-    solver = cp_model.CpSolver()
-    status = solver.solve(model)
+  # Creates a solver and solves the model.
+  solver = cp_model.CpSolver()
+  status = solver.solve(model)
 
-    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
-        print(f"x = {solver.value(x)}")
-        print(f"y = {solver.value(y)}")
-        print(f"z = {solver.value(z)}")
-    else:
-        print("No solution found.")
+  if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+    print(f'x = {solver.value(x)}')
+    print(f'y = {solver.value(y)}')
+    print(f'z = {solver.value(z)}')
+  else:
+    print('No solution found.')
 
 
 simple_sat_program()
@@ -65,20 +65,22 @@ simple_sat_program()
 ### C++ code samples
 
 The interface to the C++ CP-SAT solver is implemented through the
-**CpModelBuilder** class described in *ortools/sat/cp_model.h*.
-This class is just a helper to fill in the cp_model protobuf.
+**CpModelBuilder** class described in
+*ortools/sat/cp_model.h*. This class is just a helper to fill
+in the cp_model protobuf.
 
 Calling Solve() method will return a CpSolverResponse protobuf that contains the
 solve status, the values for each variable in the model if solve was successful,
 and some metrics.
 
 ```cpp
+// Snippet from ortools/sat/samples/simple_sat_program.cc
 #include <stdlib.h>
 
-#include "absl/base/log_severity.h"
-#include "absl/log/globals.h"
 #include "ortools/base/init_google.h"
 #include "ortools/base/logging.h"
+#include "absl/base/log_severity.h"
+#include "absl/log/globals.h"
 #include "ortools/sat/cp_model.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_solver.h"
@@ -128,11 +130,12 @@ The Java code implements the same interface as the Python code, with a
 **CpModel** and a **CpSolver** class.
 
 ```java
+// Snippet from ortools/sat/samples/SimpleSatProgram.java
 package com.google.ortools.sat.samples;
 import com.google.ortools.Loader;
+import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.CpModel;
 import com.google.ortools.sat.CpSolver;
-import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.IntVar;
 
 /** Minimal CP-SAT example to showcase calling the solver. */
@@ -174,7 +177,8 @@ public final class SimpleSatProgram {
 The C\# code implements the same interface as the Python code, with a
 **CpModel** and a **CpSolver** class.
 
-```cs
+```csharp
+// Snippet from ortools/sat/samples/SimpleSatProgram.cs
 using System;
 using Google.OrTools.Sat;
 
@@ -217,14 +221,15 @@ public class SimpleSatProgram
 
 The interface to the CP-SAT solver is implemented through the **CpModelBuilder**
 described in the package **cpmodel** in
-*ortools/sat/go/cp_model.go*. This class is a helper to fill in
-the cp_model protobuf.
+*ortools/sat/go/cp_model.go*. This class is a helper to fill
+in the cp_model protobuf.
 
 Also within the **cpmodel** package is
 *ortools/sat/go/cp_model.go* which provides functions to solve
 the model along with helpers to access the solution found by the solver.
 
-```cs
+```go
+// Snippet from ortools/sat/samples/simple_sat_program.go
 // The simple_sat_program command is an example of a simple sat program.
 package main
 
@@ -233,6 +238,7 @@ import (
 
 	log "github.com/golang/glog"
 	"github.com/google/or-tools/ortools/sat/go/cpmodel"
+
 	cmpb "github.com/google/or-tools/ortools/sat/proto/cpmodel"
 )
 
@@ -272,4 +278,5 @@ func main() {
 		log.Exitf("simpleSatProgram returned with error: %v", err)
 	}
 }
+
 ```
diff --git a/ortools/sat/docs/boolean_logic.md b/ortools/sat/docs/boolean_logic.md
index 2f96caad1f..f024ec2140 100644
--- a/ortools/sat/docs/boolean_logic.md
+++ b/ortools/sat/docs/boolean_logic.md
@@ -21,7 +21,6 @@ negation of `x`.
 
 ```python
 # Snippet from ortools/sat/samples/literal_sample_sat.py
-#!/usr/bin/env python3
 """Code sample to demonstrate Boolean variable and literals."""
 
 
@@ -37,7 +36,6 @@ def literal_sample_sat():
 
 
 literal_sample_sat()
-
 ```
 
 ### C++ code
@@ -72,7 +70,6 @@ int main(int argc, char* argv[]) {
   operations_research::sat::LiteralSampleSat();
   return EXIT_SUCCESS;
 }
-
 ```
 
 ### Java code
@@ -96,15 +93,12 @@ public class LiteralSampleSat {
     System.out.println(notX);
   }
 }
-
 ```
 
 ### C\# code
 
 ```csharp
 // Snippet from ortools/sat/samples/LiteralSampleSat.cs
-
-
 using System;
 using Google.OrTools.Sat;
 
@@ -117,14 +111,12 @@ public class LiteralSampleSat
         ILiteral not_x = x.Not();
     }
 }
-
 ```
 
 ### Go code
 
 ```go
 // Snippet from ortools/sat/samples/literal_sample_sat.go
-
 // The literal_sample_sat command is a simple example of literals.
 package main
 
@@ -164,7 +156,6 @@ constraints. For instance, we can add a constraint Or(x, not(y)).
 
 ```python
 # Snippet from ortools/sat/samples/bool_or_sample_sat.py
-#!/usr/bin/env python3
 """Code sample to demonstrates a simple Boolean constraint."""
 
 
@@ -184,15 +175,12 @@ def bool_or_sample_sat():
 
 
 bool_or_sample_sat()
-
 ```
 
 ### C++ code
 
 ```cpp
 // Snippet from ortools/sat/samples/bool_or_sample_sat.cc
-
-
 #include <stdlib.h>
 
 #include "ortools/base/init_google.h"
@@ -223,15 +211,12 @@ int main(int argc, char* argv[]) {
   operations_research::sat::BoolOrSampleSat();
   return EXIT_SUCCESS;
 }
-
 ```
 
 ### Java code
 
 ```java
 // Snippet from ortools/sat/samples/BoolOrSampleSat.java
-
-
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -249,15 +234,12 @@ public class BoolOrSampleSat {
     model.addBoolOr(new Literal[] {x, y.not()});
   }
 }
-
 ```
 
 ### C\# code
 
 ```csharp
 // Snippet from ortools/sat/samples/BoolOrSampleSat.cs
-
-
 using System;
 using Google.OrTools.Sat;
 
@@ -273,15 +255,12 @@ public class BoolOrSampleSat
         model.AddBoolOr(new ILiteral[] { x, y.Not() });
     }
 }
-
 ```
 
 ### Go code
 
 ```go
 // Snippet from ortools/sat/samples/bool_or_sample_sat.go
-
-
 // The bool_or_sample_sat command is simple example of the BoolOr constraint.
 package main
 
@@ -327,7 +306,6 @@ then is written as Or(not b, x) and Or(not b, not y).
 
 ```python
 # Snippet from ortools/sat/samples/reified_sample_sat.py
-#!/usr/bin/env python3
 """Simple model with a reified constraint."""
 
 from ortools.sat.python import cp_model
@@ -354,16 +332,12 @@ def reified_sample_sat():
 
 
 reified_sample_sat()
-
 ```
 
 ### C++ code
 
 ```cpp
 // Snippet from ortools/sat/samples/reified_sample_sat.cc
-
-
-
 #include <stdlib.h>
 
 #include "ortools/base/init_google.h"
@@ -403,15 +377,12 @@ int main(int argc, char* argv[]) {
   operations_research::sat::ReifiedSampleSat();
   return EXIT_SUCCESS;
 }
-
 ```
 
 ### Java code
 
 ```java
 // Snippet from ortools/sat/samples/ReifiedSampleSat.java
-
-
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -450,15 +421,12 @@ public class ReifiedSampleSat {
     model.addBoolOr(new Literal[] {b.not(), y.not()});
   }
 }
-
 ```
 
 ### C\# code
 
 ```csharp
 // Snippet from ortools/sat/samples/ReifiedSampleSat.cs
-
-
 using System;
 using Google.OrTools.Sat;
 
@@ -484,15 +452,12 @@ public class ReifiedSampleSat
         model.AddBoolOr(new ILiteral[] { b.Not(), y.Not() });
     }
 }
-
 ```
 
 ### Go code
 
 ```go
 // Snippet from ortools/sat/samples/reified_sample_sat.go
-
-
 // The reified_sample_sat command is a simple example of implication constraints.
 package main
 
@@ -553,7 +518,6 @@ x = 1   y = 1   p = 1
 
 ```python
 # Snippet from ortools/sat/samples/boolean_product_sample_sat.py
-#!/usr/bin/env python3
 """Code sample that encodes the product of two Boolean variables."""
 
 
@@ -585,15 +549,12 @@ def boolean_product_sample_sat():
 
 
 boolean_product_sample_sat()
-
 ```
 
 ### Go code
 
 ```go
 // Snippet from ortools/sat/samples/boolean_product_sample_sat.go
-
-
 // The boolean_product_sample_sat command is a simple example of the product of two literals.
 package main
 
@@ -655,4 +616,5 @@ func main() {
 		log.Exitf("booleanProductSample returned with error: %v", err)
 	}
 }
+
 ```
diff --git a/ortools/sat/docs/channeling.md b/ortools/sat/docs/channeling.md
index 9582cedbdb..28cb3b4cbf 100644
--- a/ortools/sat/docs/channeling.md
+++ b/ortools/sat/docs/channeling.md
@@ -28,7 +28,7 @@ These are implemented using the `OnlyEnforceIf` method as shown below.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/channeling_sample_sat.py
 """Link integer constraints together."""
 
 
@@ -36,55 +36,57 @@ from ortools.sat.python import cp_model
 
 
 class VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):
-    """Print intermediate solutions."""
+  """Print intermediate solutions."""
 
-    def __init__(self, variables: list[cp_model.IntVar]):
-        cp_model.CpSolverSolutionCallback.__init__(self)
-        self.__variables = variables
+  def __init__(self, variables: list[cp_model.IntVar]):
+    cp_model.CpSolverSolutionCallback.__init__(self)
+    self.__variables = variables
 
-    def on_solution_callback(self) -> None:
-        for v in self.__variables:
-            print(f"{v}={self.value(v)}", end=" ")
-        print()
+  def on_solution_callback(self) -> None:
+    for v in self.__variables:
+      print(f'{v}={self.value(v)}', end=' ')
+    print()
 
 
 def channeling_sample_sat():
-    """Demonstrates how to link integer constraints together."""
+  """Demonstrates how to link integer constraints together."""
 
-    # Create the CP-SAT model.
-    model = cp_model.CpModel()
+  # Create the CP-SAT model.
+  model = cp_model.CpModel()
 
-    # Declare our two primary variables.
-    x = model.new_int_var(0, 10, "x")
-    y = model.new_int_var(0, 10, "y")
+  # Declare our two primary variables.
+  x = model.new_int_var(0, 10, 'x')
+  y = model.new_int_var(0, 10, 'y')
 
-    # Declare our intermediate boolean variable.
-    b = model.new_bool_var("b")
+  # Declare our intermediate boolean variable.
+  b = model.new_bool_var('b')
 
-    # Implement b == (x >= 5).
-    model.add(x >= 5).only_enforce_if(b)
-    model.add(x < 5).only_enforce_if(~b)
+  # Implement b == (x >= 5).
+  model.add(x >= 5).only_enforce_if(b)
+  model.add(x < 5).only_enforce_if(~b)
 
-    # Create our two half-reified constraints.
-    # First, b implies (y == 10 - x).
-    model.add(y == 10 - x).only_enforce_if(b)
-    # Second, not(b) implies y == 0.
-    model.add(y == 0).only_enforce_if(~b)
+  # Create our two half-reified constraints.
+  # First, b implies (y == 10 - x).
+  model.add(y == 10 - x).only_enforce_if(b)
+  # Second, not(b) implies y == 0.
+  model.add(y == 0).only_enforce_if(~b)
 
-    # Search for x values in increasing order.
-    model.add_decision_strategy([x], cp_model.CHOOSE_FIRST, cp_model.SELECT_MIN_VALUE)
+  # Search for x values in increasing order.
+  model.add_decision_strategy(
+      [x], cp_model.CHOOSE_FIRST, cp_model.SELECT_MIN_VALUE
+  )
 
-    # Create a solver and solve with a fixed search.
-    solver = cp_model.CpSolver()
+  # Create a solver and solve with a fixed search.
+  solver = cp_model.CpSolver()
 
-    # Force the solver to follow the decision strategy exactly.
-    solver.parameters.search_branching = cp_model.FIXED_SEARCH
-    # Enumerate all solutions.
-    solver.parameters.enumerate_all_solutions = True
+  # Force the solver to follow the decision strategy exactly.
+  solver.parameters.search_branching = cp_model.FIXED_SEARCH
+  # Enumerate all solutions.
+  solver.parameters.enumerate_all_solutions = True
 
-    # Search and print out all solutions.
-    solution_printer = VarArraySolutionPrinter([x, y, b])
-    solver.solve(model, solution_printer)
+  # Search and print out all solutions.
+  solution_printer = VarArraySolutionPrinter([x, y, b])
+  solver.solve(model, solution_printer)
 
 
 channeling_sample_sat()
@@ -93,13 +95,14 @@ channeling_sample_sat()
 ### C++ code
 
 ```cpp
+// Snippet from ortools/sat/samples/channeling_sample_sat.cc
 #include <stdlib.h>
 
+#include "ortools/base/init_google.h"
+#include "ortools/base/logging.h"
 #include "absl/base/log_severity.h"
 #include "absl/log/globals.h"
 #include "absl/types/span.h"
-#include "ortools/base/init_google.h"
-#include "ortools/base/logging.h"
 #include "ortools/sat/cp_model.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_solver.h"
@@ -162,18 +165,19 @@ int main(int argc, char* argv[]) {
 ### Java code
 
 ```java
+// Snippet from ortools/sat/samples/ChannelingSampleSat.java
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
+import com.google.ortools.sat.CpSolverStatus;
+import com.google.ortools.sat.DecisionStrategyProto;
+import com.google.ortools.sat.SatParameters;
 import com.google.ortools.sat.BoolVar;
 import com.google.ortools.sat.CpModel;
 import com.google.ortools.sat.CpSolver;
 import com.google.ortools.sat.CpSolverSolutionCallback;
-import com.google.ortools.sat.CpSolverStatus;
-import com.google.ortools.sat.DecisionStrategyProto;
 import com.google.ortools.sat.IntVar;
 import com.google.ortools.sat.LinearExpr;
-import com.google.ortools.sat.SatParameters;
 
 /** Link integer constraints together. */
 public final class ChannelingSampleSat {
@@ -199,7 +203,8 @@ public final class ChannelingSampleSat {
     model.addEquality(vars[1], 0).onlyEnforceIf(b.not());
 
     // Search for x values in increasing order.
-    model.addDecisionStrategy(new IntVar[] {vars[0]},
+    model.addDecisionStrategy(
+        new IntVar[] {vars[0]},
         DecisionStrategyProto.VariableSelectionStrategy.CHOOSE_FIRST,
         DecisionStrategyProto.DomainReductionStrategy.SELECT_MIN_VALUE);
 
@@ -212,22 +217,25 @@ public final class ChannelingSampleSat {
     solver.getParameters().setEnumerateAllSolutions(true);
 
     // Solve the problem with the printer callback.
-    CpSolverStatus unusedStatus = solver.solve(model, new CpSolverSolutionCallback() {
-      public CpSolverSolutionCallback init(IntVar[] variables) {
-        variableArray = variables;
-        return this;
-      }
+    CpSolverStatus unusedStatus =
+        solver.solve(
+            model,
+            new CpSolverSolutionCallback() {
+              public CpSolverSolutionCallback init(IntVar[] variables) {
+                variableArray = variables;
+                return this;
+              }
 
-      @Override
-      public void onSolutionCallback() {
-        for (IntVar v : variableArray) {
-          System.out.printf("%s=%d ", v.getName(), value(v));
-        }
-        System.out.println();
-      }
+              @Override
+              public void onSolutionCallback() {
+                for (IntVar v : variableArray) {
+                  System.out.printf("%s=%d ", v.getName(), value(v));
+                }
+                System.out.println();
+              }
 
-      private IntVar[] variableArray;
-    }.init(new IntVar[] {vars[0], vars[1], b}));
+              private IntVar[] variableArray;
+            }.init(new IntVar[] {vars[0], vars[1], b}));
   }
 
   private ChannelingSampleSat() {}
@@ -236,7 +244,8 @@ public final class ChannelingSampleSat {
 
 ### C\# code
 
-```cs
+```csharp
+// Snippet from ortools/sat/samples/ChannelingSampleSat.cs
 using System;
 using Google.OrTools.Sat;
 using Google.OrTools.Util;
@@ -305,7 +314,8 @@ public class ChannelingSampleSat
 
 ### Go code
 
-```cs
+```go
+// Snippet from ortools/sat/samples/channeling_sample_sat.go
 // The channeling_sample_sat command is a simple example of a channeling constraint.
 package main
 
@@ -313,10 +323,11 @@ import (
 	"fmt"
 
 	log "github.com/golang/glog"
+	"google.golang.org/protobuf/proto"
 	"github.com/google/or-tools/ortools/sat/go/cpmodel"
+
 	cmpb "github.com/google/or-tools/ortools/sat/proto/cpmodel"
 	sppb "github.com/google/or-tools/ortools/sat/proto/satparameters"
-	"google.golang.org/protobuf/proto"
 )
 
 func channelingSampleSat() error {
@@ -348,7 +359,7 @@ func channelingSampleSat() error {
 	if err != nil {
 		return fmt.Errorf("failed to instantiate the CP model: %w", err)
 	}
-	params := &sppb.SatParameters{
+		params := &sppb.SatParameters{
 		FillAdditionalSolutionsInResponse: proto.Bool(true),
 		EnumerateAllSolutions:             proto.Bool(true),
 		SolutionPoolSize:                  proto.Int32(11),
@@ -374,6 +385,7 @@ func main() {
 		log.Exitf("channelingSampleSat returned with error: %v", err)
 	}
 }
+
 ```
 
 This displays the following:
@@ -401,63 +413,63 @@ to the number of Boolean variables if they are all false.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/index_first_boolvar_true_sample_sat.py
 """Compute the index of the first Boolean variable set to true."""
 
 from ortools.sat.python import cp_model
 
 
 class VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):
-    """Print intermediate solutions."""
+  """Print intermediate solutions."""
 
-    def __init__(self, index: cp_model.IntVar, boolvars: list[cp_model.IntVar]):
-        cp_model.CpSolverSolutionCallback.__init__(self)
-        self.__index = index
-        self.__boolvars = boolvars
+  def __init__(self, index: cp_model.IntVar, boolvars: list[cp_model.IntVar]):
+    cp_model.CpSolverSolutionCallback.__init__(self)
+    self.__index = index
+    self.__boolvars = boolvars
 
-    def on_solution_callback(self) -> None:
-        line = ""
-        for v in self.__boolvars:
-            line += f"{self.value(v)}"
-        line += f" -> {self.value(self.__index)}"
-        print(line)
+  def on_solution_callback(self) -> None:
+    line = ''
+    for v in self.__boolvars:
+      line += f'{self.value(v)}'
+    line += f' -> {self.value(self.__index)}'
+    print(line)
 
 
 def index_of_first_bool_at_true_sample_sat():
-    """Compute the index of the first Boolean variable set to true."""
+  """Compute the index of the first Boolean variable set to true."""
 
-    # Model.
-    model = cp_model.CpModel()
+  # Model.
+  model = cp_model.CpModel()
 
-    # Variables
-    num_bool_vars = 5
-    bool_vars = [model.new_bool_var(f"{i}") for i in range(num_bool_vars)]
-    index = model.new_int_var(0, num_bool_vars, "index")
+  # Variables
+  num_bool_vars = 5
+  bool_vars = [model.new_bool_var(f'{i}') for i in range(num_bool_vars)]
+  index = model.new_int_var(0, num_bool_vars, 'index')
 
-    # Channeling between the index and the Boolean variables.
-    model.add_min_equality(
-        index,
-        [
-            num_bool_vars - bool_vars[i] * (num_bool_vars - i)
-            for i in range(num_bool_vars)
-        ],
-    )
+  # Channeling between the index and the Boolean variables.
+  model.add_min_equality(
+      index,
+      [
+          num_bool_vars - bool_vars[i] * (num_bool_vars - i)
+          for i in range(num_bool_vars)
+      ],
+  )
 
-    # Flip bool_vars in increasing order.
-    model.add_decision_strategy(
-        bool_vars, cp_model.CHOOSE_FIRST, cp_model.SELECT_MIN_VALUE
-    )
+  # Flip bool_vars in increasing order.
+  model.add_decision_strategy(
+      bool_vars, cp_model.CHOOSE_FIRST, cp_model.SELECT_MIN_VALUE
+  )
 
-    # Create a solver and solve with a fixed search.
-    solver = cp_model.CpSolver()
+  # Create a solver and solve with a fixed search.
+  solver = cp_model.CpSolver()
 
-    # Force the solver to follow the decision strategy exactly.
-    solver.parameters.search_branching = cp_model.FIXED_SEARCH
+  # Force the solver to follow the decision strategy exactly.
+  solver.parameters.search_branching = cp_model.FIXED_SEARCH
 
-    # Search and print out all solutions.
-    solver.parameters.enumerate_all_solutions = True
-    solution_printer = VarArraySolutionPrinter(index, bool_vars)
-    solver.solve(model, solution_printer)
+  # Search and print out all solutions.
+  solver.parameters.enumerate_all_solutions = True
+  solution_printer = VarArraySolutionPrinter(index, bool_vars)
+  solver.solve(model, solution_printer)
 
 
 index_of_first_bool_at_true_sample_sat()
@@ -513,13 +525,13 @@ items to pack into the bins. You would like to maximize the number of bins that
 can accept one emergency load of size 20.
 
 To do this, you need to maximize the number of bins that have a load less
-than 80.  In the code below, channeling is used to link the *load* and *slack*
+than 80. In the code below, channeling is used to link the *load* and *slack*
 variables together:
 
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/binpacking_problem_sat.py
 """Solves a binpacking problem using the CP-SAT solver."""
 
 
@@ -527,62 +539,62 @@ from ortools.sat.python import cp_model
 
 
 def binpacking_problem_sat():
-    """Solves a bin-packing problem using the CP-SAT solver."""
-    # Data.
-    bin_capacity = 100
-    slack_capacity = 20
-    num_bins = 5
-    all_bins = range(num_bins)
+  """Solves a bin-packing problem using the CP-SAT solver."""
+  # Data.
+  bin_capacity = 100
+  slack_capacity = 20
+  num_bins = 5
+  all_bins = range(num_bins)
 
-    items = [(20, 6), (15, 6), (30, 4), (45, 3)]
-    num_items = len(items)
-    all_items = range(num_items)
+  items = [(20, 6), (15, 6), (30, 4), (45, 3)]
+  num_items = len(items)
+  all_items = range(num_items)
 
-    # Model.
-    model = cp_model.CpModel()
+  # Model.
+  model = cp_model.CpModel()
 
-    # Main variables.
-    x = {}
-    for i in all_items:
-        num_copies = items[i][1]
-        for b in all_bins:
-            x[(i, b)] = model.new_int_var(0, num_copies, f"x[{i},{b}]")
-
-    # Load variables.
-    load = [model.new_int_var(0, bin_capacity, f"load[{b}]") for b in all_bins]
-
-    # Slack variables.
-    slacks = [model.new_bool_var(f"slack[{b}]") for b in all_bins]
-
-    # Links load and x.
+  # Main variables.
+  x = {}
+  for i in all_items:
+    num_copies = items[i][1]
     for b in all_bins:
-        model.add(load[b] == sum(x[(i, b)] * items[i][0] for i in all_items))
+      x[(i, b)] = model.new_int_var(0, num_copies, f'x[{i},{b}]')
 
-    # Place all items.
-    for i in all_items:
-        model.add(sum(x[(i, b)] for b in all_bins) == items[i][1])
+  # Load variables.
+  load = [model.new_int_var(0, bin_capacity, f'load[{b}]') for b in all_bins]
 
-    # Links load and slack through an equivalence relation.
-    safe_capacity = bin_capacity - slack_capacity
-    for b in all_bins:
-        # slack[b] => load[b] <= safe_capacity.
-        model.add(load[b] <= safe_capacity).only_enforce_if(slacks[b])
-        # not(slack[b]) => load[b] > safe_capacity.
-        model.add(load[b] > safe_capacity).only_enforce_if(~slacks[b])
+  # Slack variables.
+  slacks = [model.new_bool_var(f'slack[{b}]') for b in all_bins]
 
-    # Maximize sum of slacks.
-    model.maximize(sum(slacks))
+  # Links load and x.
+  for b in all_bins:
+    model.add(load[b] == sum(x[(i, b)] * items[i][0] for i in all_items))
 
-    # Solves and prints out the solution.
-    solver = cp_model.CpSolver()
-    status = solver.solve(model)
-    print(f"solve status: {solver.status_name(status)}")
-    if status == cp_model.OPTIMAL:
-        print(f"Optimal objective value: {solver.objective_value}")
-    print("Statistics")
-    print(f"  - conflicts : {solver.num_conflicts}")
-    print(f"  - branches  : {solver.num_branches}")
-    print(f"  - wall time : {solver.wall_time}s")
+  # Place all items.
+  for i in all_items:
+    model.add(sum(x[(i, b)] for b in all_bins) == items[i][1])
+
+  # Links load and slack through an equivalence relation.
+  safe_capacity = bin_capacity - slack_capacity
+  for b in all_bins:
+    # slack[b] => load[b] <= safe_capacity.
+    model.add(load[b] <= safe_capacity).only_enforce_if(slacks[b])
+    # not(slack[b]) => load[b] > safe_capacity.
+    model.add(load[b] > safe_capacity).only_enforce_if(~slacks[b])
+
+  # Maximize sum of slacks.
+  model.maximize(sum(slacks))
+
+  # Solves and prints out the solution.
+  solver = cp_model.CpSolver()
+  status = solver.solve(model)
+  print(f'solve status: {solver.status_name(status)}')
+  if status == cp_model.OPTIMAL:
+    print(f'Optimal objective value: {solver.objective_value}')
+  print('Statistics')
+  print(f'  - conflicts : {solver.num_conflicts}')
+  print(f'  - branches  : {solver.num_branches}')
+  print(f'  - wall time : {solver.wall_time}s')
 
 
 binpacking_problem_sat()
@@ -591,14 +603,15 @@ binpacking_problem_sat()
 ### C++ code
 
 ```cpp
+// Snippet from ortools/sat/samples/binpacking_problem_sat.cc
 #include <stdlib.h>
 
 #include <vector>
 
-#include "absl/base/log_severity.h"
-#include "absl/log/globals.h"
 #include "ortools/base/init_google.h"
 #include "ortools/base/logging.h"
+#include "absl/base/log_severity.h"
+#include "absl/log/globals.h"
 #include "ortools/sat/cp_model.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_solver.h"
@@ -685,12 +698,13 @@ int main(int argc, char* argv[]) {
 ### Java code
 
 ```java
+// Snippet from ortools/sat/samples/BinPackingProblemSat.java
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
+import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.CpModel;
 import com.google.ortools.sat.CpSolver;
-import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.IntVar;
 import com.google.ortools.sat.LinearExpr;
 import com.google.ortools.sat.LinearExprBuilder;
@@ -785,7 +799,8 @@ public class BinPackingProblemSat {
 
 ### C\# code
 
-```cs
+```csharp
+// Snippet from ortools/sat/samples/BinPackingProblemSat.cs
 using System;
 using Google.OrTools.Sat;
 
@@ -895,7 +910,8 @@ public class BinPackingProblemSat
 
 ### Go code
 
-```cs
+```go
+// Snippet from ortools/sat/samples/binpacking_problem_sat.go
 // The binpacking_problem_sat command is an example of a bin packing problem that uses channeling
 // constraints.
 package main
@@ -1004,4 +1020,5 @@ func main() {
 		log.Exitf("binpackingProblemSat returned with error: %v", err)
 	}
 }
+
 ```
diff --git a/ortools/sat/docs/integer_arithmetic.md b/ortools/sat/docs/integer_arithmetic.md
index fac52d3acd..c2c2b221f6 100644
--- a/ortools/sat/docs/integer_arithmetic.md
+++ b/ortools/sat/docs/integer_arithmetic.md
@@ -121,7 +121,6 @@ rabbits and pheasants are there?
 
 ```python
 # Snippet from ortools/sat/samples/rabbits_and_pheasants_sat.py
-#!/usr/bin/env python3
 """Rabbits and Pheasants quizz."""
 
 from ortools.sat.python import cp_model
@@ -148,12 +147,12 @@ def rabbits_and_pheasants_sat():
 
 
 rabbits_and_pheasants_sat()
-
 ```
 
 ### C++ code
 
 ```cpp
+// Snippet from ortools/sat/samples/rabbits_and_pheasants_sat.cc
 #include <stdlib.h>
 
 #include "ortools/base/init_google.h"
@@ -197,7 +196,6 @@ int main(int argc, char* argv[]) {
   operations_research::sat::RabbitsAndPheasantsSat();
   return EXIT_SUCCESS;
 }
-
 ```
 
 ### Java code
@@ -239,12 +237,12 @@ public class RabbitsAndPheasantsSat {
     }
   }
 }
-
 ```
 
 ### C\# code
 
 ```csharp
+// Snippet from ortools/sat/samples/RabbitsAndPheasantsSat.cs
 using System;
 using Google.OrTools.Sat;
 
@@ -272,11 +270,13 @@ public class RabbitsAndPheasantsSat
         }
     }
 }
+
 ```
 
 ### Go code
 
 ```go
+// Snippet from ortools/sat/samples/rabbits_and_pheasants_sat.go
 // The rabbits_and_pheasants_sat command is an example of a simple sat program that
 // solves the rabbits and pheasants problem.
 package main
@@ -371,7 +371,6 @@ x=20 expr=60
 
 ```python
 # Snippet from ortools/sat/samples/earliness_tardiness_cost_sample_sat.py
-#!/usr/bin/env python3
 """Encodes a convex piecewise linear function."""
 
 
@@ -447,7 +446,6 @@ def earliness_tardiness_cost_sample_sat():
 
 
 earliness_tardiness_cost_sample_sat()
-
 ```
 
 ### C++ code
@@ -523,7 +521,6 @@ int main(int argc, char* argv[]) {
   operations_research::sat::EarlinessTardinessCostSampleSat();
   return EXIT_SUCCESS;
 }
-
 ```
 
 ### Java code
@@ -617,7 +614,6 @@ public class EarlinessTardinessCostSampleSat {
             }.init(new IntVar[] {x, expr}));
   }
 }
-
 ```
 
 ### C\# code
@@ -693,7 +689,6 @@ public class EarlinessTardinessCostSampleSat
         solver.Solve(model, cb);
     }
 }
-
 ```
 
 ### Go code
@@ -815,7 +810,6 @@ x=20 expr=2
 
 ```python
 # Snippet from ortools/sat/samples/step_function_sample_sat.py
-#!/usr/bin/env python3
 """Implements a step function."""
 
 from ortools.sat.python import cp_model
@@ -895,7 +889,6 @@ def step_function_sample_sat():
 
 
 step_function_sample_sat()
-
 ```
 
 ### C++ code
@@ -984,7 +977,6 @@ int main(int argc, char* argv[]) {
   operations_research::sat::StepFunctionSampleSat();
   return EXIT_SUCCESS;
 }
-
 ```
 
 ### Java code
@@ -1173,14 +1165,12 @@ public class StepFunctionSampleSat
         solver.Solve(model, cb);
     }
 }
-
 ```
 
 ### Go code
 
 ```go
 // Snippet from ortools/sat/samples/step_function_sample_sat.go
-
 // The step_function_sample_sat command is an example of an implementation of a step function.
 package main
 
@@ -1302,7 +1292,6 @@ x=10 b=1 p=10
 
 ```python
 # Snippet from ortools/sat/samples/bool_and_int_var_product_sample_sat.py
-#!/usr/bin/env python3
 """Code sample that encodes the product of a Boolean and an integer variable."""
 
 from ortools.sat.python import cp_model
@@ -1362,7 +1351,6 @@ def bool_and_int_var_product_sample_sat():
 
 
 bool_and_int_var_product_sample_sat()
-
 ```
 
 ## Scanning the domain of variables.
@@ -1380,7 +1368,6 @@ reading back the values from the model.
 
 ```python
 # Snippet from ortools/sat/samples/all_different_except_zero_sample_sat.py
-#!/usr/bin/env python3
 """Implements AllDifferentExcept0 using atomic constraints."""
 
 import collections
@@ -1451,5 +1438,4 @@ def all_different_except_0():
 
 
 all_different_except_0()
-
 ```
diff --git a/ortools/sat/docs/model.md b/ortools/sat/docs/model.md
index a6c63d929e..7f32b9c30b 100644
--- a/ortools/sat/docs/model.md
+++ b/ortools/sat/docs/model.md
@@ -309,6 +309,7 @@ public class SolutionHintingSampleSat
 ### Go code
 
 ```go
+// Snippet from ortools/sat/samples/solution_hinting_sample_sat.go
 // The solution_hinting_sample_sat command is an example of setting solution hints on the model.
 package main
 
diff --git a/ortools/sat/docs/scheduling.md b/ortools/sat/docs/scheduling.md
index 79c1822a0a..60f193b237 100644
--- a/ortools/sat/docs/scheduling.md
+++ b/ortools/sat/docs/scheduling.md
@@ -25,7 +25,7 @@ Creating these intervals is illustrated in the following code snippets.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/interval_sample_sat.py
 """Code sample to demonstrates how to build an interval."""
 
 
@@ -33,28 +33,30 @@ from ortools.sat.python import cp_model
 
 
 def interval_sample_sat():
-    """Showcases how to build interval variables."""
-    model = cp_model.CpModel()
-    horizon = 100
+  """Showcases how to build interval variables."""
+  model = cp_model.CpModel()
+  horizon = 100
 
-    # An interval can be created from three affine expressions.
-    start_var = model.new_int_var(0, horizon, "start")
-    duration = 10  # Python cp/sat code accept integer variables or constants.
-    end_var = model.new_int_var(0, horizon, "end")
-    interval_var = model.new_interval_var(start_var, duration, end_var + 2, "interval")
+  # An interval can be created from three affine expressions.
+  start_var = model.new_int_var(0, horizon, 'start')
+  duration = 10  # Python cp/sat code accept integer variables or constants.
+  end_var = model.new_int_var(0, horizon, 'end')
+  interval_var = model.new_interval_var(
+      start_var, duration, end_var + 2, 'interval'
+  )
 
-    print(f"interval = {repr(interval_var)}")
+  print(f'interval = {repr(interval_var)}')
 
-    # If the size is fixed, a simpler version uses the start expression and the
-    # size.
-    fixed_size_interval_var = model.new_fixed_size_interval_var(
-        start_var, 10, "fixed_size_interval_var"
-    )
-    print(f"fixed_size_interval_var = {repr(fixed_size_interval_var)}")
+  # If the size is fixed, a simpler version uses the start expression and the
+  # size.
+  fixed_size_interval_var = model.new_fixed_size_interval_var(
+      start_var, 10, 'fixed_size_interval_var'
+  )
+  print(f'fixed_size_interval_var = {repr(fixed_size_interval_var)}')
 
-    # A fixed interval can be created using the same API.
-    fixed_interval = model.new_fixed_size_interval_var(5, 10, "fixed_interval")
-    print(f"fixed_interval = {repr(fixed_interval)}")
+  # A fixed interval can be created using the same API.
+  fixed_interval = model.new_fixed_size_interval_var(5, 10, 'fixed_interval')
+  print(f'fixed_interval = {repr(fixed_interval)}')
 
 
 interval_sample_sat()
@@ -63,12 +65,13 @@ interval_sample_sat()
 ### C++ code
 
 ```cpp
+// Snippet from ortools/sat/samples/interval_sample_sat.cc
 #include <stdlib.h>
 
-#include "absl/base/log_severity.h"
-#include "absl/log/globals.h"
 #include "ortools/base/init_google.h"
 #include "ortools/base/logging.h"
+#include "absl/base/log_severity.h"
+#include "absl/log/globals.h"
 #include "ortools/sat/cp_model.h"
 #include "ortools/util/sorted_interval_list.h"
 
@@ -125,6 +128,7 @@ int main(int argc, char* argv[]) {
 ### Java code
 
 ```java
+// Snippet from ortools/sat/samples/IntervalSampleSat.java
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -143,8 +147,12 @@ public class IntervalSampleSat {
     // An interval can be created from three affine expressions.
     IntVar startVar = model.newIntVar(0, horizon, "start");
     IntVar endVar = model.newIntVar(0, horizon, "end");
-    IntervalVar intervalVar = model.newIntervalVar(
-        startVar, LinearExpr.constant(10), LinearExpr.newBuilder().add(endVar).add(2), "interval");
+    IntervalVar intervalVar =
+        model.newIntervalVar(
+            startVar,
+            LinearExpr.constant(10),
+            LinearExpr.newBuilder().add(endVar).add(2),
+            "interval");
     System.out.println(intervalVar);
 
     // If the size is fixed, a simpler version uses the start expression and the size.
@@ -161,7 +169,8 @@ public class IntervalSampleSat {
 
 ### C\# code
 
-```cs
+```csharp
+// Snippet from ortools/sat/samples/IntervalSampleSat.cs
 using System;
 using Google.OrTools.Sat;
 
@@ -192,7 +201,8 @@ public class IntervalSampleSat
 
 ### Go code
 
-```cs
+```go
+// Snippet from ortools/sat/samples/interval_sample_sat.go
 // The interval_sample_sat_go command is a simple example of the Interval variable.
 package main
 
@@ -238,6 +248,7 @@ func main() {
 		log.Exitf("intervalSampleSat returned with error: %v", err)
 	}
 }
+
 ```
 
 ## Optional intervals
@@ -249,40 +260,40 @@ understand these presence literals, and correctly ignore inactive intervals.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/optional_interval_sample_sat.py
 """Code sample to demonstrates how to build an optional interval."""
 
 from ortools.sat.python import cp_model
 
 
 def optional_interval_sample_sat():
-    """Showcases how to build optional interval variables."""
-    model = cp_model.CpModel()
-    horizon = 100
+  """Showcases how to build optional interval variables."""
+  model = cp_model.CpModel()
+  horizon = 100
 
-    # An interval can be created from three affine expressions.
-    start_var = model.new_int_var(0, horizon, "start")
-    duration = 10  # Python cp/sat code accept integer variables or constants.
-    end_var = model.new_int_var(0, horizon, "end")
-    presence_var = model.new_bool_var("presence")
-    interval_var = model.new_optional_interval_var(
-        start_var, duration, end_var + 2, presence_var, "interval"
-    )
+  # An interval can be created from three affine expressions.
+  start_var = model.new_int_var(0, horizon, 'start')
+  duration = 10  # Python cp/sat code accept integer variables or constants.
+  end_var = model.new_int_var(0, horizon, 'end')
+  presence_var = model.new_bool_var('presence')
+  interval_var = model.new_optional_interval_var(
+      start_var, duration, end_var + 2, presence_var, 'interval'
+  )
 
-    print(f"interval = {repr(interval_var)}")
+  print(f'interval = {repr(interval_var)}')
 
-    # If the size is fixed, a simpler version uses the start expression and the
-    # size.
-    fixed_size_interval_var = model.new_optional_fixed_size_interval_var(
-        start_var, 10, presence_var, "fixed_size_interval_var"
-    )
-    print(f"fixed_size_interval_var = {repr(fixed_size_interval_var)}")
+  # If the size is fixed, a simpler version uses the start expression and the
+  # size.
+  fixed_size_interval_var = model.new_optional_fixed_size_interval_var(
+      start_var, 10, presence_var, 'fixed_size_interval_var'
+  )
+  print(f'fixed_size_interval_var = {repr(fixed_size_interval_var)}')
 
-    # A fixed interval can be created using the same API.
-    fixed_interval = model.new_optional_fixed_size_interval_var(
-        5, 10, presence_var, "fixed_interval"
-    )
-    print(f"fixed_interval = {repr(fixed_interval)}")
+  # A fixed interval can be created using the same API.
+  fixed_interval = model.new_optional_fixed_size_interval_var(
+      5, 10, presence_var, 'fixed_interval'
+  )
+  print(f'fixed_interval = {repr(fixed_interval)}')
 
 
 optional_interval_sample_sat()
@@ -291,12 +302,13 @@ optional_interval_sample_sat()
 ### C++ code
 
 ```cpp
+// Snippet from ortools/sat/samples/optional_interval_sample_sat.cc
 #include <stdlib.h>
 
-#include "absl/base/log_severity.h"
-#include "absl/log/globals.h"
 #include "ortools/base/init_google.h"
 #include "ortools/base/logging.h"
+#include "absl/base/log_severity.h"
+#include "absl/log/globals.h"
 #include "ortools/sat/cp_model.h"
 #include "ortools/util/sorted_interval_list.h"
 
@@ -350,6 +362,7 @@ int main(int argc, char* argv[]) {
 ### Java code
 
 ```java
+// Snippet from ortools/sat/samples/OptionalIntervalSampleSat.java
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -370,8 +383,13 @@ public class OptionalIntervalSampleSat {
     IntVar startVar = model.newIntVar(0, horizon, "start");
     IntVar endVar = model.newIntVar(0, horizon, "end");
     Literal presence = model.newBoolVar("presence");
-    IntervalVar intervalVar = model.newOptionalIntervalVar(startVar, LinearExpr.constant(10),
-        LinearExpr.newBuilder().add(endVar).add(2), presence, "interval");
+    IntervalVar intervalVar =
+        model.newOptionalIntervalVar(
+            startVar,
+            LinearExpr.constant(10),
+            LinearExpr.newBuilder().add(endVar).add(2),
+            presence,
+            "interval");
     System.out.println(intervalVar);
 
     // If the size is fixed, a simpler version uses the start expression, the size and the literal.
@@ -388,7 +406,8 @@ public class OptionalIntervalSampleSat {
 
 ### C\# code
 
-```cs
+```csharp
+// Snippet from ortools/sat/samples/OptionalIntervalSampleSat.cs
 using System;
 using Google.OrTools.Sat;
 
@@ -421,7 +440,8 @@ public class OptionalIntervalSampleSat
 
 ### Go code
 
-```cs
+```go
+// Snippet from ortools/sat/samples/optional_interval_sample_sat.go
 // The optional_interval_sample_sat command is an example of an Interval variable that is
 // marked as optional.
 package main
@@ -465,6 +485,7 @@ func main() {
 		log.Exitf("optionalIntervalSampleSat returned with error: %v", err)
 	}
 }
+
 ```
 
 ## Time relations between intervals
@@ -487,69 +508,71 @@ by the presence literals of the optional intervals used.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/interval_relations_sample_sat.py
 """Builds temporal relations between intervals."""
 
 from ortools.sat.python import cp_model
 
 
 def interval_relations_sample_sat():
-    """Showcases how to build temporal relations between intervals."""
-    model = cp_model.CpModel()
-    horizon = 100
+  """Showcases how to build temporal relations between intervals."""
+  model = cp_model.CpModel()
+  horizon = 100
 
-    # An interval can be created from three 1-var affine expressions.
-    start_var = model.new_int_var(0, horizon, "start")
-    duration = 10  # Python CP-SAT code accept integer variables or constants.
-    end_var = model.new_int_var(0, horizon, "end")
-    interval_var = model.new_interval_var(start_var, duration, end_var, "interval")
+  # An interval can be created from three 1-var affine expressions.
+  start_var = model.new_int_var(0, horizon, 'start')
+  duration = 10  # Python CP-SAT code accept integer variables or constants.
+  end_var = model.new_int_var(0, horizon, 'end')
+  interval_var = model.new_interval_var(
+      start_var, duration, end_var, 'interval'
+  )
 
-    # If the size is fixed, a simpler version uses the start expression and the
-    # size.
-    fixed_size_start_var = model.new_int_var(0, horizon, "fixed_start")
-    fixed_size_duration = 10
-    fixed_size_interval_var = model.new_fixed_size_interval_var(
-        fixed_size_start_var,
-        fixed_size_duration,
-        "fixed_size_interval_var",
-    )
+  # If the size is fixed, a simpler version uses the start expression and the
+  # size.
+  fixed_size_start_var = model.new_int_var(0, horizon, 'fixed_start')
+  fixed_size_duration = 10
+  fixed_size_interval_var = model.new_fixed_size_interval_var(
+      fixed_size_start_var,
+      fixed_size_duration,
+      'fixed_size_interval_var',
+  )
 
-    # An optional interval can be created from three 1-var affine expressions and
-    # a literal.
-    opt_start_var = model.new_int_var(0, horizon, "opt_start")
-    opt_duration = model.new_int_var(2, 6, "opt_size")
-    opt_end_var = model.new_int_var(0, horizon, "opt_end")
-    opt_presence_var = model.new_bool_var("opt_presence")
-    opt_interval_var = model.new_optional_interval_var(
-        opt_start_var, opt_duration, opt_end_var, opt_presence_var, "opt_interval"
-    )
+  # An optional interval can be created from three 1-var affine expressions and
+  # a literal.
+  opt_start_var = model.new_int_var(0, horizon, 'opt_start')
+  opt_duration = model.new_int_var(2, 6, 'opt_size')
+  opt_end_var = model.new_int_var(0, horizon, 'opt_end')
+  opt_presence_var = model.new_bool_var('opt_presence')
+  opt_interval_var = model.new_optional_interval_var(
+      opt_start_var, opt_duration, opt_end_var, opt_presence_var, 'opt_interval'
+  )
 
-    # If the size is fixed, a simpler version uses the start expression, the
-    # size, and the presence literal.
-    opt_fixed_size_start_var = model.new_int_var(0, horizon, "opt_fixed_start")
-    opt_fixed_size_duration = 10
-    opt_fixed_size_presence_var = model.new_bool_var("opt_fixed_presence")
-    opt_fixed_size_interval_var = model.new_optional_fixed_size_interval_var(
-        opt_fixed_size_start_var,
-        opt_fixed_size_duration,
-        opt_fixed_size_presence_var,
-        "opt_fixed_size_interval_var",
-    )
+  # If the size is fixed, a simpler version uses the start expression, the
+  # size, and the presence literal.
+  opt_fixed_size_start_var = model.new_int_var(0, horizon, 'opt_fixed_start')
+  opt_fixed_size_duration = 10
+  opt_fixed_size_presence_var = model.new_bool_var('opt_fixed_presence')
+  opt_fixed_size_interval_var = model.new_optional_fixed_size_interval_var(
+      opt_fixed_size_start_var,
+      opt_fixed_size_duration,
+      opt_fixed_size_presence_var,
+      'opt_fixed_size_interval_var',
+  )
 
-    # Simple precedence between two non optional intervals.
-    model.add(interval_var.start_expr() >= fixed_size_interval_var.end_expr())
+  # Simple precedence between two non optional intervals.
+  model.add(interval_var.start_expr() >= fixed_size_interval_var.end_expr())
 
-    # Synchronize start between two intervals (one optional, one not)
-    model.add(
-        interval_var.start_expr() == opt_interval_var.start_expr()
-    ).only_enforce_if(opt_presence_var)
+  # Synchronize start between two intervals (one optional, one not)
+  model.add(
+      interval_var.start_expr() == opt_interval_var.start_expr()
+  ).only_enforce_if(opt_presence_var)
 
-    # Exact delay between two optional intervals.
-    exact_delay: int = 5
-    model.add(
-        opt_interval_var.start_expr()
-        == opt_fixed_size_interval_var.end_expr() + exact_delay
-    ).only_enforce_if(opt_presence_var, opt_fixed_size_presence_var)
+  # Exact delay between two optional intervals.
+  exact_delay: int = 5
+  model.add(
+      opt_interval_var.start_expr()
+      == opt_fixed_size_interval_var.end_expr() + exact_delay
+  ).only_enforce_if(opt_presence_var, opt_fixed_size_presence_var)
 
 
 interval_relations_sample_sat()
@@ -567,59 +590,61 @@ weekends, making the final day as early as possible.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/no_overlap_sample_sat.py
 """Code sample to demonstrate how to build a NoOverlap constraint."""
 
 from ortools.sat.python import cp_model
 
 
 def no_overlap_sample_sat():
-    """No overlap sample with fixed activities."""
-    model = cp_model.CpModel()
-    horizon = 21  # 3 weeks.
+  """No overlap sample with fixed activities."""
+  model = cp_model.CpModel()
+  horizon = 21  # 3 weeks.
 
-    # Task 0, duration 2.
-    start_0 = model.new_int_var(0, horizon, "start_0")
-    duration_0 = 2  # Python cp/sat code accepts integer variables or constants.
-    end_0 = model.new_int_var(0, horizon, "end_0")
-    task_0 = model.new_interval_var(start_0, duration_0, end_0, "task_0")
-    # Task 1, duration 4.
-    start_1 = model.new_int_var(0, horizon, "start_1")
-    duration_1 = 4  # Python cp/sat code accepts integer variables or constants.
-    end_1 = model.new_int_var(0, horizon, "end_1")
-    task_1 = model.new_interval_var(start_1, duration_1, end_1, "task_1")
+  # Task 0, duration 2.
+  start_0 = model.new_int_var(0, horizon, 'start_0')
+  duration_0 = 2  # Python cp/sat code accepts integer variables or constants.
+  end_0 = model.new_int_var(0, horizon, 'end_0')
+  task_0 = model.new_interval_var(start_0, duration_0, end_0, 'task_0')
+  # Task 1, duration 4.
+  start_1 = model.new_int_var(0, horizon, 'start_1')
+  duration_1 = 4  # Python cp/sat code accepts integer variables or constants.
+  end_1 = model.new_int_var(0, horizon, 'end_1')
+  task_1 = model.new_interval_var(start_1, duration_1, end_1, 'task_1')
 
-    # Task 2, duration 3.
-    start_2 = model.new_int_var(0, horizon, "start_2")
-    duration_2 = 3  # Python cp/sat code accepts integer variables or constants.
-    end_2 = model.new_int_var(0, horizon, "end_2")
-    task_2 = model.new_interval_var(start_2, duration_2, end_2, "task_2")
+  # Task 2, duration 3.
+  start_2 = model.new_int_var(0, horizon, 'start_2')
+  duration_2 = 3  # Python cp/sat code accepts integer variables or constants.
+  end_2 = model.new_int_var(0, horizon, 'end_2')
+  task_2 = model.new_interval_var(start_2, duration_2, end_2, 'task_2')
 
-    # Weekends.
-    weekend_0 = model.new_interval_var(5, 2, 7, "weekend_0")
-    weekend_1 = model.new_interval_var(12, 2, 14, "weekend_1")
-    weekend_2 = model.new_interval_var(19, 2, 21, "weekend_2")
+  # Weekends.
+  weekend_0 = model.new_interval_var(5, 2, 7, 'weekend_0')
+  weekend_1 = model.new_interval_var(12, 2, 14, 'weekend_1')
+  weekend_2 = model.new_interval_var(19, 2, 21, 'weekend_2')
 
-    # No Overlap constraint.
-    model.add_no_overlap([task_0, task_1, task_2, weekend_0, weekend_1, weekend_2])
+  # No Overlap constraint.
+  model.add_no_overlap(
+      [task_0, task_1, task_2, weekend_0, weekend_1, weekend_2]
+  )
 
-    # Makespan objective.
-    obj = model.new_int_var(0, horizon, "makespan")
-    model.add_max_equality(obj, [end_0, end_1, end_2])
-    model.minimize(obj)
+  # Makespan objective.
+  obj = model.new_int_var(0, horizon, 'makespan')
+  model.add_max_equality(obj, [end_0, end_1, end_2])
+  model.minimize(obj)
 
-    # Solve model.
-    solver = cp_model.CpSolver()
-    status = solver.solve(model)
+  # Solve model.
+  solver = cp_model.CpSolver()
+  status = solver.solve(model)
 
-    if status == cp_model.OPTIMAL:
-        # Print out makespan and the start times for all tasks.
-        print(f"Optimal Schedule Length: {solver.objective_value}")
-        print(f"Task 0 starts at {solver.value(start_0)}")
-        print(f"Task 1 starts at {solver.value(start_1)}")
-        print(f"Task 2 starts at {solver.value(start_2)}")
-    else:
-        print(f"Solver exited with nonoptimal status: {status}")
+  if status == cp_model.OPTIMAL:
+    # Print out makespan and the start times for all tasks.
+    print(f'Optimal Schedule Length: {solver.objective_value}')
+    print(f'Task 0 starts at {solver.value(start_0)}')
+    print(f'Task 1 starts at {solver.value(start_1)}')
+    print(f'Task 2 starts at {solver.value(start_2)}')
+  else:
+    print(f'Solver exited with nonoptimal status: {status}')
 
 
 no_overlap_sample_sat()
@@ -628,15 +653,16 @@ no_overlap_sample_sat()
 ### C++ code
 
 ```cpp
+// Snippet from ortools/sat/samples/no_overlap_sample_sat.cc
 #include <stdlib.h>
 
 #include <cstdint>
 
+#include "ortools/base/init_google.h"
+#include "ortools/base/logging.h"
 #include "absl/base/log_severity.h"
 #include "absl/log/globals.h"
 #include "absl/types/span.h"
-#include "ortools/base/init_google.h"
-#include "ortools/base/logging.h"
 #include "ortools/sat/cp_model.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_solver.h"
@@ -716,12 +742,13 @@ int main(int argc, char* argv[]) {
 ### Java code
 
 ```java
+// Snippet from ortools/sat/samples/NoOverlapSampleSat.java
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
+import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.CpModel;
 import com.google.ortools.sat.CpSolver;
-import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.IntVar;
 import com.google.ortools.sat.IntervalVar;
 import com.google.ortools.sat.LinearExpr;
@@ -764,10 +791,13 @@ public class NoOverlapSampleSat {
 
     // Makespan objective.
     IntVar obj = model.newIntVar(0, horizon, "makespan");
-    model.addMaxEquality(obj,
-        new LinearExpr[] {LinearExpr.newBuilder().add(start0).add(duration0).build(),
-            LinearExpr.newBuilder().add(start1).add(duration1).build(),
-            LinearExpr.newBuilder().add(start2).add(duration2).build()});
+    model.addMaxEquality(
+        obj,
+        new LinearExpr[] {
+          LinearExpr.newBuilder().add(start0).add(duration0).build(),
+          LinearExpr.newBuilder().add(start1).add(duration1).build(),
+          LinearExpr.newBuilder().add(start2).add(duration2).build()
+        });
     model.minimize(obj);
 
     // Creates a solver and solves the model.
@@ -786,7 +816,8 @@ public class NoOverlapSampleSat {
 
 ### C\# code
 
-```cs
+```csharp
+// Snippet from ortools/sat/samples/NoOverlapSampleSat.cs
 using System;
 using Google.OrTools.Sat;
 
@@ -846,7 +877,8 @@ public class NoOverlapSampleSat
 
 ### Go code
 
-```cs
+```go
+// Snippet from ortools/sat/samples/no_overlap_sample_sat.go
 // The no_overlap_sample_sat command is an example of the NoOverlap constraints.
 package main
 
@@ -855,6 +887,7 @@ import (
 
 	log "github.com/golang/glog"
 	"github.com/google/or-tools/ortools/sat/go/cpmodel"
+
 	cmpb "github.com/google/or-tools/ortools/sat/proto/cpmodel"
 )
 
@@ -924,6 +957,7 @@ func main() {
 		log.Exitf("noOverlapSampleSat returned with error: %v", err)
 	}
 }
+
 ```
 
 ## Cumulative constraint with min and max capacity profile.
@@ -941,7 +975,7 @@ the complementary cumulative constraint.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/cumulative_variable_profile_sample_sat.py
 """Solves a scheduling problem with a min and max profile for the work load."""
 
 import io
@@ -953,9 +987,9 @@ from ortools.sat.python import cp_model
 
 
 def create_data_model() -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
-    """Creates the dataframes that describes the model."""
+  """Creates the dataframes that describes the model."""
 
-    max_load_str: str = """
+  max_load_str: str = """
   start_hour  max_load
      0            0
      2            0
@@ -971,7 +1005,7 @@ def create_data_model() -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
     22            0
   """
 
-    min_load_str: str = """
+  min_load_str: str = """
   start_hour  min_load
      0            0
      2            0
@@ -987,7 +1021,7 @@ def create_data_model() -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
     22            0
   """
 
-    tasks_str: str = """
+  tasks_str: str = """
   name  duration load  priority
    t1      60      3      2
    t2     180      2      1
@@ -1021,10 +1055,10 @@ def create_data_model() -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    t30     90      4      2
   """
 
-    max_load_df = pd.read_table(io.StringIO(max_load_str), sep=r"\s+")
-    min_load_df = pd.read_table(io.StringIO(min_load_str), sep=r"\s+")
-    tasks_df = pd.read_table(io.StringIO(tasks_str), index_col=0, sep=r"\s+")
-    return max_load_df, min_load_df, tasks_df
+  max_load_df = pd.read_table(io.StringIO(max_load_str), sep=r'\s+')
+  min_load_df = pd.read_table(io.StringIO(min_load_str), sep=r'\s+')
+  tasks_df = pd.read_table(io.StringIO(tasks_str), index_col=0, sep=r'\s+')
+  return max_load_df, min_load_df, tasks_df
 
 
 def check_solution(
@@ -1034,182 +1068,184 @@ def check_solution(
     period_length: int,
     horizon: int,
 ) -> bool:
-    """Checks the solution validity against the min and max load constraints."""
-    minutes_per_hour = 60
-    actual_load_profile = [0 for _ in range(horizon)]
-    min_load_profile = [0 for _ in range(horizon)]
-    max_load_profile = [0 for _ in range(horizon)]
+  """Checks the solution validity against the min and max load constraints."""
+  minutes_per_hour = 60
+  actual_load_profile = [0 for _ in range(horizon)]
+  min_load_profile = [0 for _ in range(horizon)]
+  max_load_profile = [0 for _ in range(horizon)]
 
-    # The complexity of the checker is linear in the number of time points, and
-    # should be improved.
-    for task in tasks:
-        for t in range(task[1]):
-            actual_load_profile[task[0] + t] += task[2]
-    for row in max_load_df.itertuples():
-        for t in range(period_length):
-            max_load_profile[row.start_hour * minutes_per_hour + t] = row.max_load
-    for row in min_load_df.itertuples():
-        for t in range(period_length):
-            min_load_profile[row.start_hour * minutes_per_hour + t] = row.min_load
+  # The complexity of the checker is linear in the number of time points, and
+  # should be improved.
+  for task in tasks:
+    for t in range(task[1]):
+      actual_load_profile[task[0] + t] += task[2]
+  for row in max_load_df.itertuples():
+    for t in range(period_length):
+      max_load_profile[row.start_hour * minutes_per_hour + t] = row.max_load
+  for row in min_load_df.itertuples():
+    for t in range(period_length):
+      min_load_profile[row.start_hour * minutes_per_hour + t] = row.min_load
 
-    for time in range(horizon):
-        if actual_load_profile[time] > max_load_profile[time]:
-            print(
-                f"actual load {actual_load_profile[time]} at time {time} is greater"
-                f" than max load {max_load_profile[time]}"
-            )
-            return False
-        if actual_load_profile[time] < min_load_profile[time]:
-            print(
-                f"actual load {actual_load_profile[time]} at time {time} is"
-                f" less than min load {min_load_profile[time]}"
-            )
-            return False
-    return True
+  for time in range(horizon):
+    if actual_load_profile[time] > max_load_profile[time]:
+      print(
+          f'actual load {actual_load_profile[time]} at time {time} is greater'
+          f' than max load {max_load_profile[time]}'
+      )
+      return False
+    if actual_load_profile[time] < min_load_profile[time]:
+      print(
+          f'actual load {actual_load_profile[time]} at time {time} is'
+          f' less than min load {min_load_profile[time]}'
+      )
+      return False
+  return True
 
 
 def main(_) -> None:
-    """Create the model and solves it."""
-    max_load_df, min_load_df, tasks_df = create_data_model()
+  """Create the model and solves it."""
+  max_load_df, min_load_df, tasks_df = create_data_model()
 
-    # Create the model.
-    model = cp_model.CpModel()
+  # Create the model.
+  model = cp_model.CpModel()
 
-    # Get the max capacity from the capacity dataframe.
-    max_load = max_load_df.max_load.max()
-    print(f"Max capacity = {max_load}")
-    print(f"#tasks = {len(tasks_df)}")
+  # Get the max capacity from the capacity dataframe.
+  max_load = max_load_df.max_load.max()
+  print(f'Max capacity = {max_load}')
+  print(f'#tasks = {len(tasks_df)}')
 
-    minutes_per_hour: int = 60
-    horizon: int = 24 * 60
+  minutes_per_hour: int = 60
+  horizon: int = 24 * 60
 
-    # Variables
-    starts = model.new_int_var_series(
-        name="starts",
-        lower_bounds=0,
-        upper_bounds=horizon - tasks_df.duration,
-        index=tasks_df.index,
-    )
-    performed = model.new_bool_var_series(name="performed", index=tasks_df.index)
+  # Variables
+  starts = model.new_int_var_series(
+      name='starts',
+      lower_bounds=0,
+      upper_bounds=horizon - tasks_df.duration,
+      index=tasks_df.index,
+  )
+  performed = model.new_bool_var_series(name='performed', index=tasks_df.index)
 
-    intervals = model.new_optional_fixed_size_interval_var_series(
-        name="intervals",
-        index=tasks_df.index,
-        starts=starts,
-        sizes=tasks_df.duration,
-        are_present=performed,
-    )
+  intervals = model.new_optional_fixed_size_interval_var_series(
+      name='intervals',
+      index=tasks_df.index,
+      starts=starts,
+      sizes=tasks_df.duration,
+      are_present=performed,
+  )
 
-    # Set up the max profile. We use fixed (intervals, demands) to fill in the
-    # space between the actual max load profile and the max capacity.
-    time_period_max_intervals = model.new_fixed_size_interval_var_series(
-        name="time_period_max_intervals",
-        index=max_load_df.index,
-        starts=max_load_df.start_hour * minutes_per_hour,
-        sizes=minutes_per_hour * 2,
-    )
-    time_period_max_heights = max_load - max_load_df.max_load
+  # Set up the max profile. We use fixed (intervals, demands) to fill in the
+  # space between the actual max load profile and the max capacity.
+  time_period_max_intervals = model.new_fixed_size_interval_var_series(
+      name='time_period_max_intervals',
+      index=max_load_df.index,
+      starts=max_load_df.start_hour * minutes_per_hour,
+      sizes=minutes_per_hour * 2,
+  )
+  time_period_max_heights = max_load - max_load_df.max_load
 
-    # Cumulative constraint for the max profile.
-    model.add_cumulative(
-        intervals.to_list() + time_period_max_intervals.to_list(),
-        tasks_df.load.to_list() + time_period_max_heights.to_list(),
-        max_load,
-    )
+  # Cumulative constraint for the max profile.
+  model.add_cumulative(
+      intervals.to_list() + time_period_max_intervals.to_list(),
+      tasks_df.load.to_list() + time_period_max_heights.to_list(),
+      max_load,
+  )
 
-    # Set up complemented intervals (from 0 to start, and from start + size to
-    # horizon).
-    prefix_intervals = model.new_optional_interval_var_series(
-        name="prefix_intervals",
-        index=tasks_df.index,
-        starts=0,
-        sizes=starts,
-        ends=starts,
-        are_present=performed,
-    )
+  # Set up complemented intervals (from 0 to start, and from start + size to
+  # horizon).
+  prefix_intervals = model.new_optional_interval_var_series(
+      name='prefix_intervals',
+      index=tasks_df.index,
+      starts=0,
+      sizes=starts,
+      ends=starts,
+      are_present=performed,
+  )
 
-    suffix_intervals = model.new_optional_interval_var_series(
-        name="suffix_intervals",
-        index=tasks_df.index,
-        starts=starts + tasks_df.duration,
-        sizes=horizon - starts - tasks_df.duration,
-        ends=horizon,
-        are_present=performed,
-    )
+  suffix_intervals = model.new_optional_interval_var_series(
+      name='suffix_intervals',
+      index=tasks_df.index,
+      starts=starts + tasks_df.duration,
+      sizes=horizon - starts - tasks_df.duration,
+      ends=horizon,
+      are_present=performed,
+  )
 
-    # Set up the min profile. We use complemented intervals to maintain the
-    # complement of the work load, and fixed intervals to enforce the min
-    # number of active workers per time period.
-    #
-    # Note that this works only if the max load cumulative is also added to the
-    # model.
-    time_period_min_intervals = model.new_fixed_size_interval_var_series(
-        name="time_period_min_intervals",
-        index=min_load_df.index,
-        starts=min_load_df.start_hour * minutes_per_hour,
-        sizes=minutes_per_hour * 2,
-    )
-    time_period_min_heights = min_load_df.min_load
+  # Set up the min profile. We use complemented intervals to maintain the
+  # complement of the work load, and fixed intervals to enforce the min
+  # number of active workers per time period.
+  #
+  # Note that this works only if the max load cumulative is also added to the
+  # model.
+  time_period_min_intervals = model.new_fixed_size_interval_var_series(
+      name='time_period_min_intervals',
+      index=min_load_df.index,
+      starts=min_load_df.start_hour * minutes_per_hour,
+      sizes=minutes_per_hour * 2,
+  )
+  time_period_min_heights = min_load_df.min_load
 
-    # We take into account optional intervals. The actual capacity of the min load
-    # cumulative is the sum of all the active demands.
-    sum_of_demands = sum(tasks_df.load)
-    complement_capacity = model.new_int_var(0, sum_of_demands, "complement_capacity")
-    model.add(complement_capacity == performed.dot(tasks_df.load))
+  # We take into account optional intervals. The actual capacity of the min load
+  # cumulative is the sum of all the active demands.
+  sum_of_demands = sum(tasks_df.load)
+  complement_capacity = model.new_int_var(
+      0, sum_of_demands, 'complement_capacity'
+  )
+  model.add(complement_capacity == performed.dot(tasks_df.load))
 
-    # Cumulative constraint for the min profile.
-    model.add_cumulative(
-        prefix_intervals.to_list()
-        + suffix_intervals.to_list()
-        + time_period_min_intervals.to_list(),
-        tasks_df.load.to_list()
-        + tasks_df.load.to_list()
-        + time_period_min_heights.to_list(),
-        complement_capacity,
-    )
+  # Cumulative constraint for the min profile.
+  model.add_cumulative(
+      prefix_intervals.to_list()
+      + suffix_intervals.to_list()
+      + time_period_min_intervals.to_list(),
+      tasks_df.load.to_list()
+      + tasks_df.load.to_list()
+      + time_period_min_heights.to_list(),
+      complement_capacity,
+  )
 
-    # Objective: maximize the value of performed intervals.
-    # 1 is the max priority.
-    max_priority = max(tasks_df.priority)
-    model.maximize(sum(performed * (max_priority + 1 - tasks_df.priority)))
+  # Objective: maximize the value of performed intervals.
+  # 1 is the max priority.
+  max_priority = max(tasks_df.priority)
+  model.maximize(sum(performed * (max_priority + 1 - tasks_df.priority)))
 
-    # Create the solver and solve the model.
-    solver = cp_model.CpSolver()
-    # solver.parameters.log_search_progress = True  # Uncomment to see the logs.
-    solver.parameters.num_workers = 16
-    solver.parameters.max_time_in_seconds = 30.0
-    status = solver.solve(model)
+  # Create the solver and solve the model.
+  solver = cp_model.CpSolver()
+  # solver.parameters.log_search_progress = True  # Uncomment to see the logs.
+  solver.parameters.num_workers = 16
+  solver.parameters.max_time_in_seconds = 30.0
+  status = solver.solve(model)
 
-    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
-        start_values = solver.values(starts)
-        performed_values = solver.boolean_values(performed)
-        tasks: list[tuple[int, int, int]] = []
-        for task in tasks_df.index:
-            if performed_values[task]:
-                print(
-                    f'task {task} duration={tasks_df["duration"][task]} '
-                    f'load={tasks_df["load"][task]} starts at {start_values[task]}'
-                )
-                tasks.append(
-                    (start_values[task], tasks_df.duration[task], tasks_df.load[task])
-                )
-            else:
-                print(f"task {task} is not performed")
-        assert check_solution(
-            tasks=tasks,
-            min_load_df=min_load_df,
-            max_load_df=max_load_df,
-            period_length=2 * minutes_per_hour,
-            horizon=horizon,
+  if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+    start_values = solver.values(starts)
+    performed_values = solver.boolean_values(performed)
+    tasks: list[tuple[int, int, int]] = []
+    for task in tasks_df.index:
+      if performed_values[task]:
+        print(
+            f'task {task} duration={tasks_df["duration"][task]} '
+            f'load={tasks_df["load"][task]} starts at {start_values[task]}'
         )
-    elif status == cp_model.INFEASIBLE:
-        print("No solution found")
-    else:
-        print("Something is wrong, check the status and the log of the solve")
+        tasks.append(
+            (start_values[task], tasks_df.duration[task], tasks_df.load[task])
+        )
+      else:
+        print(f'task {task} is not performed')
+    assert check_solution(
+        tasks=tasks,
+        min_load_df=min_load_df,
+        max_load_df=max_load_df,
+        period_length=2 * minutes_per_hour,
+        horizon=horizon,
+    )
+  elif status == cp_model.INFEASIBLE:
+    print('No solution found')
+  else:
+    print('Something is wrong, check the status and the log of the solve')
 
 
-if __name__ == "__main__":
-    app.run(main)
+if __name__ == '__main__':
+  app.run(main)
 ```
 
 ## Alternative resources for one interval
@@ -1233,7 +1269,7 @@ number of other intervals that precede it.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/ranking_sample_sat.py
 """Code sample to demonstrates how to rank intervals."""
 
 from ortools.sat.python import cp_model
@@ -1245,138 +1281,138 @@ def rank_tasks(
     presences: list[cp_model.BoolVarT],
     ranks: list[cp_model.IntVar],
 ) -> None:
-    """This method adds constraints and variables to links tasks and ranks.
+  """This method adds constraints and variables to links tasks and ranks.
 
-    This method assumes that all starts are disjoint, meaning that all tasks have
-    a strictly positive duration, and they appear in the same NoOverlap
-    constraint.
+  This method assumes that all starts are disjoint, meaning that all tasks have
+  a strictly positive duration, and they appear in the same NoOverlap
+  constraint.
 
-    Args:
-      model: The CpModel to add the constraints to.
-      starts: The array of starts variables of all tasks.
-      presences: The array of presence variables or constants of all tasks.
-      ranks: The array of rank variables of all tasks.
-    """
+  Args:
+    model: The CpModel to add the constraints to.
+    starts: The array of starts variables of all tasks.
+    presences: The array of presence variables or constants of all tasks.
+    ranks: The array of rank variables of all tasks.
+  """
 
-    num_tasks = len(starts)
-    all_tasks = range(num_tasks)
+  num_tasks = len(starts)
+  all_tasks = range(num_tasks)
 
-    # Creates precedence variables between pairs of intervals.
-    precedences: dict[tuple[int, int], cp_model.BoolVarT] = {}
-    for i in all_tasks:
-        for j in all_tasks:
-            if i == j:
-                precedences[(i, j)] = presences[i]
-            else:
-                prec = model.new_bool_var(f"{i} before {j}")
-                precedences[(i, j)] = prec
-                model.add(starts[i] < starts[j]).only_enforce_if(prec)
+  # Creates precedence variables between pairs of intervals.
+  precedences: dict[tuple[int, int], cp_model.BoolVarT] = {}
+  for i in all_tasks:
+    for j in all_tasks:
+      if i == j:
+        precedences[(i, j)] = presences[i]
+      else:
+        prec = model.new_bool_var(f'{i} before {j}')
+        precedences[(i, j)] = prec
+        model.add(starts[i] < starts[j]).only_enforce_if(prec)
 
-    # Treats optional intervals.
-    for i in range(num_tasks - 1):
-        for j in range(i + 1, num_tasks):
-            tmp_array: list[cp_model.BoolVarT] = [
-                precedences[(i, j)],
-                precedences[(j, i)],
-            ]
-            if not cp_model.object_is_a_true_literal(presences[i]):
-                tmp_array.append(~presences[i])
-                # Makes sure that if i is not performed, all precedences are false.
-                model.add_implication(~presences[i], ~precedences[(i, j)])
-                model.add_implication(~presences[i], ~precedences[(j, i)])
-            if not cp_model.object_is_a_true_literal(presences[j]):
-                tmp_array.append(~presences[j])
-                # Makes sure that if j is not performed, all precedences are false.
-                model.add_implication(~presences[j], ~precedences[(i, j)])
-                model.add_implication(~presences[j], ~precedences[(j, i)])
-            # The following bool_or will enforce that for any two intervals:
-            #    i precedes j or j precedes i or at least one interval is not
-            #        performed.
-            model.add_bool_or(tmp_array)
-            # Redundant constraint: it propagates early that at most one precedence
-            # is true.
-            model.add_implication(precedences[(i, j)], ~precedences[(j, i)])
-            model.add_implication(precedences[(j, i)], ~precedences[(i, j)])
+  # Treats optional intervals.
+  for i in range(num_tasks - 1):
+    for j in range(i + 1, num_tasks):
+      tmp_array: list[cp_model.BoolVarT] = [
+          precedences[(i, j)],
+          precedences[(j, i)],
+      ]
+      if not cp_model.object_is_a_true_literal(presences[i]):
+        tmp_array.append(~presences[i])
+        # Makes sure that if i is not performed, all precedences are false.
+        model.add_implication(~presences[i], ~precedences[(i, j)])
+        model.add_implication(~presences[i], ~precedences[(j, i)])
+      if not cp_model.object_is_a_true_literal(presences[j]):
+        tmp_array.append(~presences[j])
+        # Makes sure that if j is not performed, all precedences are false.
+        model.add_implication(~presences[j], ~precedences[(i, j)])
+        model.add_implication(~presences[j], ~precedences[(j, i)])
+      # The following bool_or will enforce that for any two intervals:
+      #    i precedes j or j precedes i or at least one interval is not
+      #        performed.
+      model.add_bool_or(tmp_array)
+      # Redundant constraint: it propagates early that at most one precedence
+      # is true.
+      model.add_implication(precedences[(i, j)], ~precedences[(j, i)])
+      model.add_implication(precedences[(j, i)], ~precedences[(i, j)])
 
-    # Links precedences and ranks.
-    for i in all_tasks:
-        model.add(ranks[i] == sum(precedences[(j, i)] for j in all_tasks) - 1)
+  # Links precedences and ranks.
+  for i in all_tasks:
+    model.add(ranks[i] == sum(precedences[(j, i)] for j in all_tasks) - 1)
 
 
 def ranking_sample_sat() -> None:
-    """Ranks tasks in a NoOverlap constraint."""
+  """Ranks tasks in a NoOverlap constraint."""
 
-    model = cp_model.CpModel()
-    horizon = 100
-    num_tasks = 4
-    all_tasks = range(num_tasks)
+  model = cp_model.CpModel()
+  horizon = 100
+  num_tasks = 4
+  all_tasks = range(num_tasks)
 
-    starts = []
-    ends = []
-    intervals = []
-    presences: list[cp_model.BoolVarT] = []
-    ranks = []
+  starts = []
+  ends = []
+  intervals = []
+  presences: list[cp_model.BoolVarT] = []
+  ranks = []
 
-    # Creates intervals, half of them are optional.
-    for t in all_tasks:
-        start = model.new_int_var(0, horizon, f"start[{t}]")
-        duration = t + 1
-        end = model.new_int_var(0, horizon, f"end[{t}]")
-        if t < num_tasks // 2:
-            interval = model.new_interval_var(start, duration, end, f"interval[{t}]")
-            presence = model.new_constant(1)
-        else:
-            presence = model.new_bool_var(f"presence[{t}]")
-            interval = model.new_optional_interval_var(
-                start, duration, end, presence, f"o_interval[{t}]"
-            )
-        starts.append(start)
-        ends.append(end)
-        intervals.append(interval)
-        presences.append(presence)
-
-        # Ranks = -1 if and only if the tasks is not performed.
-        ranks.append(model.new_int_var(-1, num_tasks - 1, f"rank[{t}]"))
-
-    # Adds NoOverlap constraint.
-    model.add_no_overlap(intervals)
-
-    # Adds ranking constraint.
-    rank_tasks(model, starts, presences, ranks)
-
-    # Adds a constraint on ranks.
-    model.add(ranks[0] < ranks[1])
-
-    # Creates makespan variable.
-    makespan = model.new_int_var(0, horizon, "makespan")
-    for t in all_tasks:
-        model.add(ends[t] <= makespan).only_enforce_if(presences[t])
-
-    # Minimizes makespan - fixed gain per tasks performed.
-    # As the fixed cost is less that the duration of the last interval,
-    # the solver will not perform the last interval.
-    model.minimize(2 * makespan - 7 * sum(presences[t] for t in all_tasks))
-
-    # Solves the model model.
-    solver = cp_model.CpSolver()
-    status = solver.solve(model)
-
-    if status == cp_model.OPTIMAL:
-        # Prints out the makespan and the start times and ranks of all tasks.
-        print(f"Optimal cost: {solver.objective_value}")
-        print(f"Makespan: {solver.value(makespan)}")
-        for t in all_tasks:
-            if solver.value(presences[t]):
-                print(
-                    f"Task {t} starts at {solver.value(starts[t])} "
-                    f"with rank {solver.value(ranks[t])}"
-                )
-            else:
-                print(
-                    f"Task {t} in not performed and ranked at {solver.value(ranks[t])}"
-                )
+  # Creates intervals, half of them are optional.
+  for t in all_tasks:
+    start = model.new_int_var(0, horizon, f'start[{t}]')
+    duration = t + 1
+    end = model.new_int_var(0, horizon, f'end[{t}]')
+    if t < num_tasks // 2:
+      interval = model.new_interval_var(start, duration, end, f'interval[{t}]')
+      presence = model.new_constant(1)
     else:
-        print(f"Solver exited with nonoptimal status: {status}")
+      presence = model.new_bool_var(f'presence[{t}]')
+      interval = model.new_optional_interval_var(
+          start, duration, end, presence, f'o_interval[{t}]'
+      )
+    starts.append(start)
+    ends.append(end)
+    intervals.append(interval)
+    presences.append(presence)
+
+    # Ranks = -1 if and only if the tasks is not performed.
+    ranks.append(model.new_int_var(-1, num_tasks - 1, f'rank[{t}]'))
+
+  # Adds NoOverlap constraint.
+  model.add_no_overlap(intervals)
+
+  # Adds ranking constraint.
+  rank_tasks(model, starts, presences, ranks)
+
+  # Adds a constraint on ranks.
+  model.add(ranks[0] < ranks[1])
+
+  # Creates makespan variable.
+  makespan = model.new_int_var(0, horizon, 'makespan')
+  for t in all_tasks:
+    model.add(ends[t] <= makespan).only_enforce_if(presences[t])
+
+  # Minimizes makespan - fixed gain per tasks performed.
+  # As the fixed cost is less that the duration of the last interval,
+  # the solver will not perform the last interval.
+  model.minimize(2 * makespan - 7 * sum(presences[t] for t in all_tasks))
+
+  # Solves the model model.
+  solver = cp_model.CpSolver()
+  status = solver.solve(model)
+
+  if status == cp_model.OPTIMAL:
+    # Prints out the makespan and the start times and ranks of all tasks.
+    print(f'Optimal cost: {solver.objective_value}')
+    print(f'Makespan: {solver.value(makespan)}')
+    for t in all_tasks:
+      if solver.value(presences[t]):
+        print(
+            f'Task {t} starts at {solver.value(starts[t])} '
+            f'with rank {solver.value(ranks[t])}'
+        )
+      else:
+        print(
+            f'Task {t} in not performed and ranked at {solver.value(ranks[t])}'
+        )
+  else:
+    print(f'Solver exited with nonoptimal status: {status}')
 
 
 ranking_sample_sat()
@@ -1385,16 +1421,17 @@ ranking_sample_sat()
 ### C++ code
 
 ```cpp
+// Snippet from ortools/sat/samples/ranking_sample_sat.cc
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <vector>
 
+#include "ortools/base/init_google.h"
+#include "ortools/base/logging.h"
 #include "absl/base/log_severity.h"
 #include "absl/log/globals.h"
 #include "absl/types/span.h"
-#include "ortools/base/init_google.h"
-#include "ortools/base/logging.h"
 #include "ortools/sat/cp_model.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_solver.h"
@@ -1543,13 +1580,14 @@ int main(int argc, char* argv[]) {
 ### Java code
 
 ```java
+// Snippet from ortools/sat/samples/RankingSampleSat.java
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
+import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.BoolVar;
 import com.google.ortools.sat.CpModel;
 import com.google.ortools.sat.CpSolver;
-import com.google.ortools.sat.CpSolverStatus;
 import com.google.ortools.sat.IntVar;
 import com.google.ortools.sat.IntervalVar;
 import com.google.ortools.sat.LinearExpr;
@@ -1645,13 +1683,15 @@ public class RankingSampleSat {
       int duration = t + 1;
       ends[t] = model.newIntVar(0, horizon, "end_" + t);
       if (t < numTasks / 2) {
-        intervals[t] = model.newIntervalVar(
-            starts[t], LinearExpr.constant(duration), ends[t], "interval_" + t);
+        intervals[t] =
+            model.newIntervalVar(
+                starts[t], LinearExpr.constant(duration), ends[t], "interval_" + t);
         presences[t] = trueLiteral;
       } else {
         presences[t] = model.newBoolVar("presence_" + t);
-        intervals[t] = model.newOptionalIntervalVar(
-            starts[t], LinearExpr.constant(duration), ends[t], presences[t], "o_interval_" + t);
+        intervals[t] =
+            model.newOptionalIntervalVar(
+                starts[t], LinearExpr.constant(duration), ends[t], presences[t], "o_interval_" + t);
       }
 
       // The rank will be -1 iff the task is not performed.
@@ -1695,8 +1735,9 @@ public class RankingSampleSat {
       System.out.println("Makespan: " + solver.value(makespan));
       for (int t = 0; t < numTasks; ++t) {
         if (solver.booleanValue(presences[t])) {
-          System.out.printf("Task %d starts at %d with rank %d%n", t, solver.value(starts[t]),
-              solver.value(ranks[t]));
+          System.out.printf(
+              "Task %d starts at %d with rank %d%n",
+              t, solver.value(starts[t]), solver.value(ranks[t]));
         } else {
           System.out.printf(
               "Task %d in not performed and ranked at %d%n", t, solver.value(ranks[t]));
@@ -1711,7 +1752,8 @@ public class RankingSampleSat {
 
 ### C\# code
 
-```cs
+```csharp
+// Snippet from ortools/sat/samples/RankingSampleSat.cs
 using System;
 using System.Collections.Generic;
 using Google.OrTools.Sat;
@@ -1874,7 +1916,8 @@ public class RankingSampleSat
 
 ### Go code
 
-```cs
+```go
+// Snippet from ortools/sat/samples/ranking_sample_sat.go
 // The ranking_sample_sat command is an example of ranking intervals in a NoOverlap constraint.
 package main
 
@@ -1883,6 +1926,7 @@ import (
 
 	log "github.com/golang/glog"
 	"github.com/google/or-tools/ortools/sat/go/cpmodel"
+
 	cmpb "github.com/google/or-tools/ortools/sat/proto/cpmodel"
 )
 
@@ -2027,6 +2071,7 @@ func main() {
 		log.Exitf("rankingSampleSat returned with error: %v", err)
 	}
 }
+
 ```
 
 ## Ranking tasks in a disjunctive resource with a circuit constraint.
@@ -2040,11 +2085,11 @@ need to take into account the case where no task is performed.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/ranking_circuit_sample_sat.py
 """Code sample to demonstrates how to rank intervals using a circuit."""
 
-from typing import List, Sequence
 
+from collections.abc import Sequence
 
 from ortools.sat.python import cp_model
 
@@ -2056,153 +2101,155 @@ def rank_tasks_with_circuit(
     presences: Sequence[cp_model.IntVar],
     ranks: Sequence[cp_model.IntVar],
 ) -> None:
-    """This method uses a circuit constraint to rank tasks.
+  """This method uses a circuit constraint to rank tasks.
 
-    This method assumes that all starts are disjoint, meaning that all tasks have
-    a strictly positive duration, and they appear in the same NoOverlap
-    constraint.
+  This method assumes that all starts are disjoint, meaning that all tasks have
+  a strictly positive duration, and they appear in the same NoOverlap
+  constraint.
 
-    To implement this ranking, we will create a dense graph with num_tasks + 1
-    nodes.
-    The extra node (with id 0) will be used to decide which task is first with
-    its only outgoing arc, and which task is last with its only incoming arc.
-    Each task i will be associated with id i + 1, and an arc between i + 1 and j +
-    1 indicates that j is the immediate successor of i.
+  To implement this ranking, we will create a dense graph with num_tasks + 1
+  nodes.
+  The extra node (with id 0) will be used to decide which task is first with
+  its only outgoing arc, and which task is last with its only incoming arc.
+  Each task i will be associated with id i + 1, and an arc between i + 1 and j +
+  1 indicates that j is the immediate successor of i.
 
-    The circuit constraint ensures there is at most 1 hamiltonian cycle of
-    length > 1. If no such path exists, then no tasks are active.
-    We also need to enforce that any hamiltonian cycle of size > 1 must contain
-    the node 0. And thus, there is a self loop on node 0 iff the circuit is empty.
+  The circuit constraint ensures there is at most 1 hamiltonian cycle of
+  length > 1. If no such path exists, then no tasks are active.
+  We also need to enforce that any hamiltonian cycle of size > 1 must contain
+  the node 0. And thus, there is a self loop on node 0 iff the circuit is empty.
 
-    Args:
-      model: The CpModel to add the constraints to.
-      starts: The array of starts variables of all tasks.
-      durations: the durations of all tasks.
-      presences: The array of presence variables of all tasks.
-      ranks: The array of rank variables of all tasks.
-    """
+  Args:
+    model: The CpModel to add the constraints to.
+    starts: The array of starts variables of all tasks.
+    durations: the durations of all tasks.
+    presences: The array of presence variables of all tasks.
+    ranks: The array of rank variables of all tasks.
+  """
 
-    num_tasks = len(starts)
-    all_tasks = range(num_tasks)
+  num_tasks = len(starts)
+  all_tasks = range(num_tasks)
 
-    arcs: List[cp_model.ArcT] = []
-    for i in all_tasks:
-        # if node i is first.
-        start_lit = model.new_bool_var(f"start_{i}")
-        arcs.append((0, i + 1, start_lit))
-        model.add(ranks[i] == 0).only_enforce_if(start_lit)
+  arcs: list[cp_model.ArcT] = []
+  for i in all_tasks:
+    # if node i is first.
+    start_lit = model.new_bool_var(f'start_{i}')
+    arcs.append((0, i + 1, start_lit))
+    model.add(ranks[i] == 0).only_enforce_if(start_lit)
 
-        # As there are no other constraints on the problem, we can add this
-        # redundant constraint.
-        model.add(starts[i] == 0).only_enforce_if(start_lit)
+    # As there are no other constraints on the problem, we can add this
+    # redundant constraint.
+    model.add(starts[i] == 0).only_enforce_if(start_lit)
 
-        # if node i is last.
-        end_lit = model.new_bool_var(f"end_{i}")
-        arcs.append((i + 1, 0, end_lit))
+    # if node i is last.
+    end_lit = model.new_bool_var(f'end_{i}')
+    arcs.append((i + 1, 0, end_lit))
 
-        for j in all_tasks:
-            if i == j:
-                arcs.append((i + 1, i + 1, ~presences[i]))
-                model.add(ranks[i] == -1).only_enforce_if(~presences[i])
-            else:
-                literal = model.new_bool_var(f"arc_{i}_to_{j}")
-                arcs.append((i + 1, j + 1, literal))
-                model.add(ranks[j] == ranks[i] + 1).only_enforce_if(literal)
+    for j in all_tasks:
+      if i == j:
+        arcs.append((i + 1, i + 1, ~presences[i]))
+        model.add(ranks[i] == -1).only_enforce_if(~presences[i])
+      else:
+        literal = model.new_bool_var(f'arc_{i}_to_{j}')
+        arcs.append((i + 1, j + 1, literal))
+        model.add(ranks[j] == ranks[i] + 1).only_enforce_if(literal)
 
-                # To perform the transitive reduction from precedences to successors,
-                # we need to tie the starts of the tasks with 'literal'.
-                # In a pure problem, the following inequality could be an equality.
-                # It is not true in general.
-                #
-                # Note that we could use this literal to penalize the transition, add an
-                # extra delay to the precedence.
-                model.add(starts[j] >= starts[i] + durations[i]).only_enforce_if(
-                    literal
-                )
+        # To perform the transitive reduction from precedences to successors,
+        # we need to tie the starts of the tasks with 'literal'.
+        # In a pure problem, the following inequality could be an equality.
+        # It is not true in general.
+        #
+        # Note that we could use this literal to penalize the transition, add an
+        # extra delay to the precedence.
+        model.add(starts[j] >= starts[i] + durations[i]).only_enforce_if(
+            literal
+        )
 
-    # Manage the empty circuit
-    empty = model.new_bool_var("empty")
-    arcs.append((0, 0, empty))
+  # Manage the empty circuit
+  empty = model.new_bool_var('empty')
+  arcs.append((0, 0, empty))
 
-    for i in all_tasks:
-        model.add_implication(empty, ~presences[i])
+  for i in all_tasks:
+    model.add_implication(empty, ~presences[i])
 
-    # Add the circuit constraint.
-    model.add_circuit(arcs)
+  # Add the circuit constraint.
+  model.add_circuit(arcs)
 
 
 def ranking_sample_sat() -> None:
-    """Ranks tasks in a NoOverlap constraint."""
+  """Ranks tasks in a NoOverlap constraint."""
 
-    model = cp_model.CpModel()
-    horizon = 100
-    num_tasks = 4
-    all_tasks = range(num_tasks)
+  model = cp_model.CpModel()
+  horizon = 100
+  num_tasks = 4
+  all_tasks = range(num_tasks)
 
-    starts = []
-    durations = []
-    intervals = []
-    presences = []
-    ranks = []
+  starts = []
+  durations = []
+  intervals = []
+  presences = []
+  ranks = []
 
-    # Creates intervals, half of them are optional.
+  # Creates intervals, half of them are optional.
+  for t in all_tasks:
+    start = model.new_int_var(0, horizon, f'start[{t}]')
+    duration = t + 1
+    presence = model.new_bool_var(f'presence[{t}]')
+    interval = model.new_optional_fixed_size_interval_var(
+        start, duration, presence, f'opt_interval[{t}]'
+    )
+    if t < num_tasks // 2:
+      model.add(presence == 1)
+
+    starts.append(start)
+    durations.append(duration)
+    intervals.append(interval)
+    presences.append(presence)
+
+    # Ranks = -1 if and only if the tasks is not performed.
+    ranks.append(model.new_int_var(-1, num_tasks - 1, f'rank[{t}]'))
+
+  # Adds NoOverlap constraint.
+  model.add_no_overlap(intervals)
+
+  # Adds ranking constraint.
+  rank_tasks_with_circuit(model, starts, durations, presences, ranks)
+
+  # Adds a constraint on ranks.
+  model.add(ranks[0] < ranks[1])
+
+  # Creates makespan variable.
+  makespan = model.new_int_var(0, horizon, 'makespan')
+  for t in all_tasks:
+    model.add(starts[t] + durations[t] <= makespan).only_enforce_if(
+        presences[t]
+    )
+
+  # Minimizes makespan - fixed gain per tasks performed.
+  # As the fixed cost is less that the duration of the last interval,
+  # the solver will not perform the last interval.
+  model.minimize(2 * makespan - 7 * sum(presences[t] for t in all_tasks))
+
+  # Solves the model model.
+  solver = cp_model.CpSolver()
+  status = solver.solve(model)
+
+  if status == cp_model.OPTIMAL:
+    # Prints out the makespan and the start times and ranks of all tasks.
+    print(f'Optimal cost: {solver.objective_value}')
+    print(f'Makespan: {solver.value(makespan)}')
     for t in all_tasks:
-        start = model.new_int_var(0, horizon, f"start[{t}]")
-        duration = t + 1
-        presence = model.new_bool_var(f"presence[{t}]")
-        interval = model.new_optional_fixed_size_interval_var(
-            start, duration, presence, f"opt_interval[{t}]"
+      if solver.value(presences[t]):
+        print(
+            f'Task {t} starts at {solver.value(starts[t])} '
+            f'with rank {solver.value(ranks[t])}'
         )
-        if t < num_tasks // 2:
-            model.add(presence == 1)
-
-        starts.append(start)
-        durations.append(duration)
-        intervals.append(interval)
-        presences.append(presence)
-
-        # Ranks = -1 if and only if the tasks is not performed.
-        ranks.append(model.new_int_var(-1, num_tasks - 1, f"rank[{t}]"))
-
-    # Adds NoOverlap constraint.
-    model.add_no_overlap(intervals)
-
-    # Adds ranking constraint.
-    rank_tasks_with_circuit(model, starts, durations, presences, ranks)
-
-    # Adds a constraint on ranks.
-    model.add(ranks[0] < ranks[1])
-
-    # Creates makespan variable.
-    makespan = model.new_int_var(0, horizon, "makespan")
-    for t in all_tasks:
-        model.add(starts[t] + durations[t] <= makespan).only_enforce_if(presences[t])
-
-    # Minimizes makespan - fixed gain per tasks performed.
-    # As the fixed cost is less that the duration of the last interval,
-    # the solver will not perform the last interval.
-    model.minimize(2 * makespan - 7 * sum(presences[t] for t in all_tasks))
-
-    # Solves the model model.
-    solver = cp_model.CpSolver()
-    status = solver.solve(model)
-
-    if status == cp_model.OPTIMAL:
-        # Prints out the makespan and the start times and ranks of all tasks.
-        print(f"Optimal cost: {solver.objective_value}")
-        print(f"Makespan: {solver.value(makespan)}")
-        for t in all_tasks:
-            if solver.value(presences[t]):
-                print(
-                    f"Task {t} starts at {solver.value(starts[t])} "
-                    f"with rank {solver.value(ranks[t])}"
-                )
-            else:
-                print(
-                    f"Task {t} in not performed and ranked at {solver.value(ranks[t])}"
-                )
-    else:
-        print(f"Solver exited with nonoptimal status: {status}")
+      else:
+        print(
+            f'Task {t} in not performed and ranked at {solver.value(ranks[t])}'
+        )
+  else:
+    print(f'Solver exited with nonoptimal status: {status}')
 
 
 ranking_sample_sat()
@@ -2230,70 +2277,70 @@ The following code displays:
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/scheduling_with_calendar_sample_sat.py
 """Code sample to demonstrate how an interval can span across a break."""
 
 from ortools.sat.python import cp_model
 
 
 class VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):
-    """Print intermediate solutions."""
+  """Print intermediate solutions."""
 
-    def __init__(self, variables: list[cp_model.IntVar]):
-        cp_model.CpSolverSolutionCallback.__init__(self)
-        self.__variables = variables
+  def __init__(self, variables: list[cp_model.IntVar]):
+    cp_model.CpSolverSolutionCallback.__init__(self)
+    self.__variables = variables
 
-    def on_solution_callback(self) -> None:
-        for v in self.__variables:
-            print(f"{v}={self.value(v)}", end=" ")
-        print()
+  def on_solution_callback(self) -> None:
+    for v in self.__variables:
+      print(f'{v}={self.value(v)}', end=' ')
+    print()
 
 
 def scheduling_with_calendar_sample_sat():
-    """Interval spanning across a lunch break."""
-    model = cp_model.CpModel()
+  """Interval spanning across a lunch break."""
+  model = cp_model.CpModel()
 
-    # The data is the following:
-    #   Work starts at 8h, ends at 18h, with a lunch break between 13h and 14h.
-    #   We need to schedule a task that needs 3 hours of processing time.
-    #   Total duration can be 3 or 4 (if it spans the lunch break).
-    #
-    # Because the duration is at least 3 hours, work cannot start after 15h.
-    # Because of the break, work cannot start at 13h.
+  # The data is the following:
+  #   Work starts at 8h, ends at 18h, with a lunch break between 13h and 14h.
+  #   We need to schedule a task that needs 3 hours of processing time.
+  #   Total duration can be 3 or 4 (if it spans the lunch break).
+  #
+  # Because the duration is at least 3 hours, work cannot start after 15h.
+  # Because of the break, work cannot start at 13h.
 
-    start = model.new_int_var_from_domain(
-        cp_model.Domain.from_intervals([(8, 12), (14, 15)]), "start"
-    )
-    duration = model.new_int_var(3, 4, "duration")
-    end = model.new_int_var(8, 18, "end")
-    unused_interval = model.new_interval_var(start, duration, end, "interval")
+  start = model.new_int_var_from_domain(
+      cp_model.Domain.from_intervals([(8, 12), (14, 15)]), 'start'
+  )
+  duration = model.new_int_var(3, 4, 'duration')
+  end = model.new_int_var(8, 18, 'end')
+  unused_interval = model.new_interval_var(start, duration, end, 'interval')
 
-    # We have 2 states (spanning across lunch or not)
-    across = model.new_bool_var("across")
-    non_spanning_hours = cp_model.Domain.from_values([8, 9, 10, 14, 15])
-    model.add_linear_expression_in_domain(start, non_spanning_hours).only_enforce_if(
-        ~across
-    )
-    model.add_linear_constraint(start, 11, 12).only_enforce_if(across)
-    model.add(duration == 3).only_enforce_if(~across)
-    model.add(duration == 4).only_enforce_if(across)
+  # We have 2 states (spanning across lunch or not)
+  across = model.new_bool_var('across')
+  non_spanning_hours = cp_model.Domain.from_values([8, 9, 10, 14, 15])
+  model.add_linear_expression_in_domain(
+      start, non_spanning_hours
+  ).only_enforce_if(~across)
+  model.add_linear_constraint(start, 11, 12).only_enforce_if(across)
+  model.add(duration == 3).only_enforce_if(~across)
+  model.add(duration == 4).only_enforce_if(across)
 
-    # Search for x values in increasing order.
-    model.add_decision_strategy(
-        [start], cp_model.CHOOSE_FIRST, cp_model.SELECT_MIN_VALUE
-    )
+  # Search for x values in increasing order.
+  model.add_decision_strategy(
+      [start], cp_model.CHOOSE_FIRST, cp_model.SELECT_MIN_VALUE
+  )
 
-    # Create a solver and solve with a fixed search.
-    solver = cp_model.CpSolver()
+  # Create a solver and solve with a fixed search.
+  solver = cp_model.CpSolver()
 
-    # Force the solver to follow the decision strategy exactly.
-    solver.parameters.search_branching = cp_model.FIXED_SEARCH
-    # Enumerate all solutions.
-    solver.parameters.enumerate_all_solutions = True
+  # Force the solver to follow the decision strategy exactly.
+  solver.parameters.search_branching = cp_model.FIXED_SEARCH
+  # Enumerate all solutions.
+  solver.parameters.enumerate_all_solutions = True
 
-    # Search and print all solutions.
-    solution_printer = VarArraySolutionPrinter([start, duration, across])
-    solver.solve(model, solution_printer)
+  # Search and print all solutions.
+  solution_printer = VarArraySolutionPrinter([start, duration, across])
+  solver.solve(model, solution_printer)
 
 
 scheduling_with_calendar_sample_sat()
@@ -2335,86 +2382,87 @@ start_a=1 start_b=5 a_overlaps_b=0
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/overlapping_intervals_sample_sat.py
 """Code sample to demonstrates how to detect if two intervals overlap."""
 
 from ortools.sat.python import cp_model
 
 
 class VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):
-    """Print intermediate solutions."""
+  """Print intermediate solutions."""
 
-    def __init__(self, variables: list[cp_model.IntVar]):
-        cp_model.CpSolverSolutionCallback.__init__(self)
-        self.__variables = variables
+  def __init__(self, variables: list[cp_model.IntVar]):
+    cp_model.CpSolverSolutionCallback.__init__(self)
+    self.__variables = variables
 
-    def on_solution_callback(self) -> None:
-        for v in self.__variables:
-            print(f"{v}={self.value(v)}", end=" ")
-        print()
+  def on_solution_callback(self) -> None:
+    for v in self.__variables:
+      print(f'{v}={self.value(v)}', end=' ')
+    print()
 
 
 def overlapping_interval_sample_sat():
-    """Create the overlapping Boolean variables and enumerate all states."""
-    model = cp_model.CpModel()
+  """Create the overlapping Boolean variables and enumerate all states."""
+  model = cp_model.CpModel()
 
-    horizon = 7
+  horizon = 7
 
-    # First interval.
-    start_var_a = model.new_int_var(0, horizon, "start_a")
-    duration_a = 3
-    end_var_a = model.new_int_var(0, horizon, "end_a")
-    unused_interval_var_a = model.new_interval_var(
-        start_var_a, duration_a, end_var_a, "interval_a"
-    )
+  # First interval.
+  start_var_a = model.new_int_var(0, horizon, 'start_a')
+  duration_a = 3
+  end_var_a = model.new_int_var(0, horizon, 'end_a')
+  unused_interval_var_a = model.new_interval_var(
+      start_var_a, duration_a, end_var_a, 'interval_a'
+  )
 
-    # Second interval.
-    start_var_b = model.new_int_var(0, horizon, "start_b")
-    duration_b = 2
-    end_var_b = model.new_int_var(0, horizon, "end_b")
-    unused_interval_var_b = model.new_interval_var(
-        start_var_b, duration_b, end_var_b, "interval_b"
-    )
+  # Second interval.
+  start_var_b = model.new_int_var(0, horizon, 'start_b')
+  duration_b = 2
+  end_var_b = model.new_int_var(0, horizon, 'end_b')
+  unused_interval_var_b = model.new_interval_var(
+      start_var_b, duration_b, end_var_b, 'interval_b'
+  )
 
-    # a_after_b Boolean variable.
-    a_after_b = model.new_bool_var("a_after_b")
-    model.add(start_var_a >= end_var_b).only_enforce_if(a_after_b)
-    model.add(start_var_a < end_var_b).only_enforce_if(~a_after_b)
+  # a_after_b Boolean variable.
+  a_after_b = model.new_bool_var('a_after_b')
+  model.add(start_var_a >= end_var_b).only_enforce_if(a_after_b)
+  model.add(start_var_a < end_var_b).only_enforce_if(~a_after_b)
 
-    # b_after_a Boolean variable.
-    b_after_a = model.new_bool_var("b_after_a")
-    model.add(start_var_b >= end_var_a).only_enforce_if(b_after_a)
-    model.add(start_var_b < end_var_a).only_enforce_if(~b_after_a)
+  # b_after_a Boolean variable.
+  b_after_a = model.new_bool_var('b_after_a')
+  model.add(start_var_b >= end_var_a).only_enforce_if(b_after_a)
+  model.add(start_var_b < end_var_a).only_enforce_if(~b_after_a)
 
-    # Result Boolean variable.
-    a_overlaps_b = model.new_bool_var("a_overlaps_b")
+  # Result Boolean variable.
+  a_overlaps_b = model.new_bool_var('a_overlaps_b')
 
-    # Option a: using only clauses
-    model.add_bool_or(a_after_b, b_after_a, a_overlaps_b)
-    model.add_implication(a_after_b, ~a_overlaps_b)
-    model.add_implication(b_after_a, ~a_overlaps_b)
+  # Option a: using only clauses
+  model.add_bool_or(a_after_b, b_after_a, a_overlaps_b)
+  model.add_implication(a_after_b, ~a_overlaps_b)
+  model.add_implication(b_after_a, ~a_overlaps_b)
 
-    # Option b: using an exactly one constraint.
-    # model.add_exactly_one(a_after_b, b_after_a, a_overlaps_b)
+  # Option b: using an exactly one constraint.
+  # model.add_exactly_one(a_after_b, b_after_a, a_overlaps_b)
 
-    # Search for start values in increasing order for the two intervals.
-    model.add_decision_strategy(
-        [start_var_a, start_var_b],
-        cp_model.CHOOSE_FIRST,
-        cp_model.SELECT_MIN_VALUE,
-    )
+  # Search for start values in increasing order for the two intervals.
+  model.add_decision_strategy(
+      [start_var_a, start_var_b],
+      cp_model.CHOOSE_FIRST,
+      cp_model.SELECT_MIN_VALUE,
+  )
 
-    # Create a solver and solve with a fixed search.
-    solver = cp_model.CpSolver()
+  # Create a solver and solve with a fixed search.
+  solver = cp_model.CpSolver()
 
-    # Force the solver to follow the decision strategy exactly.
-    solver.parameters.search_branching = cp_model.FIXED_SEARCH
-    # Enumerate all solutions.
-    solver.parameters.enumerate_all_solutions = True
+  # Force the solver to follow the decision strategy exactly.
+  solver.parameters.search_branching = cp_model.FIXED_SEARCH
+  # Enumerate all solutions.
+  solver.parameters.enumerate_all_solutions = True
 
-    # Search and print out all solutions.
-    solution_printer = VarArraySolutionPrinter([start_var_a, start_var_b, a_overlaps_b])
-    solver.solve(model, solution_printer)
+  # Search and print out all solutions.
+  solution_printer = VarArraySolutionPrinter(
+      [start_var_a, start_var_b, a_overlaps_b])
+  solver.solve(model, solution_printer)
 
 
 overlapping_interval_sample_sat()
@@ -2433,10 +2481,11 @@ successor literals to implement the penalties or the delays.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/transitions_in_no_overlap_sample_sat.py
 """Implements transition times and costs in a no_overlap constraint."""
 
-from typing import Dict, List, Sequence, Tuple, Union
+from collections.abc import Sequence
+from typing import Union
 
 from ortools.sat.python import cp_model
 
@@ -2446,180 +2495,180 @@ def transitive_reduction_with_circuit_delays_and_penalties(
     starts: Sequence[cp_model.IntVar],
     durations: Sequence[int],
     presences: Sequence[Union[cp_model.IntVar, bool]],
-    penalties: Dict[Tuple[int, int], int],
-    delays: Dict[Tuple[int, int], int],
-) -> Sequence[Tuple[cp_model.IntVar, int]]:
-    """This method uses a circuit constraint to rank tasks.
+    penalties: dict[tuple[int, int], int],
+    delays: dict[tuple[int, int], int],
+) -> Sequence[tuple[cp_model.IntVar, int]]:
+  """This method uses a circuit constraint to rank tasks.
 
-    This method assumes that all starts are disjoint, meaning that all tasks have
-    a strictly positive duration, and they appear in the same NoOverlap
-    constraint.
+  This method assumes that all starts are disjoint, meaning that all tasks have
+  a strictly positive duration, and they appear in the same NoOverlap
+  constraint.
 
-    The extra node (with id 0) will be used to decide which task is first with
-    its only outgoing arc, and which task is last with its only incoming arc.
-    Each task i will be associated with id i + 1, and an arc between i + 1 and j +
-    1 indicates that j is the immediate successor of i.
+  The extra node (with id 0) will be used to decide which task is first with
+  its only outgoing arc, and which task is last with its only incoming arc.
+  Each task i will be associated with id i + 1, and an arc between i + 1 and j +
+  1 indicates that j is the immediate successor of i.
 
-    The circuit constraint ensures there is at most 1 hamiltonian cycle of
-    length > 1. If no such path exists, then no tasks are active.
-    We also need to enforce that any hamiltonian cycle of size > 1 must contain
-    the node 0. And thus, there is a self loop on node 0 iff the circuit is empty.
+  The circuit constraint ensures there is at most 1 hamiltonian cycle of
+  length > 1. If no such path exists, then no tasks are active.
+  We also need to enforce that any hamiltonian cycle of size > 1 must contain
+  the node 0. And thus, there is a self loop on node 0 iff the circuit is empty.
 
-    Args:
-      model: The CpModel to add the constraints to.
-      starts: The array of starts variables of all tasks.
-      durations: the durations of all tasks.
-      presences: The array of presence variables of all tasks.
-      penalties: the array of tuple (`tail_index`, `head_index`, `penalty`) that
-        specifies that if task `tail_index` is the successor of the task
-        `head_index`, then `penalty` must be added to the cost.
-      delays: the array of tuple (`tail_index`, `head_index`, `delay`) that
-        specifies that if task `tail_index` is the successor of the task
-        `head_index`, then an extra `delay` must be added between the end of the
-        first task and the start of the second task.
+  Args:
+    model: The CpModel to add the constraints to.
+    starts: The array of starts variables of all tasks.
+    durations: the durations of all tasks.
+    presences: The array of presence variables of all tasks.
+    penalties: the array of tuple (`tail_index`, `head_index`, `penalty`) that
+      specifies that if task `tail_index` is the successor of the task
+      `head_index`, then `penalty` must be added to the cost.
+    delays: the array of tuple (`tail_index`, `head_index`, `delay`) that
+      specifies that if task `tail_index` is the successor of the task
+      `head_index`, then an extra `delay` must be added between the end of the
+      first task and the start of the second task.
 
-    Returns:
-      The list of pairs (Boolean variables, penalty) to be added to the objective.
-    """
+  Returns:
+    The list of pairs (Boolean variables, penalty) to be added to the objective.
+  """
 
-    num_tasks = len(starts)
-    all_tasks = range(num_tasks)
+  num_tasks = len(starts)
+  all_tasks = range(num_tasks)
 
-    arcs: List[cp_model.ArcT] = []
-    penalty_terms = []
-    for i in all_tasks:
-        # if node i is first.
-        start_lit = model.new_bool_var(f"start_{i}")
-        arcs.append((0, i + 1, start_lit))
+  arcs: list[cp_model.ArcT] = []
+  penalty_terms = []
+  for i in all_tasks:
+    # if node i is first.
+    start_lit = model.new_bool_var(f'start_{i}')
+    arcs.append((0, i + 1, start_lit))
 
-        # As there are no other constraints on the problem, we can add this
-        # redundant constraint.
-        model.add(starts[i] == 0).only_enforce_if(start_lit)
+    # As there are no other constraints on the problem, we can add this
+    # redundant constraint.
+    model.add(starts[i] == 0).only_enforce_if(start_lit)
 
-        # if node i is last.
-        end_lit = model.new_bool_var(f"end_{i}")
-        arcs.append((i + 1, 0, end_lit))
+    # if node i is last.
+    end_lit = model.new_bool_var(f'end_{i}')
+    arcs.append((i + 1, 0, end_lit))
 
-        for j in all_tasks:
-            if i == j:
-                arcs.append((i + 1, i + 1, ~presences[i]))
-            else:
-                literal = model.new_bool_var(f"arc_{i}_to_{j}")
-                arcs.append((i + 1, j + 1, literal))
+    for j in all_tasks:
+      if i == j:
+        arcs.append((i + 1, i + 1, ~presences[i]))
+      else:
+        literal = model.new_bool_var(f'arc_{i}_to_{j}')
+        arcs.append((i + 1, j + 1, literal))
 
-                # To perform the transitive reduction from precedences to successors,
-                # we need to tie the starts of the tasks with 'literal'.
-                # In a pure problem, the following inequality could be an equality.
-                # It is not true in general.
-                #
-                # Note that we could use this literal to penalize the transition, add an
-                # extra delay to the precedence.
-                min_delay = 0
-                key = (i, j)
-                if key in delays:
-                    min_delay = delays[key]
-                model.add(
-                    starts[j] >= starts[i] + durations[i] + min_delay
-                ).only_enforce_if(literal)
+        # To perform the transitive reduction from precedences to successors,
+        # we need to tie the starts of the tasks with 'literal'.
+        # In a pure problem, the following inequality could be an equality.
+        # It is not true in general.
+        #
+        # Note that we could use this literal to penalize the transition, add an
+        # extra delay to the precedence.
+        min_delay = 0
+        key = (i, j)
+        if key in delays:
+          min_delay = delays[key]
+        model.add(
+            starts[j] >= starts[i] + durations[i] + min_delay
+        ).only_enforce_if(literal)
 
-                # Create the penalties.
-                if key in penalties:
-                    penalty_terms.append((literal, penalties[key]))
+        # Create the penalties.
+        if key in penalties:
+          penalty_terms.append((literal, penalties[key]))
 
-    # Manage the empty circuit
-    empty = model.new_bool_var("empty")
-    arcs.append((0, 0, empty))
+  # Manage the empty circuit
+  empty = model.new_bool_var('empty')
+  arcs.append((0, 0, empty))
 
-    for i in all_tasks:
-        model.add_implication(empty, ~presences[i])
+  for i in all_tasks:
+    model.add_implication(empty, ~presences[i])
 
-    # Add the circuit constraint.
-    model.add_circuit(arcs)
+  # Add the circuit constraint.
+  model.add_circuit(arcs)
 
-    return penalty_terms
+  return penalty_terms
 
 
 def transitions_in_no_overlap_sample_sat():
-    """Implement transitions in a NoOverlap constraint."""
+  """Implement transitions in a NoOverlap constraint."""
 
-    model = cp_model.CpModel()
-    horizon = 40
-    num_tasks = 4
+  model = cp_model.CpModel()
+  horizon = 40
+  num_tasks = 4
 
-    # Breaking the natural sequence induces a fixed penalty.
-    penalties = {
-        (1, 0): 10,
-        (2, 0): 10,
-        (3, 0): 10,
-        (2, 1): 10,
-        (3, 1): 10,
-        (3, 2): 10,
-    }
+  # Breaking the natural sequence induces a fixed penalty.
+  penalties = {
+      (1, 0): 10,
+      (2, 0): 10,
+      (3, 0): 10,
+      (2, 1): 10,
+      (3, 1): 10,
+      (3, 2): 10,
+  }
 
-    # Switching from an odd to even or even to odd task indices induces a delay.
-    delays = {
-        (1, 0): 10,
-        (0, 1): 10,
-        (3, 0): 10,
-        (0, 3): 10,
-        (1, 2): 10,
-        (2, 1): 10,
-        (3, 2): 10,
-        (2, 3): 10,
-    }
+  # Switching from an odd to even or even to odd task indices induces a delay.
+  delays = {
+      (1, 0): 10,
+      (0, 1): 10,
+      (3, 0): 10,
+      (0, 3): 10,
+      (1, 2): 10,
+      (2, 1): 10,
+      (3, 2): 10,
+      (2, 3): 10,
+  }
 
-    all_tasks = range(num_tasks)
+  all_tasks = range(num_tasks)
 
-    starts = []
-    durations = []
-    intervals = []
-    presences = []
+  starts = []
+  durations = []
+  intervals = []
+  presences = []
 
-    # Creates intervals, all present. But the cost is robust w.r.t. optional
-    # intervals.
-    for t in all_tasks:
-        start = model.new_int_var(0, horizon, f"start[{t}]")
-        duration = 5
-        presence = True
-        interval = model.new_optional_fixed_size_interval_var(
-            start, duration, presence, f"opt_interval[{t}]"
-        )
-
-        starts.append(start)
-        durations.append(duration)
-        intervals.append(interval)
-        presences.append(presence)
-
-    # Adds NoOverlap constraint.
-    model.add_no_overlap(intervals)
-
-    # Adds ranking constraint.
-    penalty_terms = transitive_reduction_with_circuit_delays_and_penalties(
-        model, starts, durations, presences, penalties, delays
+  # Creates intervals, all present. But the cost is robust w.r.t. optional
+  # intervals.
+  for t in all_tasks:
+    start = model.new_int_var(0, horizon, f'start[{t}]')
+    duration = 5
+    presence = True
+    interval = model.new_optional_fixed_size_interval_var(
+        start, duration, presence, f'opt_interval[{t}]'
     )
 
-    # Minimize the sum of penalties,
-    model.minimize(sum(var * penalty for var, penalty in penalty_terms))
+    starts.append(start)
+    durations.append(duration)
+    intervals.append(interval)
+    presences.append(presence)
 
-    # In practise, only one penalty can happen. Thus the two even tasks are
-    # together, same for the two odd tasks.
-    # Because of the penalties, the optimal sequence is 0 -> 2 -> 1 -> 3
-    # which induces one penalty and one delay.
+  # Adds NoOverlap constraint.
+  model.add_no_overlap(intervals)
 
-    # Solves the model model.
-    solver = cp_model.CpSolver()
-    status = solver.solve(model)
+  # Adds ranking constraint.
+  penalty_terms = transitive_reduction_with_circuit_delays_and_penalties(
+      model, starts, durations, presences, penalties, delays
+  )
 
-    if status == cp_model.OPTIMAL:
-        # Prints out the makespan and the start times and ranks of all tasks.
-        print(f"Optimal cost: {solver.objective_value}")
-        for t in all_tasks:
-            if solver.value(presences[t]):
-                print(f"Task {t} starts at {solver.value(starts[t])} ")
-            else:
-                print(f"Task {t} in not performed")
-    else:
-        print(f"Solver exited with nonoptimal status: {status}")
+  # Minimize the sum of penalties,
+  model.minimize(sum(var * penalty for var, penalty in penalty_terms))
+
+  # In practise, only one penalty can happen. Thus the two even tasks are
+  # together, same for the two odd tasks.
+  # Because of the penalties, the optimal sequence is 0 -> 2 -> 1 -> 3
+  # which induces one penalty and one delay.
+
+  # Solves the model model.
+  solver = cp_model.CpSolver()
+  status = solver.solve(model)
+
+  if status == cp_model.OPTIMAL:
+    # Prints out the makespan and the start times and ranks of all tasks.
+    print(f'Optimal cost: {solver.objective_value}')
+    for t in all_tasks:
+      if solver.value(presences[t]):
+        print(f'Task {t} starts at {solver.value(starts[t])} ')
+      else:
+        print(f'Task {t} in not performed')
+  else:
+    print(f'Solver exited with nonoptimal status: {status}')
 
 
 transitions_in_no_overlap_sample_sat()
@@ -2638,10 +2687,10 @@ literals to maintain these counters.
 ### Python code
 
 ```python
-#!/usr/bin/env python3
+# Snippet from ortools/sat/samples/sequences_in_no_overlap_sample_sat.py
 """Implements sequence constraints in a no_overlap constraint."""
 
-from typing import Dict, List, Sequence, Tuple
+from collections.abc import Sequence
 
 from ortools.sat.python import cp_model
 
@@ -2653,273 +2702,276 @@ def sequence_constraints_with_circuit(
     task_types: Sequence[str],
     lengths: Sequence[cp_model.IntVar],
     cumuls: Sequence[cp_model.IntVar],
-    sequence_length_constraints: Dict[str, Tuple[int, int]],
-    sequence_cumul_constraints: Dict[str, Tuple[int, int, int]],
-) -> Sequence[Tuple[cp_model.IntVar, int]]:
-    """This method enforces constraints on sequences of tasks of the same type.
+    sequence_length_constraints: dict[str, tuple[int, int]],
+    sequence_cumul_constraints: dict[str, tuple[int, int, int]],
+) -> Sequence[tuple[cp_model.IntVar, int]]:
+  """This method enforces constraints on sequences of tasks of the same type.
 
-    This method assumes that all durations are strictly positive.
+  This method assumes that all durations are strictly positive.
 
-    The extra node (with id 0) will be used to decide which task is first with
-    its only outgoing arc, and which task is last with its only incoming arc.
-    Each task i will be associated with id i + 1, and an arc between i + 1 and j +
-    1 indicates that j is the immediate successor of i.
+  The extra node (with id 0) will be used to decide which task is first with
+  its only outgoing arc, and which task is last with its only incoming arc.
+  Each task i will be associated with id i + 1, and an arc between i + 1 and j +
+  1 indicates that j is the immediate successor of i.
 
-    The circuit constraint ensures there is at most 1 hamiltonian cycle of
-    length > 1. If no such path exists, then no tasks are active.
-    In this simplified model, all tasks must be performed.
+  The circuit constraint ensures there is at most 1 hamiltonian cycle of
+  length > 1. If no such path exists, then no tasks are active.
+  In this simplified model, all tasks must be performed.
 
-    Args:
-      model: The CpModel to add the constraints to.
-      starts: The array of starts variables of all tasks.
-      durations: the durations of all tasks.
-      task_types: The type of all tasks.
-      lengths: the number of tasks of the same type in the current sequence.
-      cumuls: The computed cumul of the current sequence for each task.
-      sequence_length_constraints: the array of tuple (`task_type`, (`length_min`,
-        `length_max`)) that specifies the minimum and maximum length of the
-        sequence of tasks of type `task_type`.
-      sequence_cumul_constraints: the array of tuple (`task_type`, (`soft_max`,
-        `linear_penalty`, `hard_max`)) that specifies that if the cumul of the
-        sequence of tasks of type `task_type` is greater than `soft_max`, then
-        `linear_penalty * (cumul - soft_max)` is added to the cost
+  Args:
+    model: The CpModel to add the constraints to.
+    starts: The array of starts variables of all tasks.
+    durations: the durations of all tasks.
+    task_types: The type of all tasks.
+    lengths: the number of tasks of the same type in the current sequence.
+    cumuls: The computed cumul of the current sequence for each task.
+    sequence_length_constraints: the array of tuple (`task_type`, (`length_min`,
+      `length_max`)) that specifies the minimum and maximum length of the
+      sequence of tasks of type `task_type`.
+    sequence_cumul_constraints: the array of tuple (`task_type`, (`soft_max`,
+      `linear_penalty`, `hard_max`)) that specifies that if the cumul of the
+      sequence of tasks of type `task_type` is greater than `soft_max`, then
+      `linear_penalty * (cumul - soft_max)` is added to the cost
 
-    Returns:
-      The list of pairs (integer variables, penalty) to be added to the objective.
-    """
+  Returns:
+    The list of pairs (integer variables, penalty) to be added to the objective.
+  """
 
-    num_tasks = len(starts)
-    all_tasks = range(num_tasks)
+  num_tasks = len(starts)
+  all_tasks = range(num_tasks)
 
-    arcs: List[cp_model.ArcT] = []
-    for i in all_tasks:
-        # if node i is first.
-        start_lit = model.new_bool_var(f"start_{i}")
-        arcs.append((0, i + 1, start_lit))
-        model.add(lengths[i] == 1).only_enforce_if(start_lit)
-        model.add(cumuls[i] == durations[i]).only_enforce_if(start_lit)
+  arcs: list[cp_model.ArcT] = []
+  for i in all_tasks:
+    # if node i is first.
+    start_lit = model.new_bool_var(f'start_{i}')
+    arcs.append((0, i + 1, start_lit))
+    model.add(lengths[i] == 1).only_enforce_if(start_lit)
+    model.add(cumuls[i] == durations[i]).only_enforce_if(start_lit)
 
-        # As there are no other constraints on the problem, we can add this
-        # redundant constraint. This is not valid in general.
-        model.add(starts[i] == 0).only_enforce_if(start_lit)
+    # As there are no other constraints on the problem, we can add this
+    # redundant constraint. This is not valid in general.
+    model.add(starts[i] == 0).only_enforce_if(start_lit)
 
-        # if node i is last.
-        end_lit = model.new_bool_var(f"end_{i}")
-        arcs.append((i + 1, 0, end_lit))
+    # if node i is last.
+    end_lit = model.new_bool_var(f'end_{i}')
+    arcs.append((i + 1, 0, end_lit))
+
+    # Make sure the previous length is within bounds.
+    type_length_min = sequence_length_constraints[task_types[i]][0]
+    model.add(lengths[i] >= type_length_min).only_enforce_if(end_lit)
+
+    for j in all_tasks:
+      if i == j:
+        continue
+      lit = model.new_bool_var(f'arc_{i}_to_{j}')
+      arcs.append((i + 1, j + 1, lit))
+
+      # The circuit constraint is use to enforce the consistency between the
+      # precedences relations and the successor arcs. This is implemented by
+      # adding the constraint that force the implication task j is the next of
+      # task i implies that start(j) is greater or equal than the end(i).
+      #
+      # In the majority of problems, the following equality must be an
+      # inequality. In that particular case, as there are no extra constraints,
+      # we can keep the equality between start(j) and end(i).
+      model.add(starts[j] == starts[i] + durations[i]).only_enforce_if(lit)
+
+      # We add the constraints to incrementally maintain the length and the
+      # cumul variables of the sequence.
+      if task_types[i] == task_types[j]:  # Same task type.
+        # Increase the length of the sequence by 1.
+        model.add(lengths[j] == lengths[i] + 1).only_enforce_if(lit)
+
+        # Increase the cumul of the sequence by the duration of the task.
+        model.add(cumuls[j] == cumuls[i] + durations[j]).only_enforce_if(lit)
+
+      else:
+        # Switching task type. task[i] is the last task of the previous
+        # sequence, task[j] is the first task of the new sequence.
+        #
+        # Reset the length to 1.
+        model.add(lengths[j] == 1).only_enforce_if(lit)
 
         # Make sure the previous length is within bounds.
         type_length_min = sequence_length_constraints[task_types[i]][0]
-        model.add(lengths[i] >= type_length_min).only_enforce_if(end_lit)
+        model.add(lengths[i] >= type_length_min).only_enforce_if(lit)
 
-        for j in all_tasks:
-            if i == j:
-                continue
-            lit = model.new_bool_var(f"arc_{i}_to_{j}")
-            arcs.append((i + 1, j + 1, lit))
+        # Reset the cumul to the duration of the task.
+        model.add(cumuls[j] == durations[j]).only_enforce_if(lit)
 
-            # The circuit constraint is use to enforce the consistency between the
-            # precedences relations and the successor arcs. This is implemented by
-            # adding the constraint that force the implication task j is the next of
-            # task i implies that start(j) is greater or equal than the end(i).
-            #
-            # In the majority of problems, the following equality must be an
-            # inequality. In that particular case, as there are no extra constraints,
-            # we can keep the equality between start(j) and end(i).
-            model.add(starts[j] == starts[i] + durations[i]).only_enforce_if(lit)
+  # Add the circuit constraint.
+  model.add_circuit(arcs)
 
-            # We add the constraints to incrementally maintain the length and the
-            # cumul variables of the sequence.
-            if task_types[i] == task_types[j]:  # Same task type.
-                # Increase the length of the sequence by 1.
-                model.add(lengths[j] == lengths[i] + 1).only_enforce_if(lit)
+  # Create the penalty terms. We can penalize each cumul locally.
+  penalty_terms = []
+  for i in all_tasks:
+    # Penalize the cumul of the last task w.r.t. the soft max
+    soft_max, linear_penalty, hard_max = sequence_cumul_constraints[
+        task_types[i]
+    ]
 
-                # Increase the cumul of the sequence by the duration of the task.
-                model.add(cumuls[j] == cumuls[i] + durations[j]).only_enforce_if(lit)
+    # To make it separable per task, and avoid double counting, we use the
+    # following trick:
+    #     reduced_excess = min(durations[i], max(0, cumul[i] - soft_max))
+    if soft_max < hard_max:
+      excess = model.new_int_var(0, hard_max - soft_max, f'excess+_{i}')
+      model.add_max_equality(excess, [0, cumuls[i] - soft_max])
+      reduced_excess = model.new_int_var(0, durations[i], f'reduced_excess_{i}')
+      model.add_min_equality(reduced_excess, [durations[i], excess])
+      penalty_terms.append((reduced_excess, linear_penalty))
 
-            else:
-                # Switching task type. task[i] is the last task of the previous
-                # sequence, task[j] is the first task of the new sequence.
-                #
-                # Reset the length to 1.
-                model.add(lengths[j] == 1).only_enforce_if(lit)
-
-                # Make sure the previous length is within bounds.
-                type_length_min = sequence_length_constraints[task_types[i]][0]
-                model.add(lengths[i] >= type_length_min).only_enforce_if(lit)
-
-                # Reset the cumul to the duration of the task.
-                model.add(cumuls[j] == durations[j]).only_enforce_if(lit)
-
-    # Add the circuit constraint.
-    model.add_circuit(arcs)
-
-    # Create the penalty terms. We can penalize each cumul locally.
-    penalty_terms = []
-    for i in all_tasks:
-        # Penalize the cumul of the last task w.r.t. the soft max
-        soft_max, linear_penalty, hard_max = sequence_cumul_constraints[task_types[i]]
-
-        # To make it separable per task, and avoid double counting, we use the
-        # following trick:
-        #     reduced_excess = min(durations[i], max(0, cumul[i] - soft_max))
-        if soft_max < hard_max:
-            excess = model.new_int_var(0, hard_max - soft_max, f"excess+_{i}")
-            model.add_max_equality(excess, [0, cumuls[i] - soft_max])
-            reduced_excess = model.new_int_var(0, durations[i], f"reduced_excess_{i}")
-            model.add_min_equality(reduced_excess, [durations[i], excess])
-            penalty_terms.append((reduced_excess, linear_penalty))
-
-    return penalty_terms
+  return penalty_terms
 
 
 def sequences_in_no_overlap_sample_sat():
-    """Implement cumul and length constraints in a NoOverlap constraint."""
+  """Implement cumul and length constraints in a NoOverlap constraint."""
 
-    # Tasks (duration, type).
-    tasks = [
-        (5, "A"),
-        (6, "A"),
-        (7, "A"),
-        (2, "A"),
-        (3, "A"),
-        (5, "B"),
-        (2, "B"),
-        (3, "B"),
-        (1, "B"),
-        (4, "B"),
-        (3, "B"),
-        (6, "B"),
-        (2, "B"),
-    ]
+  # Tasks (duration, type).
+  tasks = [
+      (5, 'A'),
+      (6, 'A'),
+      (7, 'A'),
+      (2, 'A'),
+      (3, 'A'),
+      (5, 'B'),
+      (2, 'B'),
+      (3, 'B'),
+      (1, 'B'),
+      (4, 'B'),
+      (3, 'B'),
+      (6, 'B'),
+      (2, 'B'),
+  ]
 
-    # Sequence length constraints per task_types: (hard_min, hard_max)
-    #
-    # Note that this constraint is very tight for task type B and will fail with
-    # an odd number of tasks of type B.
-    sequence_length_constraints = {
-        "A": (1, 3),
-        "B": (2, 2),
-    }
+  # Sequence length constraints per task_types: (hard_min, hard_max)
+  #
+  # Note that this constraint is very tight for task type B and will fail with
+  # an odd number of tasks of type B.
+  sequence_length_constraints = {
+      'A': (1, 3),
+      'B': (2, 2),
+  }
 
-    # Sequence accumulated durations constraints per task_types:
-    #     (soft_max, linear_penalty, hard_max)
-    sequence_cumul_constraints = {
-        "A": (6, 1, 10),
-        "B": (7, 0, 7),
-    }
+  # Sequence accumulated durations constraints per task_types:
+  #     (soft_max, linear_penalty, hard_max)
+  sequence_cumul_constraints = {
+      'A': (6, 1, 10),
+      'B': (7, 0, 7),
+  }
 
-    model: cp_model.CpModel = cp_model.CpModel()
-    horizon: int = sum(t[0] for t in tasks)
+  model: cp_model.CpModel = cp_model.CpModel()
+  horizon: int = sum(t[0] for t in tasks)
 
-    num_tasks = len(tasks)
-    all_tasks = range(num_tasks)
+  num_tasks = len(tasks)
+  all_tasks = range(num_tasks)
 
-    starts = []
-    durations = []
-    intervals = []
-    task_types = []
+  starts = []
+  durations = []
+  intervals = []
+  task_types = []
 
-    # Creates intervals for each task.
-    for duration, task_type in tasks:
-        index = len(starts)
-        start = model.new_int_var(0, horizon - duration, f"start[{index}]")
-        interval = model.new_fixed_size_interval_var(
-            start, duration, f"interval[{index}]"
-        )
-
-        starts.append(start)
-        durations.append(duration)
-        intervals.append(interval)
-        task_types.append(task_type)
-
-    # Create length variables for each task.
-    lengths = []
-    for i in all_tasks:
-        max_hard_length = sequence_length_constraints[task_types[i]][1]
-        lengths.append(model.new_int_var(1, max_hard_length, f"length_{i}"))
-
-    # Create cumul variables for each task.
-    cumuls = []
-    for i in all_tasks:
-        max_hard_cumul = sequence_cumul_constraints[task_types[i]][2]
-        cumuls.append(model.new_int_var(durations[i], max_hard_cumul, f"cumul_{i}"))
-
-    # Adds NoOverlap constraint.
-    model.add_no_overlap(intervals)
-
-    # Adds the constraints on the lengths and cumuls of maximal sequences of
-    # tasks of the same type.
-    penalty_terms = sequence_constraints_with_circuit(
-        model,
-        starts,
-        durations,
-        task_types,
-        lengths,
-        cumuls,
-        sequence_length_constraints,
-        sequence_cumul_constraints,
+  # Creates intervals for each task.
+  for duration, task_type in tasks:
+    index = len(starts)
+    start = model.new_int_var(0, horizon - duration, f'start[{index}]')
+    interval = model.new_fixed_size_interval_var(
+        start, duration, f'interval[{index}]'
     )
 
-    # Minimize the sum of penalties,
-    model.minimize(sum(var * penalty for var, penalty in penalty_terms))
+    starts.append(start)
+    durations.append(duration)
+    intervals.append(interval)
+    task_types.append(task_type)
 
-    # Solves the model model.
-    solver = cp_model.CpSolver()
-    status = solver.solve(model)
+  # Create length variables for each task.
+  lengths = []
+  for i in all_tasks:
+    max_hard_length = sequence_length_constraints[task_types[i]][1]
+    lengths.append(model.new_int_var(1, max_hard_length, f'length_{i}'))
 
-    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
-        # Prints out the makespan and the start times and lengths, cumuls at each
-        # step.
-        if status == cp_model.OPTIMAL:
-            print(f"Optimal cost: {solver.objective_value}")
-        else:
-            print(f"Feasible cost: {solver.objective_value}")
+  # Create cumul variables for each task.
+  cumuls = []
+  for i in all_tasks:
+    max_hard_cumul = sequence_cumul_constraints[task_types[i]][2]
+    cumuls.append(model.new_int_var(durations[i], max_hard_cumul, f'cumul_{i}'))
 
-        to_sort = []
-        for t in all_tasks:
-            to_sort.append((solver.value(starts[t]), t))
-        to_sort.sort()
+  # Adds NoOverlap constraint.
+  model.add_no_overlap(intervals)
 
-        sum_of_penalties = 0
-        for i, (start, t) in enumerate(to_sort):
-            # Check length constraints.
-            length: int = solver.value(lengths[t])
-            hard_min_length, hard_max_length = sequence_length_constraints[
-                task_types[t]
-            ]
-            assert length >= 0
-            assert length <= hard_max_length
-            if (
-                i + 1 == len(to_sort) or task_types[t] != task_types[to_sort[i + 1][1]]
-            ):  # End of sequence.
-                assert length >= hard_min_length
+  # Adds the constraints on the lengths and cumuls of maximal sequences of
+  # tasks of the same type.
+  penalty_terms = sequence_constraints_with_circuit(
+      model,
+      starts,
+      durations,
+      task_types,
+      lengths,
+      cumuls,
+      sequence_length_constraints,
+      sequence_cumul_constraints,
+  )
 
-            # Check cumul constraints.
-            cumul: int = solver.value(cumuls[t])
-            soft_max_cumul, penalty, hard_max_cumul = sequence_cumul_constraints[
-                task_types[t]
-            ]
-            assert cumul >= 0
-            assert cumul <= hard_max_cumul
+  # Minimize the sum of penalties,
+  model.minimize(sum(var * penalty for var, penalty in penalty_terms))
 
-            if cumul > soft_max_cumul:
-                penalty = penalty * (cumul - soft_max_cumul)
-                sum_of_penalties += penalty
-                print(
-                    f"Task {t} of type {task_types[t]} with"
-                    f" duration={durations[t]} starts at {start}, length={length},"
-                    f" cumul={cumul} penalty={penalty}"
-                )
-            else:
-                print(
-                    f"Task {t} of type {task_types[t]} with duration"
-                    f" {durations[t]} starts at {start}, length ="
-                    f" {length}, cumul = {cumul} "
-                )
+  # Solves the model model.
+  solver = cp_model.CpSolver()
+  status = solver.solve(model)
 
-        assert int(solver.objective_value) == sum_of_penalties
+  if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+    # Prints out the makespan and the start times and lengths, cumuls at each
+    # step.
+    if status == cp_model.OPTIMAL:
+      print(f'Optimal cost: {solver.objective_value}')
     else:
-        print(f"Solver exited with the following status: {status}")
+      print(f'Feasible cost: {solver.objective_value}')
+
+    to_sort = []
+    for t in all_tasks:
+      to_sort.append((solver.value(starts[t]), t))
+    to_sort.sort()
+
+    sum_of_penalties = 0
+    for i, (start, t) in enumerate(to_sort):
+      # Check length constraints.
+      length: int = solver.value(lengths[t])
+      hard_min_length, hard_max_length = sequence_length_constraints[
+          task_types[t]
+      ]
+      assert length >= 0
+      assert length <= hard_max_length
+      if (
+          i + 1 == len(to_sort)
+          or task_types[t] != task_types[to_sort[i + 1][1]]
+      ):  # End of sequence.
+        assert length >= hard_min_length
+
+      # Check cumul constraints.
+      cumul: int = solver.value(cumuls[t])
+      soft_max_cumul, penalty, hard_max_cumul = sequence_cumul_constraints[
+          task_types[t]
+      ]
+      assert cumul >= 0
+      assert cumul <= hard_max_cumul
+
+      if cumul > soft_max_cumul:
+        penalty = penalty * (cumul - soft_max_cumul)
+        sum_of_penalties += penalty
+        print(
+            f'Task {t} of type {task_types[t]} with'
+            f' duration={durations[t]} starts at {start}, length={length},'
+            f' cumul={cumul} penalty={penalty}'
+        )
+      else:
+        print(
+            f'Task {t} of type {task_types[t]} with duration'
+            f' {durations[t]} starts at {start}, length ='
+            f' {length}, cumul = {cumul} '
+        )
+
+    assert int(solver.objective_value) == sum_of_penalties
+  else:
+    print(f'Solver exited with the following status: {status}')
 
 
 sequences_in_no_overlap_sample_sat()
diff --git a/ortools/sat/docs/solver.md b/ortools/sat/docs/solver.md
index c83b886167..7bb15b578b 100644
--- a/ortools/sat/docs/solver.md
+++ b/ortools/sat/docs/solver.md
@@ -195,6 +195,7 @@ public class SolveWithTimeLimitSampleSat
 ### Specifying the time limit in Go
 
 ```go
+// Snippet from ortools/sat/samples/solve_with_time_limit_sample_sat.go
 // The solve_with_time_limit_sample_sat command is an example of setting a time limit on the model.
 package main
 
@@ -543,6 +544,7 @@ public class SolveAndPrintIntermediateSolutionsSampleSat
 ### Go code
 
 ```go
+// Snippet from ortools/sat/samples/solve_and_print_intermediate_solutions_sample_sat.go
 // The solve_and_print_intermediate_solutions_sample_sat command
 package main
 
@@ -885,6 +887,7 @@ public class SearchForAllSolutionsSampleSat
 To search for all solutions, a parameter of the SAT solver must be changed.
 
 ```go
+// Snippet from ortools/sat/samples/search_for_all_solutions_sample_sat.go
 // The search_for_all_solutions_sample_sat command is an example for how to search for
 // all solutions.
 package main
diff --git a/ortools/sat/drat_proof_handler.h b/ortools/sat/drat_proof_handler.h
index 65d32e3239..f2b28fdbd5 100644
--- a/ortools/sat/drat_proof_handler.h
+++ b/ortools/sat/drat_proof_handler.h
@@ -51,11 +51,11 @@ class DratProofHandler {
   ~DratProofHandler() = default;
 
   // During the presolve step, variable get deleted and the set of non-deleted
-  // variable is remaped in a dense set. This allows to keep track of that and
+  // variable is remapped in a dense set. This allows to keep track of that and
   // always output the DRAT clauses in term of the original variables. Must be
   // called before adding or deleting clauses AddClause() or DeleteClause().
   //
-  // TODO(user): This is exactly the same mecanism as in the SatPostsolver
+  // TODO(user): This is exactly the same mechanism as in the SatPostsolver
   // class. Factor out the code.
   void ApplyMapping(const util_intops::StrongVector<BooleanVariable,
                                                     BooleanVariable>& mapping);
diff --git a/ortools/sat/enforcement.cc b/ortools/sat/enforcement.cc
new file mode 100644
index 0000000000..44f551e73a
--- /dev/null
+++ b/ortools/sat/enforcement.cc
@@ -0,0 +1,313 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/enforcement.h"
+
+#include <algorithm>
+#include <functional>
+#include <ostream>
+#include <utility>
+#include <vector>
+
+#include "absl/log/check.h"
+#include "absl/types/span.h"
+#include "ortools/base/stl_util.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_base.h"
+#include "ortools/util/strong_integers.h"
+
+namespace operations_research {
+namespace sat {
+
+std::ostream& operator<<(std::ostream& os, const EnforcementStatus& e) {
+  switch (e) {
+    case EnforcementStatus::IS_FALSE:
+      os << "IS_FALSE";
+      break;
+    case EnforcementStatus::CANNOT_PROPAGATE:
+      os << "CANNOT_PROPAGATE";
+      break;
+    case EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT:
+      os << "CAN_PROPAGATE_ENFORCEMENT";
+      break;
+    case EnforcementStatus::IS_ENFORCED:
+      os << "IS_ENFORCED";
+      break;
+  }
+  return os;
+}
+
+EnforcementPropagator::EnforcementPropagator(Model* model)
+    : SatPropagator("EnforcementPropagator"),
+      trail_(*model->GetOrCreate<Trail>()),
+      assignment_(trail_.Assignment()) {
+  // Sentinel - also start of next Register().
+  starts_.push_back(0);
+}
+
+bool EnforcementPropagator::Propagate(Trail* /*trail*/) {
+  rev_int_repository_.SetLevel(trail_.CurrentDecisionLevel());
+  rev_int_repository_.SaveStateWithStamp(&rev_stack_size_, &rev_stamp_);
+  while (propagation_trail_index_ < trail_.Index()) {
+    const Literal literal = trail_[propagation_trail_index_++];
+    if (literal.Index() >= static_cast<int>(watcher_.size())) continue;
+
+    int new_size = 0;
+    auto& watch_list = watcher_[literal.Index()];
+    for (const EnforcementId id : watch_list) {
+      const LiteralIndex index = ProcessIdOnTrue(literal, id);
+      if (index == kNoLiteralIndex) {
+        // We keep the same watcher.
+        watch_list[new_size++] = id;
+      } else {
+        // Change the watcher.
+        CHECK_NE(index, literal.Index());
+        watcher_[index].push_back(id);
+      }
+    }
+    watch_list.resize(new_size);
+
+    // We also mark some constraint false.
+    for (const EnforcementId id : watcher_[literal.NegatedIndex()]) {
+      ChangeStatus(id, EnforcementStatus::IS_FALSE);
+    }
+  }
+  rev_stack_size_ = static_cast<int>(untrail_stack_.size());
+
+  // Compute the enforcement status of any constraint added at a positive level.
+  // This is only needed until we are back to level zero.
+  for (const EnforcementId id : ids_to_fix_until_next_root_level_) {
+    ChangeStatus(id, DebugStatus(id));
+  }
+  if (trail_.CurrentDecisionLevel() == 0) {
+    ids_to_fix_until_next_root_level_.clear();
+  }
+
+  return true;
+}
+
+void EnforcementPropagator::Untrail(const Trail& /*trail*/, int trail_index) {
+  rev_int_repository_.SetLevel(trail_.CurrentDecisionLevel());
+  // Simply revert the status change.
+  const int size = static_cast<int>(untrail_stack_.size());
+  for (int i = size - 1; i >= rev_stack_size_; --i) {
+    const auto [id, status] = untrail_stack_[i];
+    statuses_[id] = status;
+    if (callbacks_[id] != nullptr) callbacks_[id](id, status);
+  }
+  untrail_stack_.resize(rev_stack_size_);
+  propagation_trail_index_ = trail_index;
+}
+
+// Adds a new constraint to the class and returns the constraint id.
+//
+// Note that we accept empty enforcement list so that client code can be used
+// regardless of the presence of enforcement or not. A negative id means the
+// constraint is never enforced, and should be ignored.
+EnforcementId EnforcementPropagator::Register(
+    absl::Span<const Literal> enforcement,
+    std::function<void(EnforcementId, EnforcementStatus)> callback) {
+  int num_true = 0;
+  int num_false = 0;
+  temp_literals_.clear();
+  const int level = trail_.CurrentDecisionLevel();
+  for (const Literal l : enforcement) {
+    // Make sure we always have enough room for the literal and its negation.
+    const int size = std::max(l.Index().value(), l.NegatedIndex().value()) + 1;
+    if (size > static_cast<int>(watcher_.size())) {
+      watcher_.resize(size);
+    }
+    if (assignment_.LiteralIsTrue(l)) {
+      if (level == 0 || trail_.Info(l.Variable()).level == 0) continue;
+      ++num_true;
+    } else if (assignment_.LiteralIsFalse(l)) {
+      ++num_false;
+    }
+    temp_literals_.push_back(l);
+  }
+  gtl::STLSortAndRemoveDuplicates(&temp_literals_);
+
+  // Return special index if always enforced.
+  if (temp_literals_.empty()) {
+    if (callback != nullptr)
+      callback(EnforcementId(-1), EnforcementStatus::IS_ENFORCED);
+    return EnforcementId(-1);
+  }
+
+  const EnforcementId id(static_cast<int>(callbacks_.size()));
+  callbacks_.push_back(std::move(callback));
+
+  CHECK(!temp_literals_.empty());
+  buffer_.insert(buffer_.end(), temp_literals_.begin(), temp_literals_.end());
+  starts_.push_back(buffer_.size());  // Sentinel/next-start.
+
+  // The default status at level zero.
+  statuses_.push_back(temp_literals_.size() == 1
+                          ? EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT
+                          : EnforcementStatus::CANNOT_PROPAGATE);
+
+  if (temp_literals_.size() == 1) {
+    watcher_[temp_literals_[0].Index()].push_back(id);
+  } else {
+    // Make sure we watch correct literals.
+    const auto span = GetSpan(id);
+    int num_not_true = 0;
+    for (int i = 0; i < span.size(); ++i) {
+      if (assignment_.LiteralIsTrue(span[i])) continue;
+      std::swap(span[num_not_true], span[i]);
+      ++num_not_true;
+      if (num_not_true == 2) break;
+    }
+
+    // We need to watch one of the literals at highest level.
+    if (num_not_true == 1) {
+      int max_level = trail_.Info(span[1].Variable()).level;
+      for (int i = 2; i < span.size(); ++i) {
+        const int level = trail_.Info(span[i].Variable()).level;
+        if (level > max_level) {
+          max_level = level;
+          std::swap(span[1], span[i]);
+        }
+      }
+    }
+
+    watcher_[span[0].Index()].push_back(id);
+    watcher_[span[1].Index()].push_back(id);
+  }
+
+  // Change status, call callback and set up untrail if the status is different
+  // from EnforcementStatus::CANNOT_PROPAGATE.
+  if (num_false > 0) {
+    ChangeStatus(id, EnforcementStatus::IS_FALSE);
+  } else if (num_true == temp_literals_.size()) {
+    ChangeStatus(id, EnforcementStatus::IS_ENFORCED);
+  } else if (num_true + 1 == temp_literals_.size()) {
+    ChangeStatus(id, EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+    // Because this is the default status, we still need to call the callback.
+    if (temp_literals_.size() == 1) {
+      if (callbacks_[id] != nullptr) {
+        callbacks_[id](id, EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+      }
+    }
+  }
+
+  // Tricky: if we added something at a positive level, and its status is
+  // not CANNOT_PROPAGATE, then we might need to fix it on backtrack.
+  if (trail_.CurrentDecisionLevel() > 0 &&
+      statuses_[id] != EnforcementStatus::CANNOT_PROPAGATE) {
+    ids_to_fix_until_next_root_level_.push_back(id);
+  }
+
+  return id;
+}
+
+// Add the enforcement reason to the given vector.
+void EnforcementPropagator::AddEnforcementReason(
+    EnforcementId id, std::vector<Literal>* reason) const {
+  for (const Literal l : GetSpan(id)) {
+    reason->push_back(l.Negated());
+  }
+}
+
+absl::Span<Literal> EnforcementPropagator::GetSpan(EnforcementId id) {
+  if (id < 0) return {};
+  DCHECK_LE(id + 1, starts_.size());
+  const int size = starts_[id + 1] - starts_[id];
+  DCHECK_NE(size, 0);
+  return absl::MakeSpan(&buffer_[starts_[id]], size);
+}
+
+absl::Span<const Literal> EnforcementPropagator::GetSpan(
+    EnforcementId id) const {
+  if (id < 0) return {};
+  DCHECK_LE(id + 1, starts_.size());
+  const int size = starts_[id + 1] - starts_[id];
+  DCHECK_NE(size, 0);
+  return absl::MakeSpan(&buffer_[starts_[id]], size);
+}
+
+LiteralIndex EnforcementPropagator::ProcessIdOnTrue(Literal watched,
+                                                    EnforcementId id) {
+  const EnforcementStatus status = statuses_[id];
+  if (status == EnforcementStatus::IS_FALSE) return kNoLiteralIndex;
+
+  const auto span = GetSpan(id);
+  if (span.size() == 1) {
+    CHECK_EQ(status, EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+    ChangeStatus(id, EnforcementStatus::IS_ENFORCED);
+    return kNoLiteralIndex;
+  }
+
+  const int watched_pos = (span[0] == watched) ? 0 : 1;
+  CHECK_EQ(span[watched_pos], watched);
+  if (assignment_.LiteralIsFalse(span[watched_pos ^ 1])) {
+    ChangeStatus(id, EnforcementStatus::IS_FALSE);
+    return kNoLiteralIndex;
+  }
+
+  for (int i = 2; i < span.size(); ++i) {
+    const Literal l = span[i];
+    if (assignment_.LiteralIsFalse(l)) {
+      ChangeStatus(id, EnforcementStatus::IS_FALSE);
+      return kNoLiteralIndex;
+    }
+    if (!assignment_.LiteralIsAssigned(l)) {
+      // Replace the watched literal. Note that if the other watched literal is
+      // true, it should be processed afterwards. We do not change the status
+      std::swap(span[watched_pos], span[i]);
+      return span[watched_pos].Index();
+    }
+  }
+
+  // All literal with index > 1 are true. Two case.
+  if (assignment_.LiteralIsTrue(span[watched_pos ^ 1])) {
+    // All literals are true.
+    ChangeStatus(id, EnforcementStatus::IS_ENFORCED);
+    return kNoLiteralIndex;
+  } else {
+    // The other watched literal is the last unassigned
+    CHECK_EQ(status, EnforcementStatus::CANNOT_PROPAGATE);
+    ChangeStatus(id, EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+    return kNoLiteralIndex;
+  }
+}
+
+void EnforcementPropagator::ChangeStatus(EnforcementId id,
+                                         EnforcementStatus new_status) {
+  const EnforcementStatus old_status = statuses_[id];
+  if (old_status == new_status) return;
+  if (trail_.CurrentDecisionLevel() != 0) {
+    untrail_stack_.push_back({id, old_status});
+  }
+  statuses_[id] = new_status;
+  if (callbacks_[id] != nullptr) callbacks_[id](id, new_status);
+}
+
+EnforcementStatus EnforcementPropagator::DebugStatus(EnforcementId id) {
+  if (id < 0) return EnforcementStatus::IS_ENFORCED;
+
+  int num_true = 0;
+  for (const Literal l : GetSpan(id)) {
+    if (assignment_.LiteralIsFalse(l)) {
+      return EnforcementStatus::IS_FALSE;
+    }
+    if (assignment_.LiteralIsTrue(l)) ++num_true;
+  }
+  const int size = GetSpan(id).size();
+  if (num_true == size) return EnforcementStatus::IS_ENFORCED;
+  if (num_true + 1 == size) return EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT;
+  return EnforcementStatus::CANNOT_PROPAGATE;
+}
+
+}  // namespace sat
+}  // namespace operations_research
diff --git a/ortools/sat/enforcement.h b/ortools/sat/enforcement.h
new file mode 100644
index 0000000000..1c2624f22d
--- /dev/null
+++ b/ortools/sat/enforcement.h
@@ -0,0 +1,134 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OR_TOOLS_SAT_ENFORCEMENT_H_
+#define OR_TOOLS_SAT_ENFORCEMENT_H_
+
+#include <cstdint>
+#include <functional>
+#include <ostream>
+#include <utility>
+#include <vector>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/types/span.h"
+#include "ortools/base/strong_vector.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_base.h"
+#include "ortools/util/rev.h"
+#include "ortools/util/strong_integers.h"
+
+namespace operations_research {
+namespace sat {
+
+DEFINE_STRONG_INDEX_TYPE(EnforcementId);
+
+// An enforced constraint can be in one of these 4 states.
+// Note that we rely on the integer encoding to take 2 bits for optimization.
+enum class EnforcementStatus {
+  // One enforcement literal is false.
+  IS_FALSE = 0,
+  // More than two literals are unassigned.
+  CANNOT_PROPAGATE = 1,
+  // All enforcement literals are true but one.
+  CAN_PROPAGATE_ENFORCEMENT = 2,
+  // All enforcement literals are true.
+  IS_ENFORCED = 3,
+};
+
+std::ostream& operator<<(std::ostream& os, const EnforcementStatus& e);
+
+// This is meant as an helper to deal with enforcement for any constraint.
+class EnforcementPropagator : public SatPropagator {
+ public:
+  explicit EnforcementPropagator(Model* model);
+
+  // SatPropagator interface.
+  bool Propagate(Trail* trail) final;
+  void Untrail(const Trail& trail, int trail_index) final;
+
+  // Adds a new constraint to the class and register a callback that will
+  // be called on status change. Note that we also call the callback with the
+  // initial status if different from CANNOT_PROPAGATE when added.
+  //
+  // It is better to not call this for empty enforcement list, but you can. A
+  // negative id means the level zero status will never change, and only the
+  // first call to callback() should be necessary, we don't save it.
+  EnforcementId Register(
+      absl::Span<const Literal> enforcement,
+      std::function<void(EnforcementId, EnforcementStatus)> callback = nullptr);
+
+  // Add the enforcement reason to the given vector.
+  void AddEnforcementReason(EnforcementId id,
+                            std::vector<Literal>* reason) const;
+
+  EnforcementStatus Status(EnforcementId id) const {
+    if (id < 0) return EnforcementStatus::IS_ENFORCED;
+    return statuses_[id];
+  }
+
+  // Recompute the status from the current assignment.
+  // This should only used in DCHECK().
+  EnforcementStatus DebugStatus(EnforcementId id);
+
+  // Returns the enforcement literals of the given id.
+  absl::Span<const Literal> GetEnforcementLiterals(EnforcementId id) const {
+    if (id < 0) return {};
+    return GetSpan(id);
+  }
+
+ private:
+  absl::Span<Literal> GetSpan(EnforcementId id);
+  absl::Span<const Literal> GetSpan(EnforcementId id) const;
+  void ChangeStatus(EnforcementId id, EnforcementStatus new_status);
+
+  // Returns kNoLiteralIndex if nothing need to change or a new literal to
+  // watch. This also calls the registered callback.
+  LiteralIndex ProcessIdOnTrue(Literal watched, EnforcementId id);
+
+  // External classes.
+  const Trail& trail_;
+  const VariablesAssignment& assignment_;
+  RevRepository<int> rev_int_repository_;
+
+  // All enforcement will be copied there, and we will create Span out of this.
+  // Note that we don't store the span so that we are not invalidated on buffer_
+  // resizing.
+  util_intops::StrongVector<EnforcementId, int> starts_;
+  std::vector<Literal> buffer_;
+
+  util_intops::StrongVector<EnforcementId, EnforcementStatus> statuses_;
+  util_intops::StrongVector<
+      EnforcementId, std::function<void(EnforcementId, EnforcementStatus)>>
+      callbacks_;
+
+  // Used to restore status and call callback on untrail.
+  std::vector<std::pair<EnforcementId, EnforcementStatus>> untrail_stack_;
+  int rev_stack_size_ = 0;
+  int64_t rev_stamp_ = 0;
+
+  // We use a two watcher scheme.
+  util_intops::StrongVector<LiteralIndex, absl::InlinedVector<EnforcementId, 6>>
+      watcher_;
+
+  std::vector<Literal> temp_literals_;
+
+  std::vector<EnforcementId> ids_to_fix_until_next_root_level_;
+
+  friend class EnforcementHelper;
+};
+
+}  // namespace sat
+}  // namespace operations_research
+
+#endif  // OR_TOOLS_SAT_ENFORCEMENT_H_
diff --git a/ortools/sat/enforcement_helper.cc b/ortools/sat/enforcement_helper.cc
new file mode 100644
index 0000000000..1252565f72
--- /dev/null
+++ b/ortools/sat/enforcement_helper.cc
@@ -0,0 +1,132 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/enforcement_helper.h"
+
+#include <functional>
+#include <vector>
+
+#include "absl/types/span.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/integer.h"
+#include "ortools/sat/integer_base.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_base.h"
+#include "ortools/util/strong_integers.h"
+
+namespace operations_research {
+namespace sat {
+
+EnforcementHelper::EnforcementHelper(Model* model)
+    : enforcement_propagator_(*model->GetOrCreate<EnforcementPropagator>()),
+      assignment_(model->GetOrCreate<Trail>()->Assignment()),
+      integer_trail_(model->GetOrCreate<IntegerTrail>()) {}
+
+EnforcementId EnforcementHelper::Register(
+    absl::Span<const Literal> enforcement_literals,
+    GenericLiteralWatcher* watcher, int literal_watcher_id) {
+  return enforcement_propagator_.Register(
+      enforcement_literals, [=](EnforcementId, EnforcementStatus status) {
+        if (status == EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT ||
+            status == EnforcementStatus::IS_ENFORCED) {
+          watcher->CallOnNextPropagate(literal_watcher_id);
+        }
+      });
+}
+
+// Try to propagate when the enforced constraint is not satisfiable.
+// This is currently in O(enforcement_size);
+bool EnforcementHelper::PropagateWhenFalse(
+    EnforcementId id, absl::Span<const Literal> literal_reason,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  temp_reason_.clear();
+  LiteralIndex unique_unassigned = kNoLiteralIndex;
+  for (const Literal l : enforcement_propagator_.GetSpan(id)) {
+    if (assignment_.LiteralIsFalse(l)) return true;
+    if (assignment_.LiteralIsTrue(l)) {
+      temp_reason_.push_back(l.Negated());
+      continue;
+    }
+    if (unique_unassigned != kNoLiteralIndex) return true;
+    unique_unassigned = l.Index();
+  }
+
+  temp_reason_.insert(temp_reason_.end(), literal_reason.begin(),
+                      literal_reason.end());
+  if (unique_unassigned == kNoLiteralIndex) {
+    return integer_trail_->ReportConflict(temp_reason_, integer_reason);
+  }
+
+  // We also change the status right away.
+  enforcement_propagator_.ChangeStatus(id, EnforcementStatus::IS_FALSE);
+  integer_trail_->EnqueueLiteral(Literal(unique_unassigned).Negated(),
+                                 temp_reason_, integer_reason);
+  return true;
+}
+
+bool EnforcementHelper::Enqueue(
+    EnforcementId id, IntegerLiteral i_lit,
+    absl::Span<const Literal> literal_reason,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  temp_reason_.clear();
+  temp_reason_.insert(temp_reason_.end(), literal_reason.begin(),
+                      literal_reason.end());
+  enforcement_propagator_.AddEnforcementReason(id, &temp_reason_);
+  return integer_trail_->Enqueue(i_lit, temp_reason_, integer_reason);
+}
+
+bool EnforcementHelper::SafeEnqueue(
+    EnforcementId id, IntegerLiteral i_lit,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  temp_reason_.clear();
+  enforcement_propagator_.AddEnforcementReason(id, &temp_reason_);
+  return integer_trail_->SafeEnqueue(i_lit, temp_reason_, integer_reason);
+}
+
+bool EnforcementHelper::ConditionalEnqueue(
+    EnforcementId id, Literal lit, IntegerLiteral i_lit,
+    absl::Span<const Literal> literal_reason,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  temp_reason_.clear();
+  temp_reason_.insert(temp_reason_.end(), literal_reason.begin(),
+                      literal_reason.end());
+  enforcement_propagator_.AddEnforcementReason(id, &temp_reason_);
+  temp_integer_reason_.clear();
+  temp_integer_reason_.insert(temp_integer_reason_.end(),
+                              integer_reason.begin(), integer_reason.end());
+  return integer_trail_->ConditionalEnqueue(lit, i_lit, &temp_reason_,
+                                            &temp_integer_reason_);
+}
+
+void EnforcementHelper::EnqueueLiteral(
+    EnforcementId id, Literal literal, absl::Span<const Literal> literal_reason,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  temp_reason_.clear();
+  temp_reason_.insert(temp_reason_.end(), literal_reason.begin(),
+                      literal_reason.end());
+  enforcement_propagator_.AddEnforcementReason(id, &temp_reason_);
+  return integer_trail_->EnqueueLiteral(literal, temp_reason_, integer_reason);
+}
+
+bool EnforcementHelper::ReportConflict(
+    EnforcementId id, absl::Span<const Literal> literal_reason,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  temp_reason_.clear();
+  temp_reason_.insert(temp_reason_.end(), literal_reason.begin(),
+                      literal_reason.end());
+  enforcement_propagator_.AddEnforcementReason(id, &temp_reason_);
+  return integer_trail_->ReportConflict(temp_reason_, integer_reason);
+}
+
+}  // namespace sat
+}  // namespace operations_research
diff --git a/ortools/sat/enforcement_helper.h b/ortools/sat/enforcement_helper.h
new file mode 100644
index 0000000000..f87d6c018d
--- /dev/null
+++ b/ortools/sat/enforcement_helper.h
@@ -0,0 +1,103 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OR_TOOLS_SAT_ENFORCEMENT_HELPER_H_
+#define OR_TOOLS_SAT_ENFORCEMENT_HELPER_H_
+
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "absl/types/span.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/integer.h"
+#include "ortools/sat/integer_base.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_base.h"
+
+namespace operations_research {
+namespace sat {
+
+// This is meant as an helper to deal with enforcement for any integer based
+// constraint. It wraps some IntegerTrail functions while making sure the
+// enforcement literals are properly added to the propagation reason.
+class EnforcementHelper {
+ public:
+  explicit EnforcementHelper(Model* model);
+
+  // Calls `Register` with a callback calling
+  // `watcher->CallOnNextPropagate(literal_watcher_id)` if a propagation might
+  // be possible.
+  EnforcementId Register(absl::Span<const Literal> enforcement_literals,
+                         GenericLiteralWatcher* watcher,
+                         int literal_watcher_id);
+
+  // Add the enforcement reason to the given vector.
+  void AddEnforcementReason(EnforcementId id,
+                            std::vector<Literal>* reason) const {
+    enforcement_propagator_.AddEnforcementReason(id, reason);
+  }
+
+  // Try to propagate when the enforced constraint is not satisfiable.
+  // This is currently in O(enforcement_size).
+  ABSL_MUST_USE_RESULT bool PropagateWhenFalse(
+      EnforcementId id, absl::Span<const Literal> literal_reason,
+      absl::Span<const IntegerLiteral> integer_reason);
+
+  ABSL_MUST_USE_RESULT bool Enqueue(
+      EnforcementId id, IntegerLiteral i_lit,
+      absl::Span<const Literal> literal_reason,
+      absl::Span<const IntegerLiteral> integer_reason);
+
+  ABSL_MUST_USE_RESULT bool SafeEnqueue(
+      EnforcementId id, IntegerLiteral i_lit,
+      absl::Span<const IntegerLiteral> integer_reason);
+
+  ABSL_MUST_USE_RESULT bool ConditionalEnqueue(
+      EnforcementId id, Literal lit, IntegerLiteral i_lit,
+      absl::Span<const Literal> literal_reason,
+      absl::Span<const IntegerLiteral> integer_reason);
+
+  void EnqueueLiteral(EnforcementId id, Literal literal,
+                      absl::Span<const Literal> literal_reason,
+                      absl::Span<const IntegerLiteral> integer_reason);
+
+  bool ReportConflict(EnforcementId id,
+                      absl::Span<const IntegerLiteral> integer_reason) {
+    return ReportConflict(id, /*literal_reason=*/{}, integer_reason);
+  }
+
+  bool ReportConflict(EnforcementId id,
+                      absl::Span<const Literal> literal_reason,
+                      absl::Span<const IntegerLiteral> integer_reason);
+
+  EnforcementStatus Status(EnforcementId id) const {
+    return enforcement_propagator_.Status(id);
+  }
+
+  // Returns the enforcement literals of the given id.
+  absl::Span<const Literal> GetEnforcementLiterals(EnforcementId id) const {
+    return enforcement_propagator_.GetEnforcementLiterals(id);
+  }
+
+ private:
+  EnforcementPropagator& enforcement_propagator_;
+  const VariablesAssignment& assignment_;
+  IntegerTrail* integer_trail_;
+  std::vector<Literal> temp_reason_;
+  std::vector<IntegerLiteral> temp_integer_reason_;
+};
+
+}  // namespace sat
+}  // namespace operations_research
+
+#endif  // OR_TOOLS_SAT_ENFORCEMENT_HELPER_H_
diff --git a/ortools/sat/enforcement_test.cc b/ortools/sat/enforcement_test.cc
new file mode 100644
index 0000000000..bed30d8fda
--- /dev/null
+++ b/ortools/sat/enforcement_test.cc
@@ -0,0 +1,146 @@
+// Copyright 2010-2025 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ortools/sat/enforcement.h"
+
+#include <stdint.h>
+
+#include <vector>
+
+#include "absl/log/check.h"
+#include "absl/types/span.h"
+#include "gtest/gtest.h"
+#include "ortools/base/logging.h"
+#include "ortools/sat/model.h"
+#include "ortools/sat/sat_base.h"
+#include "ortools/sat/sat_solver.h"
+
+namespace operations_research {
+namespace sat {
+namespace {
+
+TEST(EnforcementPropagatorTest, BasicTest) {
+  Model model;
+  auto* sat_solver = model.GetOrCreate<SatSolver>();
+  auto* trail = model.GetOrCreate<Trail>();
+  auto* propag = model.GetOrCreate<EnforcementPropagator>();
+  sat_solver->SetNumVariables(10);
+
+  const EnforcementId id1 = propag->Register(Literals({+1}));
+  const EnforcementId id2 = propag->Register(Literals({+1, +2}));
+  const EnforcementId id3 = propag->Register(Literals({-2}));
+
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CANNOT_PROPAGATE);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+
+  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+1));
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+
+  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+2));
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::IS_FALSE);
+
+  CHECK(sat_solver->ResetToLevelZero());
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CANNOT_PROPAGATE);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+}
+
+TEST(EnforcementPropagatorTest, UntrailWork) {
+  Model model;
+  auto* sat_solver = model.GetOrCreate<SatSolver>();
+  auto* trail = model.GetOrCreate<Trail>();
+  auto* propag = model.GetOrCreate<EnforcementPropagator>();
+  sat_solver->SetNumVariables(10);
+
+  const EnforcementId id1 = propag->Register(Literals({+1}));
+  const EnforcementId id2 = propag->Register(Literals({+2}));
+  const EnforcementId id3 = propag->Register(Literals({+3}));
+
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+
+  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+1));
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+
+  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+2));
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+  const int level = sat_solver->CurrentDecisionLevel();
+
+  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+3));
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::IS_ENFORCED);
+
+  sat_solver->Backtrack(level);
+  EXPECT_EQ(propag->Status(id1), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id2), EnforcementStatus::IS_ENFORCED);
+  EXPECT_EQ(propag->Status(id3), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+}
+
+TEST(EnforcementPropagatorTest, AddingAtPositiveLevelTrue) {
+  Model model;
+  auto* sat_solver = model.GetOrCreate<SatSolver>();
+  auto* trail = model.GetOrCreate<Trail>();
+  auto* propag = model.GetOrCreate<EnforcementPropagator>();
+  sat_solver->SetNumVariables(10);
+
+  EXPECT_TRUE(propag->Propagate(trail));
+  sat_solver->EnqueueDecisionIfNotConflicting(Literal(+1));
+  EXPECT_TRUE(propag->Propagate(trail));
+
+  const EnforcementId id = propag->Register(std::vector<Literal>{+1});
+  EXPECT_EQ(propag->Status(id), EnforcementStatus::IS_ENFORCED);
+
+  sat_solver->Backtrack(0);
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+}
+
+TEST(EnforcementPropagatorTest, AddingAtPositiveLevelFalse) {
+  Model model;
+  auto* sat_solver = model.GetOrCreate<SatSolver>();
+  auto* trail = model.GetOrCreate<Trail>();
+  auto* propag = model.GetOrCreate<EnforcementPropagator>();
+  sat_solver->SetNumVariables(10);
+
+  EXPECT_TRUE(propag->Propagate(trail));
+  sat_solver->EnqueueDecisionIfNotConflicting(Literal(-1));
+  EXPECT_TRUE(propag->Propagate(trail));
+
+  const EnforcementId id = propag->Register(std::vector<Literal>{+1});
+  EXPECT_EQ(propag->Status(id), EnforcementStatus::IS_FALSE);
+
+  sat_solver->Backtrack(0);
+  EXPECT_TRUE(propag->Propagate(trail));
+  EXPECT_EQ(propag->Status(id), EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT);
+}
+
+}  // namespace
+}  // namespace sat
+}  // namespace operations_research
diff --git a/ortools/sat/implied_bounds_test.cc b/ortools/sat/implied_bounds_test.cc
index 41f79b71e8..b0092dad9a 100644
--- a/ortools/sat/implied_bounds_test.cc
+++ b/ortools/sat/implied_bounds_test.cc
@@ -80,11 +80,11 @@ TEST(ImpliedBoundsTest, BasicTestPositiveLevel) {
   EXPECT_TRUE(ib->Add(enforcement.Negated(),
                       IntegerLiteral::GreaterOrEqual(var, IntegerValue(7))));
 
-  // Now, only the level zero bound is up to date.
-  EXPECT_EQ(integer_trail->LowerBound(var), IntegerValue(0));
+  // Now, because the new "root bound" is better, we update both bounds.
+  EXPECT_EQ(integer_trail->LowerBound(var), IntegerValue(3));
   EXPECT_EQ(integer_trail->LevelZeroLowerBound(var), IntegerValue(3));
 
-  // But on the next restart, nothing is lost.
+  // And on the next restart, nothing is lost.
   EXPECT_TRUE(sat_solver->ResetToLevelZero());
   EXPECT_EQ(integer_trail->LowerBound(var), IntegerValue(3));
 }
diff --git a/ortools/sat/integer.cc b/ortools/sat/integer.cc
index 076ea5810e..7691ffa88e 100644
--- a/ortools/sat/integer.cc
+++ b/ortools/sat/integer.cc
@@ -1235,11 +1235,39 @@ bool IntegerTrail::RootLevelEnqueue(IntegerLiteral i_lit) {
     return true;
   }
 
-  // We update right away the level zero bounds, but delay the actual enqueue
-  // until we are back at level zero. This allow to properly push any associated
-  // literal.
+  // If the new level zero bounds is greater than or equal to our best bound, we
+  // "clear" all entries associated to this variables and only keep the level
+  // zero entry.
+  //
+  // TODO(user): We could still "clear" just a subset of the entries event
+  // if the recent ones are still needed.
+  if (i_lit.bound >= var_lbs_[i_lit.var]) {
+    int index = var_trail_index_[i_lit.var];
+    const int num_vars = var_lbs_.size();
+    while (index >= num_vars) {
+      integer_trail_[index].var = kNoIntegerVariable;
+      index = integer_trail_[index].prev_trail_index;
+    }
+    DCHECK_EQ(index, i_lit.var.value());
+
+    // Point to the level zero entry.
+    DCHECK_GE(i_lit.bound, var_lbs_[i_lit.var]);
+    var_lbs_[i_lit.var] = i_lit.bound;
+    var_trail_index_[i_lit.var] = index;
+
+    // TODO(user): we might update this twice, but it is important to at least
+    // increase this as this counter can be used for "timestamping" and here
+    // we did change a bound.
+    ++num_enqueues_;
+  }
+
+  // Update the level-zero bound in any case.
   integer_trail_[i_lit.var.value()].bound = i_lit.bound;
+
+  // Make sure we will update InitialVariableDomain() when we are back
+  // at level zero.
   delayed_to_fix_->integer_literal_to_fix.push_back(i_lit);
+
   return true;
 }
 
@@ -1397,6 +1425,18 @@ void IntegerTrail::EnqueueLiteral(
   EnqueueLiteralInternal(literal, false, literal_reason, integer_reason);
 }
 
+bool IntegerTrail::SafeEnqueueLiteral(
+    Literal literal, absl::Span<const Literal> literal_reason,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  if (trail_->Assignment().LiteralIsTrue(literal)) {
+    return true;
+  } else if (trail_->Assignment().LiteralIsFalse(literal)) {
+    return ReportConflict(literal_reason, integer_reason);
+  }
+  EnqueueLiteralInternal(literal, false, literal_reason, integer_reason);
+  return true;
+}
+
 void IntegerTrail::EnqueueLiteralInternal(
     Literal literal, bool use_lazy_reason,
     absl::Span<const Literal> literal_reason,
@@ -1870,6 +1910,7 @@ void IntegerTrail::MergeReasonIntoInternal(std::vector<Literal>* output,
     DCHECK_GE(trail_index, var_lbs_.size());
     DCHECK_LT(trail_index, integer_trail_.size());
     const TrailEntry& entry = integer_trail_[trail_index];
+    DCHECK_NE(entry.var, kNoIntegerVariable);
     tmp_var_to_trail_index_in_queue_[entry.var] =
         std::max(tmp_var_to_trail_index_in_queue_[entry.var], trail_index);
   }
@@ -1892,6 +1933,7 @@ void IntegerTrail::MergeReasonIntoInternal(std::vector<Literal>* output,
     // Skip any stale queue entry. Amongst all the entry referring to a given
     // variable, only the latest added to the queue is valid and we detect it
     // using its trail index.
+    DCHECK_NE(entry.var, kNoIntegerVariable);
     if (tmp_var_to_trail_index_in_queue_[entry.var] != trail_index) {
       continue;
     }
@@ -1974,6 +2016,11 @@ void IntegerTrail::MergeReasonIntoInternal(std::vector<Literal>* output,
       DCHECK_LT(next_trail_index, trail_index);
       const TrailEntry& next_entry = integer_trail_[next_trail_index];
 
+      // Tricky: we cache trail_index in Dependencies() but it is possible
+      // via RootLevelEnqueue() that some of the trail index listed here are
+      // "stale", so we skip any entry with a kNoIntegerVariable.
+      if (next_entry.var == kNoIntegerVariable) continue;
+
       // Only add literals that are not "implied" by the ones already present.
       // For instance, do not add (x >= 4) if we already have (x >= 7). This
       // translate into only adding a trail index if it is larger than the one
@@ -2051,6 +2098,13 @@ absl::Span<const Literal> IntegerTrail::Reason(const Trail& trail,
   DCHECK(tmp_queue_.empty());
   for (const int prev_trail_index : Dependencies(reason_index)) {
     DCHECK_GE(prev_trail_index, var_lbs_.size());
+
+    // Tricky: we cache trail_index in Dependencies() but it is possible
+    // via RootLevelEnqueue() that some of the trail indices listed here are
+    // "stale", so we skip any entry with a kNoIntegerVariable.
+    const TrailEntry& next_entry = integer_trail_[prev_trail_index];
+    if (next_entry.var == kNoIntegerVariable) continue;
+
     tmp_queue_.push_back(prev_trail_index);
   }
   MergeReasonIntoInternal(reason, conflict_id);
diff --git a/ortools/sat/integer.h b/ortools/sat/integer.h
index c127aa6be5..b7aefdb1d9 100644
--- a/ortools/sat/integer.h
+++ b/ortools/sat/integer.h
@@ -72,8 +72,11 @@ struct LiteralValueValue {
 // Sometimes we propagate fact with no reason at a positive level, those
 // will automatically be fixed on the next restart.
 //
-// TODO(user): If we change the logic to not restart right away, we probably
-// need to remove duplicates bounds for the same variable.
+// Note that for integer literal, we already remore all "stale" entry, however
+// this is still needed to properly update the InitialVariableDomain().
+//
+// TODO(user): we should update the initial domain right away, but this as
+// some complication to clean up first.
 struct DelayedRootLevelDeduction {
   std::vector<Literal> literal_to_fix;
   std::vector<IntegerLiteral> integer_literal_to_fix;
@@ -689,6 +692,10 @@ class IntegerTrail final : public SatPropagator {
   void EnqueueLiteral(Literal literal, absl::Span<const Literal> literal_reason,
                       absl::Span<const IntegerLiteral> integer_reason);
 
+  bool SafeEnqueueLiteral(Literal literal,
+                          absl::Span<const Literal> literal_reason,
+                          absl::Span<const IntegerLiteral> integer_reason);
+
   // Returns the reason (as set of Literal currently false) for a given integer
   // literal. Note that the bound must be less restrictive than the current
   // bound (checked).
diff --git a/ortools/sat/integer_expr.cc b/ortools/sat/integer_expr.cc
index 498a2152fb..96c535fb9e 100644
--- a/ortools/sat/integer_expr.cc
+++ b/ortools/sat/integer_expr.cc
@@ -26,7 +26,7 @@
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
 #include "ortools/base/mathutil.h"
-#include "ortools/sat/cp_constraints.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/linear_constraint.h"
@@ -644,20 +644,27 @@ void MinPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
   watcher->WatchUpperBound(min_var_, id);
 }
 
-LinMinPropagator::LinMinPropagator(std::vector<LinearExpression> exprs,
-                                   IntegerVariable min_var, Model* model)
+GreaterThanMinOfExprsPropagator::GreaterThanMinOfExprsPropagator(
+    absl::Span<const Literal> enforcement_literals,
+    std::vector<LinearExpression> exprs, IntegerVariable min_var, Model* model)
     : exprs_(std::move(exprs)),
       min_var_(min_var),
       model_(model),
-      integer_trail_(model_->GetOrCreate<IntegerTrail>()) {}
+      integer_trail_(*model_->GetOrCreate<IntegerTrail>()),
+      enforcement_helper_(*model_->GetOrCreate<EnforcementHelper>()) {
+  GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
+}
 
-void LinMinPropagator::Explain(int id, IntegerValue propagation_slack,
-                               IntegerVariable var_to_explain, int trail_index,
-                               std::vector<Literal>* literals_reason,
-                               std::vector<int>* trail_indices_reason) {
+void GreaterThanMinOfExprsPropagator::Explain(
+    int id, IntegerValue propagation_slack, IntegerVariable var_to_explain,
+    int trail_index, std::vector<Literal>* literals_reason,
+    std::vector<int>* trail_indices_reason) {
   const auto& vars = exprs_[id].vars;
   const auto& coeffs = exprs_[id].coeffs;
   literals_reason->clear();
+  enforcement_helper_.AddEnforcementReason(enforcement_id_, literals_reason);
   trail_indices_reason->clear();
   std::vector<IntegerValue> reason_coeffs;
   const int size = vars.size();
@@ -667,7 +674,7 @@ void LinMinPropagator::Explain(int id, IntegerValue propagation_slack,
       continue;
     }
     const int index =
-        integer_trail_->FindTrailIndexOfVarBefore(var, trail_index);
+        integer_trail_.FindTrailIndexOfVarBefore(var, trail_index);
     if (index >= 0) {
       trail_indices_reason->push_back(index);
       if (propagation_slack > 0) {
@@ -676,20 +683,20 @@ void LinMinPropagator::Explain(int id, IntegerValue propagation_slack,
     }
   }
   if (propagation_slack > 0) {
-    integer_trail_->RelaxLinearReason(propagation_slack, reason_coeffs,
-                                      trail_indices_reason);
+    integer_trail_.RelaxLinearReason(propagation_slack, reason_coeffs,
+                                     trail_indices_reason);
   }
   // Now add the old integer_reason that triggered this propagation.
   for (IntegerLiteral reason_lit : integer_reason_for_unique_candidate_) {
     const int index =
-        integer_trail_->FindTrailIndexOfVarBefore(reason_lit.var, trail_index);
+        integer_trail_.FindTrailIndexOfVarBefore(reason_lit.var, trail_index);
     if (index >= 0) {
       trail_indices_reason->push_back(index);
     }
   }
 }
 
-bool LinMinPropagator::PropagateLinearUpperBound(
+bool GreaterThanMinOfExprsPropagator::PropagateLinearUpperBound(
     int id, absl::Span<const IntegerVariable> vars,
     absl::Span<const IntegerValue> coeffs, const IntegerValue upper_bound) {
   IntegerValue sum_lb = IntegerValue(0);
@@ -700,8 +707,8 @@ bool LinMinPropagator::PropagateLinearUpperBound(
     const IntegerValue coeff = coeffs[i];
     // The coefficients are assumed to be positive for this to work properly.
     DCHECK_GE(coeff, 0);
-    const IntegerValue lb = integer_trail_->LowerBound(var);
-    const IntegerValue ub = integer_trail_->UpperBound(var);
+    const IntegerValue lb = integer_trail_.LowerBound(var);
+    const IntegerValue ub = integer_trail_.UpperBound(var);
     max_variations_[i] = (ub - lb) * coeff;
     sum_lb += lb * coeff;
   }
@@ -709,6 +716,7 @@ bool LinMinPropagator::PropagateLinearUpperBound(
   model_->GetOrCreate<TimeLimit>()->AdvanceDeterministicTime(
       static_cast<double>(num_vars) * 1e-9);
 
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
   const IntegerValue slack = upper_bound - sum_lb;
   if (slack < 0) {
     // Conflict.
@@ -716,30 +724,36 @@ bool LinMinPropagator::PropagateLinearUpperBound(
     reason_coeffs_.clear();
     for (int i = 0; i < num_vars; ++i) {
       const IntegerVariable var = vars[i];
-      if (!integer_trail_->VariableLowerBoundIsFromLevelZero(var)) {
-        local_reason_.push_back(integer_trail_->LowerBoundAsLiteral(var));
+      if (!integer_trail_.VariableLowerBoundIsFromLevelZero(var)) {
+        local_reason_.push_back(integer_trail_.LowerBoundAsLiteral(var));
         reason_coeffs_.push_back(coeffs[i]);
       }
     }
-    integer_trail_->RelaxLinearReason(-slack - 1, reason_coeffs_,
-                                      &local_reason_);
+    integer_trail_.RelaxLinearReason(-slack - 1, reason_coeffs_,
+                                     &local_reason_);
     local_reason_.insert(local_reason_.end(),
                          integer_reason_for_unique_candidate_.begin(),
                          integer_reason_for_unique_candidate_.end());
-    return integer_trail_->ReportConflict({}, local_reason_);
+    if (status == EnforcementStatus::IS_ENFORCED) {
+      return enforcement_helper_.ReportConflict(enforcement_id_, local_reason_);
+    } else {
+      return enforcement_helper_.PropagateWhenFalse(
+          enforcement_id_, /*literal_reason=*/{}, local_reason_);
+    }
   }
 
   // The lower bound of all the variables except one can be used to update the
   // upper bound of the last one.
+  if (status != EnforcementStatus::IS_ENFORCED) return true;
   for (int i = 0; i < num_vars; ++i) {
     if (max_variations_[i] <= slack) continue;
 
     const IntegerVariable var = vars[i];
     const IntegerValue coeff = coeffs[i];
     const IntegerValue div = slack / coeff;
-    const IntegerValue new_ub = integer_trail_->LowerBound(var) + div;
+    const IntegerValue new_ub = integer_trail_.LowerBound(var) + div;
     const IntegerValue propagation_slack = (div + 1) * coeff - slack - 1;
-    if (!integer_trail_->EnqueueWithLazyReason(
+    if (!integer_trail_.EnqueueWithLazyReason(
             IntegerLiteral::LowerOrEqual(var, new_ub), id, propagation_slack,
             this)) {
       return false;
@@ -748,19 +762,26 @@ bool LinMinPropagator::PropagateLinearUpperBound(
   return true;
 }
 
-bool LinMinPropagator::Propagate() {
-  if (exprs_.empty()) return true;
+bool GreaterThanMinOfExprsPropagator::Propagate() {
+  // The case of empty exprs is handled in cp_model_loader.cc.
+  DCHECK(!exprs_.empty());
+
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status != EnforcementStatus::IS_ENFORCED &&
+      status != EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT) {
+    return true;
+  }
 
   // Count the number of interval that are possible candidate for the min.
   // Only the intervals for which lb > current_min_ub cannot.
-  const IntegerValue current_min_ub = integer_trail_->UpperBound(min_var_);
+  const IntegerValue current_min_ub = integer_trail_.UpperBound(min_var_);
   int num_intervals_that_can_be_min = 0;
   int last_possible_min_interval = 0;
 
   expr_lbs_.clear();
   IntegerValue min_of_linear_expression_lb = kMaxIntegerValue;
   for (int i = 0; i < exprs_.size(); ++i) {
-    const IntegerValue lb = exprs_[i].Min(*integer_trail_);
+    const IntegerValue lb = exprs_[i].Min(integer_trail_);
     expr_lbs_.push_back(lb);
     min_of_linear_expression_lb = std::min(min_of_linear_expression_lb, lb);
     if (lb <= current_min_ub) {
@@ -776,17 +797,28 @@ bool LinMinPropagator::Propagate() {
   if (min_of_linear_expression_lb > current_min_ub) {
     min_of_linear_expression_lb = current_min_ub + 1;
   }
-  if (min_of_linear_expression_lb > integer_trail_->LowerBound(min_var_)) {
+  if (min_of_linear_expression_lb > integer_trail_.LowerBound(min_var_)) {
     local_reason_.clear();
     for (int i = 0; i < exprs_.size(); ++i) {
       const IntegerValue slack = expr_lbs_[i] - min_of_linear_expression_lb;
-      integer_trail_->AppendRelaxedLinearReason(slack, exprs_[i].coeffs,
-                                                exprs_[i].vars, &local_reason_);
+      integer_trail_.AppendRelaxedLinearReason(slack, exprs_[i].coeffs,
+                                               exprs_[i].vars, &local_reason_);
     }
-    if (!integer_trail_->Enqueue(IntegerLiteral::GreaterOrEqual(
-                                     min_var_, min_of_linear_expression_lb),
-                                 {}, local_reason_)) {
-      return false;
+    if (status == EnforcementStatus::IS_ENFORCED) {
+      if (!enforcement_helper_.SafeEnqueue(
+              enforcement_id_,
+              IntegerLiteral::GreaterOrEqual(min_var_,
+                                             min_of_linear_expression_lb),
+              local_reason_)) {
+        return false;
+      }
+    } else if (min_of_linear_expression_lb > current_min_ub) {
+      // If the upper bound of min_var_ is strictly smaller than the lower bound
+      // of all the expressions, then the enforcement must be false.
+      local_reason_.push_back(
+          IntegerLiteral::LowerOrEqual(min_var_, current_min_ub));
+      return enforcement_helper_.PropagateWhenFalse(
+          enforcement_id_, /*literal_reason=*/{}, local_reason_);
     }
   }
 
@@ -796,7 +828,7 @@ bool LinMinPropagator::Propagate() {
   // In this case, ub(min) >= ub(e).
   if (num_intervals_that_can_be_min == 1) {
     const IntegerValue ub_of_only_candidate =
-        exprs_[last_possible_min_interval].Max(*integer_trail_);
+        exprs_[last_possible_min_interval].Max(integer_trail_);
     if (current_min_ub < ub_of_only_candidate) {
       // For this propagation, we only need to fill the integer reason once at
       // the lowest level. At higher levels this reason still remains valid.
@@ -806,11 +838,11 @@ bool LinMinPropagator::Propagate() {
         // The reason is that all the other interval start after current_min_ub.
         // And that min_ub has its current value.
         integer_reason_for_unique_candidate_.push_back(
-            integer_trail_->UpperBoundAsLiteral(min_var_));
+            integer_trail_.UpperBoundAsLiteral(min_var_));
         for (int i = 0; i < exprs_.size(); ++i) {
           if (i == last_possible_min_interval) continue;
           const IntegerValue slack = expr_lbs_[i] - (current_min_ub + 1);
-          integer_trail_->AppendRelaxedLinearReason(
+          integer_trail_.AppendRelaxedLinearReason(
               slack, exprs_[i].coeffs, exprs_[i].vars,
               &integer_reason_for_unique_candidate_);
         }
@@ -827,7 +859,8 @@ bool LinMinPropagator::Propagate() {
   return true;
 }
 
-void LinMinPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
+int GreaterThanMinOfExprsPropagator::RegisterWith(
+    GenericLiteralWatcher* watcher) {
   const int id = watcher->Register(this);
   bool has_var_also_in_exprs = false;
   for (const LinearExpression& expr : exprs_) {
@@ -847,6 +880,7 @@ void LinMinPropagator::RegisterWith(GenericLiteralWatcher* watcher) {
   if (has_var_also_in_exprs) {
     watcher->NotifyThatPropagatorMayNotReachFixedPointInOnePass(id);
   }
+  return id;
 }
 
 ProductPropagator::ProductPropagator(
@@ -856,10 +890,10 @@ ProductPropagator::ProductPropagator(
       b_(b),
       p_(p),
       integer_trail_(*model->GetOrCreate<IntegerTrail>()),
-      enforcement_propagator_(*model->GetOrCreate<EnforcementPropagator>()) {
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
-  enforcement_id_ = enforcement_propagator_.Register(
-      enforcement_literals, watcher, RegisterWith(watcher));
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
 }
 
 // We want all affine expression to be either non-negative or across zero.
@@ -876,7 +910,7 @@ bool ProductPropagator::CanonicalizeCases() {
   // If both a and b positive, p must be too.
   if (integer_trail_.LowerBound(a_) >= 0 &&
       integer_trail_.LowerBound(b_) >= 0) {
-    return enforcement_propagator_.SafeEnqueue(
+    return enforcement_helper_.SafeEnqueue(
         enforcement_id_, p_.GreaterOrEqual(0),
         {a_.GreaterOrEqual(0), b_.GreaterOrEqual(0)});
   }
@@ -910,7 +944,7 @@ bool ProductPropagator::PropagateWhenAllNonNegative() {
     const IntegerValue max_b = integer_trail_.UpperBound(b_);
     const IntegerValue new_max = CapProdI(max_a, max_b);
     if (new_max < integer_trail_.UpperBound(p_)) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, p_.LowerOrEqual(new_max),
               {integer_trail_.UpperBoundAsLiteral(a_),
                integer_trail_.UpperBoundAsLiteral(b_), a_.GreaterOrEqual(0),
@@ -928,13 +962,13 @@ bool ProductPropagator::PropagateWhenAllNonNegative() {
     // The conflict test is needed because when new_min is large, we could
     // have an overflow in p_.GreaterOrEqual(new_min);
     if (new_min > integer_trail_.UpperBound(p_)) {
-      return enforcement_propagator_.ReportConflict(
+      return enforcement_helper_.ReportConflict(
           enforcement_id_, {integer_trail_.UpperBoundAsLiteral(p_),
                             integer_trail_.LowerBoundAsLiteral(a_),
                             integer_trail_.LowerBoundAsLiteral(b_)});
     }
     if (new_min > integer_trail_.LowerBound(p_)) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, p_.GreaterOrEqual(new_min),
               {integer_trail_.LowerBoundAsLiteral(a_),
                integer_trail_.LowerBoundAsLiteral(b_)})) {
@@ -952,14 +986,14 @@ bool ProductPropagator::PropagateWhenAllNonNegative() {
     const IntegerValue max_p = integer_trail_.UpperBound(p_);
     const IntegerValue prod = CapProdI(max_a, min_b);
     if (prod > max_p) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, a.LowerOrEqual(FloorRatio(max_p, min_b)),
               {integer_trail_.LowerBoundAsLiteral(b),
                integer_trail_.UpperBoundAsLiteral(p_), p_.GreaterOrEqual(0)})) {
         return false;
       }
     } else if (prod < min_p && max_a != 0) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, b.GreaterOrEqual(CeilRatio(min_p, max_a)),
               {integer_trail_.UpperBoundAsLiteral(a),
                integer_trail_.LowerBoundAsLiteral(p_), a.GreaterOrEqual(0)})) {
@@ -985,7 +1019,7 @@ bool ProductPropagator::PropagateMaxOnPositiveProduct(AffineExpression a,
 
   if (max_a >= min_p) {
     if (max_p < max_a) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, a.LowerOrEqual(max_p),
               {p_.LowerOrEqual(max_p), p_.GreaterOrEqual(1)})) {
         return false;
@@ -996,7 +1030,7 @@ bool ProductPropagator::PropagateMaxOnPositiveProduct(AffineExpression a,
 
   const IntegerValue min_pos_b = CeilRatio(min_p, max_a);
   if (min_pos_b > integer_trail_.UpperBound(b)) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, b.LowerOrEqual(0),
             {integer_trail_.LowerBoundAsLiteral(p_),
              integer_trail_.UpperBoundAsLiteral(a),
@@ -1008,7 +1042,7 @@ bool ProductPropagator::PropagateMaxOnPositiveProduct(AffineExpression a,
 
   const IntegerValue new_max_a = FloorRatio(max_p, min_pos_b);
   if (new_max_a < integer_trail_.UpperBound(a)) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, a.LowerOrEqual(new_max_a),
             {integer_trail_.LowerBoundAsLiteral(p_),
              integer_trail_.UpperBoundAsLiteral(a),
@@ -1020,9 +1054,8 @@ bool ProductPropagator::PropagateMaxOnPositiveProduct(AffineExpression a,
 }
 
 bool ProductPropagator::Propagate() {
-  const EnforcementStatus status =
-      enforcement_propagator_.Status(enforcement_id_);
-  if (status == EnforcementStatus::CAN_PROPAGATE) {
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status == EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT) {
     const int64_t min_a = integer_trail_.LowerBound(a_).value();
     const int64_t max_a = integer_trail_.UpperBound(a_).value();
     const int64_t min_b = integer_trail_.LowerBound(b_).value();
@@ -1038,7 +1071,7 @@ bool ProductPropagator::Propagate() {
     // If the bounds of a * b and p are disjoint, the enforcement must be false.
     // TODO(user): relax the reason in a better way.
     if (min_ab > max_p) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {a_.GreaterOrEqual(min_a), a_.LowerOrEqual(max_a),
@@ -1046,7 +1079,7 @@ bool ProductPropagator::Propagate() {
            p_.LowerOrEqual(max_p)});
     }
     if (min_p > max_ab) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {a_.GreaterOrEqual(min_a), a_.LowerOrEqual(max_a),
@@ -1084,7 +1117,7 @@ bool ProductPropagator::Propagate() {
   const IntegerValue p4 = CapProdI(min_a, min_b);
   const IntegerValue new_max_p = std::max({p1, p2, p3, p4});
   if (new_max_p < integer_trail_.UpperBound(p_)) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, p_.LowerOrEqual(new_max_p),
             {integer_trail_.LowerBoundAsLiteral(a_),
              integer_trail_.LowerBoundAsLiteral(b_),
@@ -1095,7 +1128,7 @@ bool ProductPropagator::Propagate() {
   }
   const IntegerValue new_min_p = std::min({p1, p2, p3, p4});
   if (new_min_p > integer_trail_.LowerBound(p_)) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, p_.GreaterOrEqual(new_min_p),
             {integer_trail_.LowerBoundAsLiteral(a_),
              integer_trail_.LowerBoundAsLiteral(b_),
@@ -1113,14 +1146,14 @@ bool ProductPropagator::Propagate() {
   const bool zero_is_possible = min_p <= 0;
   if (!zero_is_possible) {
     if (integer_trail_.LowerBound(a_) == 0) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, a_.GreaterOrEqual(1),
               {p_.GreaterOrEqual(1), a_.GreaterOrEqual(0)})) {
         return false;
       }
     }
     if (integer_trail_.LowerBound(b_) == 0) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, b_.GreaterOrEqual(1),
               {p_.GreaterOrEqual(1), b_.GreaterOrEqual(0)})) {
         return false;
@@ -1128,13 +1161,13 @@ bool ProductPropagator::Propagate() {
     }
     if (integer_trail_.LowerBound(a_) >= 0 &&
         integer_trail_.LowerBound(b_) <= 0) {
-      return enforcement_propagator_.SafeEnqueue(
+      return enforcement_helper_.SafeEnqueue(
           enforcement_id_, b_.GreaterOrEqual(1),
           {a_.GreaterOrEqual(0), p_.GreaterOrEqual(1)});
     }
     if (integer_trail_.LowerBound(b_) >= 0 &&
         integer_trail_.LowerBound(a_) <= 0) {
-      return enforcement_propagator_.SafeEnqueue(
+      return enforcement_helper_.SafeEnqueue(
           enforcement_id_, a_.GreaterOrEqual(1),
           {b_.GreaterOrEqual(0), p_.GreaterOrEqual(1)});
     }
@@ -1171,12 +1204,12 @@ bool ProductPropagator::Propagate() {
     // If it does, we should reach the fixed point on the next iteration.
     if (min_b <= 0) continue;
     if (min_p >= 0) {
-      return enforcement_propagator_.SafeEnqueue(
+      return enforcement_helper_.SafeEnqueue(
           enforcement_id_, a.GreaterOrEqual(0),
           {p_.GreaterOrEqual(0), b.GreaterOrEqual(1)});
     }
     if (max_p <= 0) {
-      return enforcement_propagator_.SafeEnqueue(
+      return enforcement_helper_.SafeEnqueue(
           enforcement_id_, a.LowerOrEqual(0),
           {p_.LowerOrEqual(0), b.GreaterOrEqual(1)});
     }
@@ -1184,7 +1217,7 @@ bool ProductPropagator::Propagate() {
     // So min_b > 0 and p is across zero: min_p < 0 and max_p > 0.
     const IntegerValue new_max_a = FloorRatio(max_p, min_b);
     if (new_max_a < integer_trail_.UpperBound(a)) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, a.LowerOrEqual(new_max_a),
               {integer_trail_.UpperBoundAsLiteral(p_),
                integer_trail_.LowerBoundAsLiteral(b)})) {
@@ -1193,7 +1226,7 @@ bool ProductPropagator::Propagate() {
     }
     const IntegerValue new_min_a = CeilRatio(min_p, min_b);
     if (new_min_a > integer_trail_.LowerBound(a)) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, a.GreaterOrEqual(new_min_a),
               {integer_trail_.LowerBoundAsLiteral(p_),
                integer_trail_.LowerBoundAsLiteral(b)})) {
@@ -1220,10 +1253,10 @@ SquarePropagator::SquarePropagator(
     : x_(x),
       s_(s),
       integer_trail_(*model->GetOrCreate<IntegerTrail>()),
-      enforcement_propagator_(*model->GetOrCreate<EnforcementPropagator>()) {
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
-  enforcement_id_ = enforcement_propagator_.Register(
-      enforcement_literals, watcher, RegisterWith(watcher));
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
   CHECK_GE(integer_trail_.LevelZeroLowerBound(x), 0);
 }
 
@@ -1237,19 +1270,18 @@ bool SquarePropagator::Propagate() {
   const IntegerValue max_s = integer_trail_.UpperBound(s_);
   const IntegerValue max_x_square = CapProdI(max_x, max_x);
 
-  const EnforcementStatus status =
-      enforcement_propagator_.Status(enforcement_id_);
-  if (status == EnforcementStatus::CAN_PROPAGATE) {
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status == EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT) {
     // If the bounds of x * x and s are disjoint, the enforcement must be false.
     // TODO(user): relax the reason in a better way.
     if (min_x_square > max_s) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {x_.GreaterOrEqual(min_x), s_.LowerOrEqual(min_x - 1)});
     }
     if (min_s > max_x_square) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {s_.GreaterOrEqual(min_s), x_.LowerOrEqual(min_s - 1)});
@@ -1260,28 +1292,28 @@ bool SquarePropagator::Propagate() {
 
   if (status != EnforcementStatus::IS_ENFORCED) return true;
   if (min_x_square > min_s) {
-    if (!enforcement_propagator_.SafeEnqueue(enforcement_id_,
-                                             s_.GreaterOrEqual(min_x_square),
-                                             {x_.GreaterOrEqual(min_x)})) {
+    if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                         s_.GreaterOrEqual(min_x_square),
+                                         {x_.GreaterOrEqual(min_x)})) {
       return false;
     }
   } else if (min_x_square < min_s) {
     const IntegerValue new_min(CeilSquareRoot(min_s.value()));
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, x_.GreaterOrEqual(new_min),
             {s_.GreaterOrEqual((new_min - 1) * (new_min - 1) + 1)})) {
       return false;
     }
   }
   if (max_x_square < max_s) {
-    if (!enforcement_propagator_.SafeEnqueue(enforcement_id_,
-                                             s_.LowerOrEqual(max_x_square),
-                                             {x_.LowerOrEqual(max_x)})) {
+    if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                         s_.LowerOrEqual(max_x_square),
+                                         {x_.LowerOrEqual(max_x)})) {
       return false;
     }
   } else if (max_x_square > max_s) {
     const IntegerValue new_max(FloorSquareRoot(max_s.value()));
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, x_.LowerOrEqual(new_max),
             {s_.LowerOrEqual(CapProdI(new_max + 1, new_max + 1) - 1)})) {
       return false;
@@ -1305,14 +1337,12 @@ DivisionPropagator::DivisionPropagator(
     : num_(num),
       denom_(denom),
       div_(div),
-      negated_denom_(denom.Negated()),
-      negated_num_(num.Negated()),
       negated_div_(div.Negated()),
       integer_trail_(*model->GetOrCreate<IntegerTrail>()),
-      enforcement_propagator_(*model->GetOrCreate<EnforcementPropagator>()) {
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
-  enforcement_id_ = enforcement_propagator_.Register(
-      enforcement_literals, watcher, RegisterWith(watcher));
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
 }
 
 // TODO(user): We can propagate more, especially in the case where denom
@@ -1325,36 +1355,30 @@ bool DivisionPropagator::Propagate() {
     return true;
   }
 
-  AffineExpression num = num_;
-  AffineExpression negated_num = negated_num_;
-  AffineExpression denom = denom_;
-  AffineExpression negated_denom = negated_denom_;
-
-  if (integer_trail_.UpperBound(denom) < 0) {
-    std::swap(num, negated_num);
-    std::swap(denom, negated_denom);
+  if (integer_trail_.UpperBound(denom_) < 0) {
+    num_ = num_.Negated();
+    denom_ = denom_.Negated();
   }
 
-  const EnforcementStatus status =
-      enforcement_propagator_.Status(enforcement_id_);
-  if (status == EnforcementStatus::CAN_PROPAGATE) {
-    const IntegerValue min_num = integer_trail_.LowerBound(num);
-    const IntegerValue max_num = integer_trail_.UpperBound(num);
-    const IntegerValue min_denom = integer_trail_.LowerBound(denom);
-    const IntegerValue max_denom = integer_trail_.UpperBound(denom);
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status == EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT) {
+    const IntegerValue min_num = integer_trail_.LowerBound(num_);
+    const IntegerValue max_num = integer_trail_.UpperBound(num_);
+    const IntegerValue min_denom = integer_trail_.LowerBound(denom_);
+    const IntegerValue max_denom = integer_trail_.UpperBound(denom_);
     const IntegerValue min_div = integer_trail_.LowerBound(div_);
     const IntegerValue max_div = integer_trail_.UpperBound(div_);
     // If the bounds of num / denom and div are disjoint, the enforcement must
     // be false. TODO(user): relax the reason in a better way.
     if (min_num / max_denom > max_div) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {num_.GreaterOrEqual(min_num), denom_.LowerOrEqual(max_denom),
            div_.LowerOrEqual(max_div)});
     }
     if (max_num / min_denom < min_div) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {num_.LowerOrEqual(max_num), denom_.GreaterOrEqual(min_denom),
@@ -1365,28 +1389,28 @@ bool DivisionPropagator::Propagate() {
   }
 
   if (status != EnforcementStatus::IS_ENFORCED) return true;
-  if (!PropagateSigns(num, denom, div_)) return false;
+  if (!PropagateSigns(num_, denom_, div_)) return false;
 
-  if (integer_trail_.UpperBound(num) >= 0 &&
+  if (integer_trail_.UpperBound(num_) >= 0 &&
       integer_trail_.UpperBound(div_) >= 0 &&
-      !PropagateUpperBounds(num, denom, div_)) {
+      !PropagateUpperBounds(num_, denom_, div_)) {
     return false;
   }
 
-  if (integer_trail_.UpperBound(negated_num) >= 0 &&
+  if (integer_trail_.LowerBound(num_) <= 0 &&
       integer_trail_.UpperBound(negated_div_) >= 0 &&
-      !PropagateUpperBounds(negated_num, denom, negated_div_)) {
+      !PropagateUpperBounds(num_.Negated(), denom_, negated_div_)) {
     return false;
   }
 
-  if (integer_trail_.LowerBound(num) >= 0 &&
+  if (integer_trail_.LowerBound(num_) >= 0 &&
       integer_trail_.LowerBound(div_) >= 0) {
-    return PropagatePositiveDomains(num, denom, div_);
+    return PropagatePositiveDomains(num_, denom_, div_);
   }
 
-  if (integer_trail_.LowerBound(negated_num) >= 0 &&
+  if (integer_trail_.UpperBound(num_) <= 0 &&
       integer_trail_.LowerBound(negated_div_) >= 0) {
-    return PropagatePositiveDomains(negated_num, denom, negated_div_);
+    return PropagatePositiveDomains(num_.Negated(), denom_, negated_div_);
   }
 
   return true;
@@ -1402,7 +1426,7 @@ bool DivisionPropagator::PropagateSigns(AffineExpression num,
 
   // If num >= 0, as denom > 0, then div must be >= 0.
   if (min_num >= 0 && min_div < 0) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, div.GreaterOrEqual(0),
             {num.GreaterOrEqual(0), denom.GreaterOrEqual(1)})) {
       return false;
@@ -1411,7 +1435,7 @@ bool DivisionPropagator::PropagateSigns(AffineExpression num,
 
   // If div > 0, as denom > 0, then num must be > 0.
   if (min_num <= 0 && min_div > 0) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, num.GreaterOrEqual(1),
             {div.GreaterOrEqual(1), denom.GreaterOrEqual(1)})) {
       return false;
@@ -1420,7 +1444,7 @@ bool DivisionPropagator::PropagateSigns(AffineExpression num,
 
   // If num <= 0, as denom > 0, then div must be <= 0.
   if (max_num <= 0 && max_div > 0) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, div.LowerOrEqual(0),
             {num.LowerOrEqual(0), denom.GreaterOrEqual(1)})) {
       return false;
@@ -1429,7 +1453,7 @@ bool DivisionPropagator::PropagateSigns(AffineExpression num,
 
   // If div < 0, as denom > 0, then num must be < 0.
   if (max_num >= 0 && max_div < 0) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, num.LowerOrEqual(-1),
             {div.LowerOrEqual(-1), denom.GreaterOrEqual(1)})) {
       return false;
@@ -1449,7 +1473,7 @@ bool DivisionPropagator::PropagateUpperBounds(AffineExpression num,
 
   const IntegerValue new_max_div = max_num / min_denom;
   if (max_div > new_max_div) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, div.LowerOrEqual(new_max_div),
             {num.LowerOrEqual(max_num), denom.GreaterOrEqual(min_denom)})) {
       return false;
@@ -1462,7 +1486,7 @@ bool DivisionPropagator::PropagateUpperBounds(AffineExpression num,
   const IntegerValue new_max_num =
       CapAddI(CapProdI(max_div + 1, max_denom), -1);
   if (max_num > new_max_num) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, num.LowerOrEqual(new_max_num),
             {denom.LowerOrEqual(max_denom), denom.GreaterOrEqual(1),
              div.LowerOrEqual(max_div)})) {
@@ -1485,7 +1509,7 @@ bool DivisionPropagator::PropagatePositiveDomains(AffineExpression num,
 
   const IntegerValue new_min_div = min_num / max_denom;
   if (min_div < new_min_div) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, div.GreaterOrEqual(new_min_div),
             {num.GreaterOrEqual(min_num), denom.LowerOrEqual(max_denom),
              denom.GreaterOrEqual(1)})) {
@@ -1498,7 +1522,7 @@ bool DivisionPropagator::PropagatePositiveDomains(AffineExpression num,
   // num >= min_div * min_denom.
   const IntegerValue new_min_num = CapProdI(min_denom, min_div);
   if (min_num < new_min_num) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, num.GreaterOrEqual(new_min_num),
             {denom.GreaterOrEqual(min_denom), div.GreaterOrEqual(min_div)})) {
       return false;
@@ -1512,7 +1536,7 @@ bool DivisionPropagator::PropagatePositiveDomains(AffineExpression num,
   if (min_div > 0) {
     const IntegerValue new_max_denom = max_num / min_div;
     if (max_denom > new_max_denom) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, denom.LowerOrEqual(new_max_denom),
               {num.LowerOrEqual(max_num), num.GreaterOrEqual(0),
                div.GreaterOrEqual(min_div), denom.GreaterOrEqual(1)})) {
@@ -1525,7 +1549,7 @@ bool DivisionPropagator::PropagatePositiveDomains(AffineExpression num,
   //               >= CeilRatio(min_num + 1, max_div + 1).
   const IntegerValue new_min_denom = CeilRatio(min_num + 1, max_div + 1);
   if (min_denom < new_min_denom) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, denom.GreaterOrEqual(new_min_denom),
             {num.GreaterOrEqual(min_num), div.LowerOrEqual(max_div),
              div.GreaterOrEqual(0), denom.GreaterOrEqual(1)})) {
@@ -1552,10 +1576,10 @@ FixedDivisionPropagator::FixedDivisionPropagator(
       b_(b),
       c_(c),
       integer_trail_(*model->GetOrCreate<IntegerTrail>()),
-      enforcement_propagator_(*model->GetOrCreate<EnforcementPropagator>()) {
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
-  enforcement_id_ = enforcement_propagator_.Register(
-      enforcement_literals, watcher, RegisterWith(watcher));
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
   CHECK_GT(b_, 0);
 }
 
@@ -1565,19 +1589,18 @@ bool FixedDivisionPropagator::Propagate() {
   IntegerValue min_c = integer_trail_.LowerBound(c_);
   IntegerValue max_c = integer_trail_.UpperBound(c_);
 
-  const EnforcementStatus status =
-      enforcement_propagator_.Status(enforcement_id_);
-  if (status == EnforcementStatus::CAN_PROPAGATE) {
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status == EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT) {
     // If the bounds of a / b and c are disjoint, the enforcement must be false.
     // TODO(user): relax the reason in a better way.
     if (min_a / b_ > max_c) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {a_.GreaterOrEqual(max_c * b_ + 1), c_.LowerOrEqual(max_c)});
     }
     if (max_a / b_ < min_c) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_,
           /*literal_reason=*/{},
           {a_.LowerOrEqual(min_c * b_ - 1), c_.GreaterOrEqual(min_c)});
@@ -1589,7 +1612,7 @@ bool FixedDivisionPropagator::Propagate() {
   if (status != EnforcementStatus::IS_ENFORCED) return true;
   if (max_a / b_ < max_c) {
     max_c = max_a / b_;
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, c_.LowerOrEqual(max_c),
             {integer_trail_.UpperBoundAsLiteral(a_)})) {
       return false;
@@ -1598,7 +1621,7 @@ bool FixedDivisionPropagator::Propagate() {
     const IntegerValue new_max_a =
         max_c >= 0 ? max_c * b_ + b_ - 1 : CapProdI(max_c, b_);
     CHECK_LT(new_max_a, max_a);
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, a_.LowerOrEqual(new_max_a),
             {integer_trail_.UpperBoundAsLiteral(c_)})) {
       return false;
@@ -1607,7 +1630,7 @@ bool FixedDivisionPropagator::Propagate() {
 
   if (min_a / b_ > min_c) {
     min_c = min_a / b_;
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, c_.GreaterOrEqual(min_c),
             {integer_trail_.LowerBoundAsLiteral(a_)})) {
       return false;
@@ -1616,7 +1639,7 @@ bool FixedDivisionPropagator::Propagate() {
     const IntegerValue new_min_a =
         min_c > 0 ? CapProdI(min_c, b_) : min_c * b_ - b_ + 1;
     CHECK_GT(new_min_a, min_a);
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, a_.GreaterOrEqual(new_min_a),
             {integer_trail_.LowerBoundAsLiteral(c_)})) {
       return false;
@@ -1642,25 +1665,24 @@ FixedModuloPropagator::FixedModuloPropagator(
       negated_expr_(expr.Negated()),
       negated_target_(target.Negated()),
       integer_trail_(*model->GetOrCreate<IntegerTrail>()),
-      enforcement_propagator_(*model->GetOrCreate<EnforcementPropagator>()) {
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   CHECK_GT(mod_, 0);
   GenericLiteralWatcher* watcher = model->GetOrCreate<GenericLiteralWatcher>();
-  enforcement_id_ = enforcement_propagator_.Register(
-      enforcement_literals, watcher, RegisterWith(watcher));
+  enforcement_id_ = enforcement_helper_.Register(enforcement_literals, watcher,
+                                                 RegisterWith(watcher));
 }
 
 bool FixedModuloPropagator::Propagate() {
-  const EnforcementStatus status =
-      enforcement_propagator_.Status(enforcement_id_);
-  if (status == EnforcementStatus::CAN_PROPAGATE) {
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status == EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT) {
     const IntegerValue min_target = integer_trail_.LowerBound(target_);
     const IntegerValue max_target = integer_trail_.UpperBound(target_);
     if (min_target >= mod_) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_, /*literal_reason=*/{},
           {target_.GreaterOrEqual(mod_)});
     } else if (max_target <= -mod_) {
-      return enforcement_propagator_.PropagateWhenFalse(
+      return enforcement_helper_.PropagateWhenFalse(
           enforcement_id_, /*literal_reason=*/{},
           {target_.LowerOrEqual(-mod_)});
     }
@@ -1711,7 +1733,7 @@ bool FixedModuloPropagator::PropagateWhenFalseAndTargetIsPositive(
   // - ]max_expr_mod + k * mod_ , min_expr_mod + (k + 1) * mod_[
   if (max_expr < min_expr_mod) {
     // TODO(user): relax the reason in a better way.
-    return enforcement_propagator_.PropagateWhenFalse(
+    return enforcement_helper_.PropagateWhenFalse(
         enforcement_id_, /*literal_reason=*/{},
         {expr.LowerOrEqual(min_expr_mod - 1),
          target.GreaterOrEqual(min_expr_mod)});
@@ -1720,7 +1742,7 @@ bool FixedModuloPropagator::PropagateWhenFalseAndTargetIsPositive(
   const IntegerValue k = MathUtil::FloorOfRatio(max_expr - min_expr_mod, mod_);
   if (min_expr > max_expr_mod + k * mod_) {
     // TODO(user): relax the reason in a better way.
-    return enforcement_propagator_.PropagateWhenFalse(
+    return enforcement_helper_.PropagateWhenFalse(
         enforcement_id_, /*literal_reason=*/{},
         {expr.GreaterOrEqual(max_expr_mod + k * mod_ + 1),
          expr.LowerOrEqual(min_expr_mod + (k + 1) * mod_ - 1),
@@ -1751,7 +1773,7 @@ bool FixedModuloPropagator::PropagateWhenFalseAndTargetDomainContainsZero() {
   if (k >= 0 && min_expr > pos_max_expr_mod + k * mod_) {
     const IntegerValue min_target = integer_trail_.LowerBound(target_);
     // TODO(user): relax the reason in a better way.
-    return enforcement_propagator_.PropagateWhenFalse(
+    return enforcement_helper_.PropagateWhenFalse(
         enforcement_id_, /*literal_reason=*/{},
         {expr_.GreaterOrEqual(pos_max_expr_mod + k * mod_ + 1),
          expr_.LowerOrEqual((k + 1) * mod_ - 1),
@@ -1763,7 +1785,7 @@ bool FixedModuloPropagator::PropagateWhenFalseAndTargetDomainContainsZero() {
   if (k >= 0 && max_expr < neg_max_expr_mod - k * mod_) {
     const IntegerValue max_target = integer_trail_.UpperBound(target_);
     // TODO(user): relax the reason in a better way.
-    return enforcement_propagator_.PropagateWhenFalse(
+    return enforcement_helper_.PropagateWhenFalse(
         enforcement_id_, /*literal_reason=*/{},
         {expr_.GreaterOrEqual(-(k + 1) * mod_ + 1),
          expr_.LowerOrEqual(neg_max_expr_mod - k * mod_ - 1),
@@ -1776,14 +1798,14 @@ bool FixedModuloPropagator::PropagateWhenFalseAndTargetDomainContainsZero() {
 bool FixedModuloPropagator::PropagateSignsAndTargetRange() {
   // Initial domain reduction on the target.
   if (integer_trail_.UpperBound(target_) >= mod_) {
-    if (!enforcement_propagator_.SafeEnqueue(
-            enforcement_id_, target_.LowerOrEqual(mod_ - 1), {})) {
+    if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                         target_.LowerOrEqual(mod_ - 1), {})) {
       return false;
     }
   }
 
   if (integer_trail_.LowerBound(target_) <= -mod_) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_, target_.GreaterOrEqual(1 - mod_), {})) {
       return false;
     }
@@ -1793,9 +1815,9 @@ bool FixedModuloPropagator::PropagateSignsAndTargetRange() {
   if (integer_trail_.LowerBound(expr_) >= 0 &&
       integer_trail_.LowerBound(target_) < 0) {
     // expr >= 0 => target >= 0.
-    if (!enforcement_propagator_.SafeEnqueue(enforcement_id_,
-                                             target_.GreaterOrEqual(0),
-                                             {expr_.GreaterOrEqual(0)})) {
+    if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                         target_.GreaterOrEqual(0),
+                                         {expr_.GreaterOrEqual(0)})) {
       return false;
     }
   }
@@ -1803,9 +1825,9 @@ bool FixedModuloPropagator::PropagateSignsAndTargetRange() {
   if (integer_trail_.UpperBound(expr_) <= 0 &&
       integer_trail_.UpperBound(target_) > 0) {
     // expr <= 0 => target <= 0.
-    if (!enforcement_propagator_.SafeEnqueue(enforcement_id_,
-                                             target_.LowerOrEqual(0),
-                                             {expr_.LowerOrEqual(0)})) {
+    if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                         target_.LowerOrEqual(0),
+                                         {expr_.LowerOrEqual(0)})) {
       return false;
     }
   }
@@ -1813,9 +1835,9 @@ bool FixedModuloPropagator::PropagateSignsAndTargetRange() {
   if (integer_trail_.LowerBound(target_) > 0 &&
       integer_trail_.LowerBound(expr_) <= 0) {
     // target > 0 => expr > 0.
-    if (!enforcement_propagator_.SafeEnqueue(enforcement_id_,
-                                             expr_.GreaterOrEqual(1),
-                                             {target_.GreaterOrEqual(1)})) {
+    if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                         expr_.GreaterOrEqual(1),
+                                         {target_.GreaterOrEqual(1)})) {
       return false;
     }
   }
@@ -1823,9 +1845,9 @@ bool FixedModuloPropagator::PropagateSignsAndTargetRange() {
   if (integer_trail_.UpperBound(target_) < 0 &&
       integer_trail_.UpperBound(expr_) >= 0) {
     // target < 0 => expr < 0.
-    if (!enforcement_propagator_.SafeEnqueue(enforcement_id_,
-                                             expr_.LowerOrEqual(-1),
-                                             {target_.LowerOrEqual(-1)})) {
+    if (!enforcement_helper_.SafeEnqueue(enforcement_id_,
+                                         expr_.LowerOrEqual(-1),
+                                         {target_.LowerOrEqual(-1)})) {
       return false;
     }
   }
@@ -1840,7 +1862,7 @@ bool FixedModuloPropagator::PropagateOuterBounds() {
   const IntegerValue max_target = integer_trail_.UpperBound(target_);
 
   if (max_expr % mod_ > max_target) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_,
             expr_.LowerOrEqual((max_expr / mod_) * mod_ + max_target),
             {integer_trail_.UpperBoundAsLiteral(target_),
@@ -1850,7 +1872,7 @@ bool FixedModuloPropagator::PropagateOuterBounds() {
   }
 
   if (min_expr % mod_ < min_target) {
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_,
             expr_.GreaterOrEqual((min_expr / mod_) * mod_ + min_target),
             {integer_trail_.LowerBoundAsLiteral(expr_),
@@ -1861,7 +1883,7 @@ bool FixedModuloPropagator::PropagateOuterBounds() {
 
   if (min_expr / mod_ == max_expr / mod_) {
     if (min_target < min_expr % mod_) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_,
               target_.GreaterOrEqual(min_expr - (min_expr / mod_) * mod_),
               {integer_trail_.LowerBoundAsLiteral(target_),
@@ -1873,7 +1895,7 @@ bool FixedModuloPropagator::PropagateOuterBounds() {
     }
 
     if (max_target > max_expr % mod_) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_,
               target_.LowerOrEqual(max_expr - (max_expr / mod_) * mod_),
               {integer_trail_.LowerBoundAsLiteral(target_),
@@ -1886,7 +1908,7 @@ bool FixedModuloPropagator::PropagateOuterBounds() {
   } else if (min_expr / mod_ == 0 && min_target < 0) {
     // expr == target when expr <= 0.
     if (min_target < min_expr) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, target_.GreaterOrEqual(min_expr),
               {integer_trail_.LowerBoundAsLiteral(target_),
                integer_trail_.LowerBoundAsLiteral(expr_)})) {
@@ -1896,7 +1918,7 @@ bool FixedModuloPropagator::PropagateOuterBounds() {
   } else if (max_expr / mod_ == 0 && max_target > 0) {
     // expr == target when expr >= 0.
     if (max_target > max_expr) {
-      if (!enforcement_propagator_.SafeEnqueue(
+      if (!enforcement_helper_.SafeEnqueue(
               enforcement_id_, target_.LowerOrEqual(max_expr),
               {integer_trail_.UpperBoundAsLiteral(target_),
                integer_trail_.UpperBoundAsLiteral(expr_)})) {
@@ -1923,7 +1945,7 @@ bool FixedModuloPropagator::PropagateBoundsWhenExprIsNonNegative(
 
   if (max_expr % mod_ < min_target) {
     DCHECK_GE(max_expr, 0);
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_,
             expr.LowerOrEqual((max_expr / mod_ - 1) * mod_ + max_target),
             {integer_trail_.UpperBoundAsLiteral(expr),
@@ -1935,7 +1957,7 @@ bool FixedModuloPropagator::PropagateBoundsWhenExprIsNonNegative(
 
   if (min_expr % mod_ > max_target) {
     DCHECK_GE(min_expr, 0);
-    if (!enforcement_propagator_.SafeEnqueue(
+    if (!enforcement_helper_.SafeEnqueue(
             enforcement_id_,
             expr.GreaterOrEqual((min_expr / mod_ + 1) * mod_ + min_target),
             {integer_trail_.LowerBoundAsLiteral(target),
diff --git a/ortools/sat/integer_expr.h b/ortools/sat/integer_expr.h
index e95fa9d50a..88fbee7443 100644
--- a/ortools/sat/integer_expr.h
+++ b/ortools/sat/integer_expr.h
@@ -26,7 +26,8 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/types/span.h"
-#include "ortools/sat/cp_constraints.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/linear_constraint.h"
@@ -243,15 +244,19 @@ class MinPropagator : public PropagatorInterface {
 // Same as MinPropagator except this works on min = MIN(exprs) where exprs are
 // linear expressions. It uses IntegerSumLE to propagate bounds on the exprs.
 // Assumes Canonical expressions (all positive coefficients).
-class LinMinPropagator : public PropagatorInterface, LazyReasonInterface {
+class GreaterThanMinOfExprsPropagator : public PropagatorInterface,
+                                        LazyReasonInterface {
  public:
-  LinMinPropagator(std::vector<LinearExpression> exprs, IntegerVariable min_var,
-                   Model* model);
-  LinMinPropagator(const LinMinPropagator&) = delete;
-  LinMinPropagator& operator=(const LinMinPropagator&) = delete;
+  GreaterThanMinOfExprsPropagator(
+      absl::Span<const Literal> enforcement_literals,
+      std::vector<LinearExpression> exprs, IntegerVariable min_var,
+      Model* model);
+  GreaterThanMinOfExprsPropagator(const GreaterThanMinOfExprsPropagator&) =
+      delete;
+  GreaterThanMinOfExprsPropagator& operator=(
+      const GreaterThanMinOfExprsPropagator&) = delete;
 
   bool Propagate() final;
-  void RegisterWith(GenericLiteralWatcher* watcher);
 
   // For LazyReasonInterface.
   void Explain(int id, IntegerValue propagation_slack,
@@ -260,6 +265,8 @@ class LinMinPropagator : public PropagatorInterface, LazyReasonInterface {
                std::vector<int>* trail_indices_reason) final;
 
  private:
+  int RegisterWith(GenericLiteralWatcher* watcher);
+
   // Lighter version of IntegerSumLE. This uses the current value of
   // integer_reason_ in addition to the reason for propagating the linear
   // constraint. The coeffs are assumed to be positive here.
@@ -271,7 +278,9 @@ class LinMinPropagator : public PropagatorInterface, LazyReasonInterface {
   const IntegerVariable min_var_;
   std::vector<IntegerValue> expr_lbs_;
   Model* model_;
-  IntegerTrail* integer_trail_;
+  IntegerTrail& integer_trail_;
+  EnforcementHelper& enforcement_helper_;
+  EnforcementId enforcement_id_;
   std::vector<IntegerValue> max_variations_;
   std::vector<IntegerValue> reason_coeffs_;
   std::vector<IntegerLiteral> local_reason_;
@@ -315,7 +324,7 @@ class ProductPropagator : public PropagatorInterface {
   AffineExpression b_;
   AffineExpression p_;
   const IntegerTrail& integer_trail_;
-  EnforcementPropagator& enforcement_propagator_;
+  EnforcementHelper& enforcement_helper_;
   EnforcementId enforcement_id_;
 };
 
@@ -354,14 +363,12 @@ class DivisionPropagator : public PropagatorInterface {
   bool PropagatePositiveDomains(AffineExpression num, AffineExpression denom,
                                 AffineExpression div);
 
-  const AffineExpression num_;
-  const AffineExpression denom_;
+  AffineExpression num_;
+  AffineExpression denom_;
   const AffineExpression div_;
-  const AffineExpression negated_denom_;
-  const AffineExpression negated_num_;
   const AffineExpression negated_div_;
   const IntegerTrail& integer_trail_;
-  EnforcementPropagator& enforcement_propagator_;
+  EnforcementHelper& enforcement_helper_;
   EnforcementId enforcement_id_;
 };
 
@@ -386,7 +393,7 @@ class FixedDivisionPropagator : public PropagatorInterface {
   const IntegerValue b_;
   const AffineExpression c_;
   const IntegerTrail& integer_trail_;
-  EnforcementPropagator& enforcement_propagator_;
+  EnforcementHelper& enforcement_helper_;
   EnforcementId enforcement_id_;
 };
 
@@ -421,7 +428,7 @@ class FixedModuloPropagator : public PropagatorInterface {
   const AffineExpression negated_expr_;
   const AffineExpression negated_target_;
   const IntegerTrail& integer_trail_;
-  EnforcementPropagator& enforcement_propagator_;
+  EnforcementHelper& enforcement_helper_;
   EnforcementId enforcement_id_;
 };
 
@@ -444,7 +451,7 @@ class SquarePropagator : public PropagatorInterface {
   const AffineExpression x_;
   const AffineExpression s_;
   const IntegerTrail& integer_trail_;
-  EnforcementPropagator& enforcement_propagator_;
+  EnforcementHelper& enforcement_helper_;
   EnforcementId enforcement_id_;
 };
 
@@ -732,9 +739,10 @@ inline std::function<IntegerVariable(Model*)> NewWeightedSum(
 // Expresses the fact that an existing integer variable is equal to the minimum
 // of linear expressions. Assumes Canonical expressions (all positive
 // coefficients).
-inline void AddIsEqualToMinOf(const LinearExpression& min_expr,
-                              std::vector<LinearExpression> exprs,
-                              Model* model) {
+inline void AddIsEqualToMinOf(
+    const absl::Span<const Literal> enforcement_literals,
+    const LinearExpression& min_expr, std::vector<LinearExpression> exprs,
+    Model* model) {
   IntegerTrail* integer_trail = model->GetOrCreate<IntegerTrail>();
 
   IntegerVariable min_var;
@@ -758,17 +766,18 @@ inline void AddIsEqualToMinOf(const LinearExpression& min_expr,
     LoadLinearConstraint(builder.Build(), model);
   }
 
-  // Add for all i, min <= exprs[i].
+  // Add for all i, enforcement_literals => min <= exprs[i].
   for (const LinearExpression& expr : exprs) {
     LinearConstraintBuilder builder(0, kMaxIntegerValue);
     builder.AddLinearExpression(expr, 1);
     builder.AddTerm(min_var, -1);
-    LoadLinearConstraint(builder.Build(), model);
+    LoadConditionalLinearConstraint(enforcement_literals, builder.Build(),
+                                    model);
   }
 
-  LinMinPropagator* constraint =
-      new LinMinPropagator(std::move(exprs), min_var, model);
-  constraint->RegisterWith(model->GetOrCreate<GenericLiteralWatcher>());
+  GreaterThanMinOfExprsPropagator* constraint =
+      new GreaterThanMinOfExprsPropagator(enforcement_literals,
+                                          std::move(exprs), min_var, model);
   model->TakeOwnership(constraint);
 }
 
@@ -776,7 +785,9 @@ ABSL_DEPRECATED("Use AddIsEqualToMinOf() instead.")
 inline std::function<void(Model*)> IsEqualToMinOf(
     const LinearExpression& min_expr,
     const std::vector<LinearExpression>& exprs) {
-  return [&](Model* model) { AddIsEqualToMinOf(min_expr, exprs, model); };
+  return [&](Model* model) {
+    AddIsEqualToMinOf(/*enforcement_literals=*/{}, min_expr, exprs, model);
+  };
 }
 
 // Adds the constraint: a * b = p.
diff --git a/ortools/sat/integer_expr_test.cc b/ortools/sat/integer_expr_test.cc
index b35f3fc4d5..a076dc3069 100644
--- a/ortools/sat/integer_expr_test.cc
+++ b/ortools/sat/integer_expr_test.cc
@@ -31,6 +31,7 @@
 #include "gtest/gtest.h"
 #include "ortools/base/logging.h"
 #include "ortools/base/parse_test_proto.h"
+#include "ortools/base/parse_text_proto.h"
 #include "ortools/port/proto_utils.h"
 #include "ortools/sat/cp_model.pb.h"
 #include "ortools/sat/cp_model_checker.h"
@@ -87,6 +88,7 @@ void AddFixedWeightedSumReif(Literal is_eq,
 }
 
 using ::google::protobuf::contrib::parse_proto::ParseTestProto;
+using ::google::protobuf::contrib::parse_proto::ParseTextOrDie;
 
 CpSolverResponse SolveAndCheck(
     const CpModelProto& initial_model, absl::string_view extra_parameters = "",
@@ -94,7 +96,7 @@ CpSolverResponse SolveAndCheck(
   SatParameters params;
   params.set_enumerate_all_solutions(true);
   if (!extra_parameters.empty()) {
-    params.MergeFromString(extra_parameters);
+    params.MergeFrom(ParseTextOrDie<SatParameters>(extra_parameters));
   }
   auto observer = [&](const CpSolverResponse& response) {
     VLOG(2) << response;
@@ -476,7 +478,7 @@ TEST(LinMinTest, OnlyOnePossibleCandidate) {
   LinearExpression min_expr;
   min_expr.vars.push_back(min);
   min_expr.coeffs.push_back(1);
-  AddIsEqualToMinOf(min_expr, exprs, &model);
+  AddIsEqualToMinOf(/*enforcement_literals=*/{}, min_expr, exprs, &model);
 
   // So far everything is normal.
   EXPECT_EQ(SatSolver::FEASIBLE, model.GetOrCreate<SatSolver>()->Solve());
@@ -531,7 +533,7 @@ TEST(LinMinTest, OnlyOnePossibleExpr) {
   LinearExpression min_expr;
   min_expr.vars.push_back(min);
   min_expr.coeffs.push_back(1);
-  AddIsEqualToMinOf(min_expr, exprs, &model);
+  AddIsEqualToMinOf(/*enforcement_literals=*/{}, min_expr, exprs, &model);
 
   // So far everything is normal.
   EXPECT_EQ(SatSolver::FEASIBLE, model.GetOrCreate<SatSolver>()->Solve());
@@ -554,6 +556,134 @@ TEST(LinMinTest, OnlyOnePossibleExpr) {
   EXPECT_EQ(SatSolver::INFEASIBLE, model.GetOrCreate<SatSolver>()->Solve());
 }
 
+TEST(LinMinTest, AlwaysFalseWithUnassignedEnforcementLiteral) {
+  Model model;
+  std::vector<IntegerVariable> vars{model.Add(NewIntegerVariable(1, 2)),
+                                    model.Add(NewIntegerVariable(0, 3)),
+                                    model.Add(NewIntegerVariable(-2, 4))};
+  IntegerTrail* integer_trail = model.GetOrCreate<IntegerTrail>();
+  LinearExpression expr1;  // 2x0 + 3x1 - 5
+  expr1.vars = {vars[0], vars[1]};
+  expr1.coeffs = {2, 3};
+  expr1.offset = -5;
+  expr1 = CanonicalizeExpr(expr1);
+  EXPECT_EQ(-3, expr1.Min(*integer_trail));
+  EXPECT_EQ(8, expr1.Max(*integer_trail));
+
+  LinearExpression expr2;  // 2x1 - 5x2 + 6
+  expr2.vars = {vars[1], vars[2]};
+  expr2.coeffs = {2, -5};
+  expr2.offset = 6;
+  expr2 = CanonicalizeExpr(expr2);
+  EXPECT_EQ(-14, expr2.Min(*integer_trail));
+  EXPECT_EQ(22, expr2.Max(*integer_trail));
+
+  LinearExpression min_expr;  // 2x0 + 3x2
+  min_expr.vars = {vars[0], vars[2]};
+  min_expr.coeffs = {2, 3};
+  min_expr.offset = -50;
+  min_expr = CanonicalizeExpr(min_expr);
+  EXPECT_EQ(-54, min_expr.Min(*integer_trail));
+  EXPECT_EQ(-34, min_expr.Max(*integer_trail));
+
+  const Literal b = Literal(model.Add(NewBooleanVariable()), true);
+  // Always false if enforced (min_expr is always strictly smaller than expr1
+  // and expr2).
+  AddIsEqualToMinOf({b}, min_expr, {expr1, expr2}, &model);
+  EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
+  EXPECT_TRUE(model.GetOrCreate<Trail>()->Assignment().LiteralIsFalse(b));
+  EXPECT_EQ(model.GetOrCreate<IntegerTrail>()->num_enqueues(), 0);
+}
+
+TEST(LinMinTest, NotAlwaysFalseWithUnassignedEnforcementLiteral) {
+  Model model;
+  std::vector<IntegerVariable> vars{model.Add(NewIntegerVariable(1, 2)),
+                                    model.Add(NewIntegerVariable(0, 3)),
+                                    model.Add(NewIntegerVariable(-2, 4))};
+  IntegerTrail* integer_trail = model.GetOrCreate<IntegerTrail>();
+  LinearExpression expr1;  // 2x0 + 3x1 - 5
+  expr1.vars = {vars[0], vars[1]};
+  expr1.coeffs = {2, 3};
+  expr1.offset = -5;
+  expr1 = CanonicalizeExpr(expr1);
+  EXPECT_EQ(-3, expr1.Min(*integer_trail));
+  EXPECT_EQ(8, expr1.Max(*integer_trail));
+
+  LinearExpression expr2;  // 2x1 - 5x2 + 6
+  expr2.vars = {vars[1], vars[2]};
+  expr2.coeffs = {2, -5};
+  expr2.offset = 6;
+  expr2 = CanonicalizeExpr(expr2);
+  EXPECT_EQ(-14, expr2.Min(*integer_trail));
+  EXPECT_EQ(22, expr2.Max(*integer_trail));
+
+  LinearExpression min_expr;  // 2x0 + 3x2
+  min_expr.vars = {vars[0], vars[2]};
+  min_expr.coeffs = {2, 3};
+  min_expr = CanonicalizeExpr(min_expr);
+  EXPECT_EQ(-4, min_expr.Min(*integer_trail));
+  EXPECT_EQ(16, min_expr.Max(*integer_trail));
+
+  const Literal b = Literal(model.Add(NewBooleanVariable()), true);
+  AddIsEqualToMinOf({b}, min_expr, {expr1, expr2}, &model);
+  // Nothing should be propagated.
+  EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
+  EXPECT_FALSE(model.GetOrCreate<Trail>()->Assignment().LiteralIsAssigned(b));
+  EXPECT_EQ(model.GetOrCreate<IntegerTrail>()->num_enqueues(), 0);
+}
+
+TEST(LinMinTest, CheckEnumerateAllSolutionsWithoutEnforcementLiteral) {
+  CpModelProto initial_model = ParseTestProto(R"pb(
+    variables {
+      name: 'b'
+      domain: [ 0, 1 ]
+    }
+    variables {
+      name: 'x'
+      domain: [ 0, 6 ]
+    }
+    variables {
+      name: 'y'
+      domain: [ 1, 7 ]
+    }
+    variables {
+      name: 'z'
+      domain: [ -5, 5 ]
+    }
+    constraints {
+      enforcement_literal: 0
+      lin_max {
+        target {
+          vars: [ 1, 2, 3 ]
+          coeffs: [ 2, -2, 1 ]
+          offset: 5
+        }
+        exprs { vars: 1 coeffs: 1 offset: 1 }
+        exprs { vars: 2 coeffs: 1 offset: 2 }
+      }
+    }
+  )pb");
+  absl::btree_set<std::vector<int>> solutions;
+  const CpSolverResponse response =
+      SolveAndCheck(initial_model, "linearization_level:2", &solutions);
+  EXPECT_EQ(response.status(), CpSolverStatus::OPTIMAL);
+
+  CpModelProto reference_model = initial_model;
+  reference_model.mutable_constraints(0)->clear_enforcement_literal();
+  absl::btree_set<std::vector<int>> reference_solutions;
+  for (int x = 0; x <= 6; ++x) {
+    for (int y = 1; y <= 7; ++y) {
+      for (int z = -5; z <= 5; ++z) {
+        reference_solutions.insert({0, x, y, z});
+      }
+    }
+  }
+  const CpSolverResponse reference_response = SolveAndCheck(
+      reference_model, "linearization_level:2", &reference_solutions);
+  EXPECT_EQ(reference_response.status(), CpSolverStatus::OPTIMAL);
+  EXPECT_EQ(solutions, reference_solutions);
+}
+
 // Propagates a * b = p by hand. Return false if the domains are empty,
 // otherwise returns true and the expected domains value. This is slow and
 // work in O(product of domain(a).size() * domain(b).size())!.
@@ -1098,7 +1228,7 @@ TEST(ProductPropagationTest, AlwaysFalseWithOneUnassignedEnforcementLiteral) {
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 5));
   const IntegerVariable p = model.Add(NewIntegerVariable(50, 100));
   // Always false if enforced (x.y always less than p).
-  model.Add(ProductConstraint({b}, x, x, p));
+  model.Add(ProductConstraint({b}, x, y, p));
   EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
   EXPECT_TRUE(model.GetOrCreate<Trail>()->Assignment().LiteralIsFalse(b));
   EXPECT_EQ(model.GetOrCreate<IntegerTrail>()->num_enqueues(), 0);
@@ -1114,7 +1244,7 @@ TEST(ProductPropagationTest, AlwaysFalseWithOneUnassignedEnforcementLiteral2) {
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 5));
   const IntegerVariable p = model.Add(NewIntegerVariable(-100, -50));
   // Always false if enforced (x.y always greater than p).
-  model.Add(ProductConstraint({b}, x, x, p));
+  model.Add(ProductConstraint({b}, x, y, p));
   EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
   EXPECT_TRUE(model.GetOrCreate<Trail>()->Assignment().LiteralIsFalse(b));
   EXPECT_EQ(model.GetOrCreate<IntegerTrail>()->num_enqueues(), 0);
diff --git a/ortools/sat/integer_search.cc b/ortools/sat/integer_search.cc
index f98b2935b6..eef82f00b7 100644
--- a/ortools/sat/integer_search.cc
+++ b/ortools/sat/integer_search.cc
@@ -814,7 +814,8 @@ std::function<BooleanOrIntegerLiteral()> CumulativePrecedenceSearchHeuristic(
 
         // Remove added task ending there.
         // Set their demand to zero.
-        while (next_end < num_tasks && by_emin[next_end].time == time) {
+        for (; next_end < num_tasks && by_emin[next_end].time == time;
+             ++next_end) {
           const int t = by_emin[next_end].task_index;
           if (!helper->IsPresent(t)) continue;
           if (added_demand[t] > 0) {
@@ -824,13 +825,13 @@ std::function<BooleanOrIntegerLiteral()> CumulativePrecedenceSearchHeuristic(
             // Corner case if task is of duration zero.
             added_demand[t] = -1;
           }
-          ++next_end;
         }
 
         // Add new task starting here.
         // If the task cannot be added we have a candidate for precedence.
         // TODO(user): tie-break tasks not fitting in the profile smartly.
-        while (next_start < num_tasks && by_smin[next_start].time == time) {
+        for (; next_start < num_tasks && by_smin[next_start].time == time;
+             ++next_start) {
           const int t = by_smin[next_start].task_index;
           if (!helper->IsPresent(t)) continue;
           if (added_demand[t] == -1) continue;  // Corner case.
@@ -845,13 +846,11 @@ std::function<BooleanOrIntegerLiteral()> CumulativePrecedenceSearchHeuristic(
             found = true;
             break;
           }
-          ++next_start;
         }
       }
 
       // If packing everything to the left is feasible, continue.
       if (first_skipped_task == -1) {
-        CHECK_EQ(num_added, num_tasks);
         continue;
       }
 
@@ -872,11 +871,17 @@ std::function<BooleanOrIntegerLiteral()> CumulativePrecedenceSearchHeuristic(
       // TODO(user): Add heuristic ordering for creating interesting precedence
       // first.
       bool found_precedence_to_add = false;
-      helper->ClearReason();
+      helper->ResetReason();
       for (const int s : open_tasks) {
         for (const int t : open_tasks) {
           if (s == t) continue;
 
+          // Make sure s could be before t.
+          if (helper->TaskIsBeforeOrIsOverlapping(t, s)) {
+            helper->AddReasonForBeingBeforeAssumingNoOverlap(t, s);
+            continue;
+          }
+
           // Can we add s <= t ?
           // All the considered tasks are intersecting if on the left.
           CHECK_LT(helper->StartMin(s), helper->EndMin(t));
@@ -886,26 +891,21 @@ std::function<BooleanOrIntegerLiteral()> CumulativePrecedenceSearchHeuristic(
           const LiteralIndex existing = repo->GetPrecedenceLiteral(
               helper->Ends()[s], helper->Starts()[t]);
           if (existing != kNoLiteralIndex) {
-            // It shouldn't be able to be true here otherwise we will have s and
-            // t disjoint.
-            CHECK(!trail->Assignment().LiteralIsTrue(Literal(existing)))
-                << helper->TaskDebugString(s) << " ( <= ?) "
-                << helper->TaskDebugString(t);
+            if (trail->Assignment().LiteralIsTrue(Literal(existing))) {
+              // In normal circumstances, this shouldn't be able to be true here
+              // otherwise we will have s and t disjoint. That said, this can
+              // happen if we are not in the propagation fixed point.
+              return BooleanOrIntegerLiteral();
+            }
 
             // This should always be true in normal usage after SAT search has
             // fixed all literal, but if it is not, we can just return this
             // decision.
             if (trail->Assignment().LiteralIsFalse(Literal(existing))) {
-              helper->MutableLiteralReason()->push_back(Literal(existing));
+              helper->AddLiteralReason(Literal(existing));
               continue;
             }
           } else {
-            // Make sure s could be before t.
-            if (helper->EndMin(s) > helper->StartMax(t)) {
-              helper->AddReasonForBeingBeforeAssumingNoOverlap(t, s);
-              continue;
-            }
-
             // It shouldn't be able to fail since s can be before t.
             CHECK(repo->CreatePrecedenceLiteralIfNonTrivial(
                 helper->Ends()[s], helper->Starts()[t]));
@@ -927,22 +927,19 @@ std::function<BooleanOrIntegerLiteral()> CumulativePrecedenceSearchHeuristic(
       // cannot fit in the capacity!
       //
       // TODO(user): We need to add the reason for demand_min and capacity_max.
-      // TODO(user): unfortunately we can't report it from here.
       if (!h.capacity.IsConstant()) {
-        helper->MutableIntegerReason()->push_back(
+        helper->AddIntegerReason(
             integer_trail->UpperBoundAsLiteral(h.capacity));
       }
       const auto& demands = h.demand_helper->Demands();
       for (const int t : open_tasks) {
         if (helper->IsOptional(t)) {
           CHECK(trail->Assignment().LiteralIsTrue(helper->PresenceLiteral(t)));
-          helper->MutableLiteralReason()->push_back(
-              helper->PresenceLiteral(t).Negated());
+          helper->AddLiteralReason(helper->PresenceLiteral(t).Negated());
         }
         const AffineExpression d = demands[t];
         if (!d.IsConstant()) {
-          helper->MutableIntegerReason()->push_back(
-              integer_trail->LowerBoundAsLiteral(d));
+          helper->AddIntegerReason(integer_trail->LowerBoundAsLiteral(d));
         }
       }
       (void)helper->ReportConflict();
diff --git a/ortools/sat/integer_test.cc b/ortools/sat/integer_test.cc
index ef95eb7668..8712a17a28 100644
--- a/ortools/sat/integer_test.cc
+++ b/ortools/sat/integer_test.cc
@@ -402,21 +402,22 @@ TEST(IntegerTrailTest, RelaxLinearReason) {
   IntegerTrail* integer_trail = model.GetOrCreate<IntegerTrail>();
   const IntegerVariable a = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable b = model.Add(NewIntegerVariable(0, 10));
+  const Literal reason = Literal(model.Add(NewBooleanVariable()), true);
 
-  Trail* trail = model.GetOrCreate<Trail>();
-  trail->SetDecisionLevel(1);
-  EXPECT_TRUE(integer_trail->Propagate(trail));
+  auto* sat_solver = model.GetOrCreate<SatSolver>();
+  EXPECT_TRUE(sat_solver->EnqueueDecisionIfNotConflicting(reason.Negated()));
+  EXPECT_TRUE(sat_solver->Propagate());
 
   EXPECT_TRUE(integer_trail->Enqueue(
-      IntegerLiteral::GreaterOrEqual(a, IntegerValue(1)), {}, {}));
+      IntegerLiteral::GreaterOrEqual(a, IntegerValue(1)), {reason}, {}));
   EXPECT_TRUE(integer_trail->Enqueue(
-      IntegerLiteral::GreaterOrEqual(a, IntegerValue(2)), {}, {}));
+      IntegerLiteral::GreaterOrEqual(a, IntegerValue(2)), {reason}, {}));
   EXPECT_TRUE(integer_trail->Enqueue(
-      IntegerLiteral::GreaterOrEqual(b, IntegerValue(1)), {}, {}));
+      IntegerLiteral::GreaterOrEqual(b, IntegerValue(1)), {reason}, {}));
   EXPECT_TRUE(integer_trail->Enqueue(
-      IntegerLiteral::GreaterOrEqual(a, IntegerValue(3)), {}, {}));
+      IntegerLiteral::GreaterOrEqual(a, IntegerValue(3)), {reason}, {}));
   EXPECT_TRUE(integer_trail->Enqueue(
-      IntegerLiteral::GreaterOrEqual(b, IntegerValue(3)), {}, {}));
+      IntegerLiteral::GreaterOrEqual(b, IntegerValue(3)), {reason}, {}));
 
   std::vector<IntegerValue> coeffs(2, IntegerValue(1));
   std::vector<IntegerLiteral> reasons{
diff --git a/ortools/sat/intervals.cc b/ortools/sat/intervals.cc
index 1e9dcb2330..fc53fbeeb9 100644
--- a/ortools/sat/intervals.cc
+++ b/ortools/sat/intervals.cc
@@ -13,6 +13,7 @@
 
 #include "ortools/sat/intervals.h"
 
+#include <algorithm>
 #include <optional>
 #include <utility>
 #include <variant>
@@ -336,9 +337,11 @@ Literal IntervalsRepository::GetOrCreatePrecedenceLiteral(AffineExpression x,
 // we cannot since we often use this with a parallel vector of demands. So this
 // "sorting" should happen in the presolver so we can share as much as possible.
 SchedulingConstraintHelper* IntervalsRepository::GetOrCreateHelper(
+    std::vector<Literal> enforcement_literals,
     const std::vector<IntervalVariable>& variables,
     bool register_as_disjunctive_helper) {
-  const auto it = helper_repository_.find(variables);
+  std::sort(enforcement_literals.begin(), enforcement_literals.end());
+  const auto it = helper_repository_.find({enforcement_literals, variables});
   if (it != helper_repository_.end()) return it->second;
   std::vector<AffineExpression> starts;
   std::vector<AffineExpression> ends;
@@ -365,8 +368,9 @@ SchedulingConstraintHelper* IntervalsRepository::GetOrCreateHelper(
   SchedulingConstraintHelper* helper = new SchedulingConstraintHelper(
       std::move(starts), std::move(ends), std::move(sizes),
       std::move(reason_for_presence), model_);
-  helper->RegisterWith(model_->GetOrCreate<GenericLiteralWatcher>());
-  helper_repository_[variables] = helper;
+  helper->RegisterWith(model_->GetOrCreate<GenericLiteralWatcher>(),
+                       enforcement_literals);
+  helper_repository_[{enforcement_literals, variables}] = helper;
   model_->TakeOwnership(helper);
   if (register_as_disjunctive_helper) {
     disjunctive_helpers_.push_back(helper);
@@ -375,10 +379,12 @@ SchedulingConstraintHelper* IntervalsRepository::GetOrCreateHelper(
 }
 
 NoOverlap2DConstraintHelper* IntervalsRepository::GetOrCreate2DHelper(
+    std::vector<Literal> enforcement_literals,
     const std::vector<IntervalVariable>& x_variables,
     const std::vector<IntervalVariable>& y_variables) {
-  const auto it =
-      no_overlap_2d_helper_repository_.find({x_variables, y_variables});
+  std::sort(enforcement_literals.begin(), enforcement_literals.end());
+  const auto it = no_overlap_2d_helper_repository_.find(
+      {enforcement_literals, x_variables, y_variables});
   if (it != no_overlap_2d_helper_repository_.end()) return it->second;
 
   std::vector<AffineExpression> x_starts;
@@ -415,8 +421,10 @@ NoOverlap2DConstraintHelper* IntervalsRepository::GetOrCreate2DHelper(
       std::move(x_starts), std::move(x_ends), std::move(x_sizes),
       std::move(x_reason_for_presence), std::move(y_starts), std::move(y_ends),
       std::move(y_sizes), std::move(y_reason_for_presence), model_);
-  helper->RegisterWith(model_->GetOrCreate<GenericLiteralWatcher>());
-  no_overlap_2d_helper_repository_[{x_variables, y_variables}] = helper;
+  helper->RegisterWith(model_->GetOrCreate<GenericLiteralWatcher>(),
+                       enforcement_literals);
+  no_overlap_2d_helper_repository_[{enforcement_literals, x_variables,
+                                    y_variables}] = helper;
   model_->TakeOwnership(helper);
   return helper;
 }
diff --git a/ortools/sat/intervals.h b/ortools/sat/intervals.h
index 03c2d8b4ab..500c62a699 100644
--- a/ortools/sat/intervals.h
+++ b/ortools/sat/intervals.h
@@ -16,6 +16,7 @@
 
 #include <cstdint>
 #include <functional>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -119,10 +120,12 @@ class IntervalsRepository {
   // by setting the Boolean to true. This is used by our scheduling heuristic
   // based on precedences.
   SchedulingConstraintHelper* GetOrCreateHelper(
+      std::vector<Literal> enforcement_literals,
       const std::vector<IntervalVariable>& variables,
       bool register_as_disjunctive_helper = false);
 
   NoOverlap2DConstraintHelper* GetOrCreate2DHelper(
+      std::vector<Literal> enforcement_literals,
       const std::vector<IntervalVariable>& x_variables,
       const std::vector<IntervalVariable>& y_variables);
 
@@ -205,12 +208,14 @@ class IntervalsRepository {
   util_intops::StrongVector<IntervalVariable, AffineExpression> sizes_;
 
   // We can share the helper for all the propagators that work on the same set
-  // of intervals.
-  absl::flat_hash_map<std::vector<IntervalVariable>,
-                      SchedulingConstraintHelper*>
+  // of intervals, and with the same enforcement literals.
+  absl::flat_hash_map<
+      std::pair<std::vector<Literal>, std::vector<IntervalVariable>>,
+      SchedulingConstraintHelper*>
       helper_repository_;
   absl::flat_hash_map<
-      std::pair<std::vector<IntervalVariable>, std::vector<IntervalVariable>>,
+      std::tuple<std::vector<Literal>, std::vector<IntervalVariable>,
+                 std::vector<IntervalVariable>>,
       NoOverlap2DConstraintHelper*>
       no_overlap_2d_helper_repository_;
   absl::flat_hash_map<
diff --git a/ortools/sat/java/BUILD.bazel b/ortools/sat/java/BUILD.bazel
index 76bc1a8521..3df97a7c36 100644
--- a/ortools/sat/java/BUILD.bazel
+++ b/ortools/sat/java/BUILD.bazel
@@ -15,11 +15,11 @@
 
 load("@contrib_rules_jvm//java:defs.bzl", "java_junit5_test")
 load("@rules_jvm_external//:defs.bzl", "artifact")
-load("//bazel:swig_java.bzl", "ortools_java_wrap_cc")
+load("//bazel:swig_java.bzl", "java_wrap_cc")
 
-ortools_java_wrap_cc(
+java_wrap_cc(
     name = "sat",
-    src = "sat.swig",
+    srcs = ["sat.swig"],
     java_deps = [
         "//ortools/sat:cp_model_java_proto",
         "//ortools/sat:sat_parameters_java_proto",
@@ -29,9 +29,9 @@ ortools_java_wrap_cc(
     package = "com.google.ortools.sat",
     swig_includes = [
         "//ortools/base:base_swig",
-        "//ortools/util/java:proto_swig",
-        "//ortools/util/java:sorted_interval_list_swig",
-        "//ortools/util/java:vector_swig",
+        "//ortools/util/java:proto.i",
+        "//ortools/util/java:sorted_interval_list.swig",
+        "//ortools/util/java:vector.swig",
     ],
     use_directors = True,
     visibility = ["//visibility:public"],
diff --git a/ortools/sat/linear_constraint_manager.cc b/ortools/sat/linear_constraint_manager.cc
index 3efbcd8bcc..77b5419a97 100644
--- a/ortools/sat/linear_constraint_manager.cc
+++ b/ortools/sat/linear_constraint_manager.cc
@@ -980,7 +980,7 @@ void LinearConstraintManager::CacheReducedCostsInfo() {
   if (reduced_costs_is_cached_) return;
   reduced_costs_is_cached_ = true;
 
-  absl::int128 ub = reduced_cost_constraint_.ub.value();
+  const absl::int128 ub = reduced_cost_constraint_.ub.value();
   absl::int128 level_zero_lb = 0;
   for (int i = 0; i < reduced_cost_constraint_.num_terms; ++i) {
     IntegerVariable var = reduced_cost_constraint_.vars[i];
@@ -1000,8 +1000,7 @@ void LinearConstraintManager::CacheReducedCostsInfo() {
       reduced_costs_map_[Literal(lit)] = coeff;
     }
   }
-  const absl::int128 gap =
-      absl::int128(reduced_cost_constraint_.ub.value()) - level_zero_lb;
+  const absl::int128 gap = ub - level_zero_lb;
   if (gap > 0) {
     reduced_costs_gap_ = gap;
   } else {
diff --git a/ortools/sat/linear_propagation.cc b/ortools/sat/linear_propagation.cc
index 2446dd2ecd..b2e30467f1 100644
--- a/ortools/sat/linear_propagation.cc
+++ b/ortools/sat/linear_propagation.cc
@@ -24,6 +24,7 @@
 
 #include "absl/base/log_severity.h"
 #include "absl/cleanup/cleanup.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
@@ -32,7 +33,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/types/span.h"
 #include "ortools/base/strong_vector.h"
-#include "ortools/sat/cp_constraints.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
@@ -51,6 +52,7 @@ LinearPropagator::LinearPropagator(Model* model)
     : trail_(model->GetOrCreate<Trail>()),
       integer_trail_(model->GetOrCreate<IntegerTrail>()),
       enforcement_propagator_(model->GetOrCreate<EnforcementPropagator>()),
+      enforcement_helper_(model->GetOrCreate<EnforcementHelper>()),
       watcher_(model->GetOrCreate<GenericLiteralWatcher>()),
       time_limit_(model->GetOrCreate<TimeLimit>()),
       rev_int_repository_(model->GetOrCreate<RevIntRepository>()),
@@ -388,7 +390,7 @@ bool LinearPropagator::AddConstraint(
           // TODO(user): With some care, when we cannot propagate or the
           // constraint is not enforced, we could leave in_queue_[] at true but
           // not put the constraint in the queue.
-          if (status == EnforcementStatus::CAN_PROPAGATE ||
+          if (status == EnforcementStatus::CAN_PROPAGATE_ENFORCEMENT ||
               status == EnforcementStatus::IS_ENFORCED) {
             AddToQueueIfNeeded(id);
             watcher_->CallOnNextPropagate(watcher_id_);
@@ -403,6 +405,15 @@ bool LinearPropagator::AddConstraint(
             if (info.initial_size == 2) {
               const auto vars = GetVariables(info);
               const auto coeffs = GetCoeffs(info);
+
+              // WARNING, subtle: this callback is called from the enforcement
+              // propagator, which can run before running the propagation of the
+              // IntegerTrail. Since it is in IntegerTrail::Propagate() that we
+              // call SetLevel() on the reversible classes,
+              // EnforcedLinear2Bounds might be at the wrong level.
+              // TODO(user): find a cleaner solution
+              precedences_->SetLevelToTrail();
+
               precedences_->PushConditionalRelation(
                   enforcement_propagator_->GetEnforcementLiterals(enf_id),
                   LinearExpression2(vars[0], vars[1], coeffs[0], coeffs[1]),
@@ -633,8 +644,8 @@ bool LinearPropagator::PropagateInfeasibleConstraint(int id,
   integer_trail_->RelaxLinearReason(-slack - 1, reason_coeffs_,
                                     &integer_reason_);
   ++num_enforcement_pushes_;
-  return enforcement_propagator_->PropagateWhenFalse(info.enf_id, {},
-                                                     integer_reason_);
+  return enforcement_helper_->PropagateWhenFalse(info.enf_id, {},
+                                                 integer_reason_);
 }
 
 void LinearPropagator::Explain(int id, IntegerValue propagation_slack,
diff --git a/ortools/sat/linear_propagation.h b/ortools/sat/linear_propagation.h
index 149aaf8313..b1fb3b8eee 100644
--- a/ortools/sat/linear_propagation.h
+++ b/ortools/sat/linear_propagation.h
@@ -28,7 +28,8 @@
 #include "absl/log/check.h"
 #include "absl/types/span.h"
 #include "ortools/base/strong_vector.h"
-#include "ortools/sat/cp_constraints.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
@@ -317,6 +318,7 @@ class LinearPropagator : public PropagatorInterface,
   Trail* trail_;
   IntegerTrail* integer_trail_;
   EnforcementPropagator* enforcement_propagator_;
+  EnforcementHelper* enforcement_helper_;
   GenericLiteralWatcher* watcher_;
   TimeLimit* time_limit_;
   RevIntRepository* rev_int_repository_;
diff --git a/ortools/sat/linear_relaxation.cc b/ortools/sat/linear_relaxation.cc
index 29e57fbf8e..f697e2f8b9 100644
--- a/ortools/sat/linear_relaxation.cc
+++ b/ortools/sat/linear_relaxation.cc
@@ -26,7 +26,6 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
 #include "absl/types/span.h"
 #include "google/protobuf/message.h"
 #include "ortools/base/logging.h"
@@ -732,6 +731,7 @@ std::optional<AffineExpression> DetectMakespanFromPrecedences(
 void AppendNoOverlapRelaxationAndCutGenerator(const ConstraintProto& ct,
                                               Model* model,
                                               LinearRelaxation* relaxation) {
+  // TODO(user): add support for enforcement literals?
   if (HasEnforcementLiteral(ct)) return;
 
   auto* mapping = model->GetOrCreate<CpModelMapping>();
@@ -750,7 +750,8 @@ void AppendNoOverlapRelaxationAndCutGenerator(const ConstraintProto& ct,
     intervals.erase(intervals.begin() + makespan_index.value());
   }
 
-  SchedulingConstraintHelper* helper = repository->GetOrCreateHelper(intervals);
+  SchedulingConstraintHelper* helper =
+      repository->GetOrCreateHelper(/*enforcement_literals=*/{}, intervals);
   if (!helper->SynchronizeAndSetTimeDirection(true)) return;
   SchedulingDemandHelper* demands_helper =
       repository->GetOrCreateDemandHelper(helper, demands);
@@ -769,6 +770,7 @@ void AppendNoOverlapRelaxationAndCutGenerator(const ConstraintProto& ct,
 void AppendCumulativeRelaxationAndCutGenerator(const ConstraintProto& ct,
                                                Model* model,
                                                LinearRelaxation* relaxation) {
+  // TODO(user): add support for enforcement literals?
   if (HasEnforcementLiteral(ct)) return;
   auto* mapping = model->GetOrCreate<CpModelMapping>();
   std::vector<IntervalVariable> intervals =
@@ -788,7 +790,8 @@ void AppendCumulativeRelaxationAndCutGenerator(const ConstraintProto& ct,
   }
 
   // We try to linearize the energy of each task (size * demand).
-  SchedulingConstraintHelper* helper = repository->GetOrCreateHelper(intervals);
+  SchedulingConstraintHelper* helper =
+      repository->GetOrCreateHelper(/*enforcement_literals=*/{}, intervals);
   if (!helper->SynchronizeAndSetTimeDirection(true)) return;
   SchedulingDemandHelper* demands_helper =
       repository->GetOrCreateDemandHelper(helper, demands);
@@ -1070,6 +1073,7 @@ void AppendNoOverlap2dRelaxationForComponent(
 void AppendNoOverlap2dRelaxation(const ConstraintProto& ct, Model* model,
                                  LinearRelaxation* relaxation) {
   CHECK(ct.has_no_overlap_2d());
+  // TODO(user): add support for enforcement literals?
   if (HasEnforcementLiteral(ct)) return;
 
   auto* mapping = model->GetOrCreate<CpModelMapping>();
@@ -1080,7 +1084,8 @@ void AppendNoOverlap2dRelaxation(const ConstraintProto& ct, Model* model,
 
   auto* intervals_repository = model->GetOrCreate<IntervalsRepository>();
   NoOverlap2DConstraintHelper* no_overlap_helper =
-      intervals_repository->GetOrCreate2DHelper(x_intervals, y_intervals);
+      intervals_repository->GetOrCreate2DHelper(/*enforcement_literals=*/{},
+                                                x_intervals, y_intervals);
   auto* product_decomposer = model->GetOrCreate<ProductDecomposer>();
 
   CutGenerator& result = relaxation->cut_generators.emplace_back();
@@ -1111,7 +1116,8 @@ void AppendNoOverlap2dRelaxation(const ConstraintProto& ct, Model* model,
 }
 
 void AppendLinMaxRelaxationPart1(const ConstraintProto& ct, Model* model,
-                                 LinearRelaxation* relaxation) {
+                                 LinearRelaxation* relaxation,
+                                 ActivityBoundHelper* activity_helper) {
   auto* mapping = model->GetOrCreate<CpModelMapping>();
 
   // We want to linearize target = max(exprs[1], exprs[2], ..., exprs[d]).
@@ -1124,7 +1130,8 @@ void AppendLinMaxRelaxationPart1(const ConstraintProto& ct, Model* model,
     LinearConstraintBuilder lc(model, kMinIntegerValue, IntegerValue(0));
     lc.AddLinearExpression(negated_target);
     lc.AddLinearExpression(expr);
-    relaxation->linear_constraints.push_back(lc.Build());
+    AppendLinearConstraintRelaxation(ct.enforcement_literal(), lc.Build(),
+                                     model, relaxation, activity_helper);
   }
 }
 
@@ -1133,7 +1140,8 @@ void AppendLinMaxRelaxationPart1(const ConstraintProto& ct, Model* model,
 //   2) keep this code
 //   3) remove this code and create the cut generator at level 1.
 void AppendMaxAffineRelaxation(const ConstraintProto& ct, Model* model,
-                               LinearRelaxation* relaxation) {
+                               LinearRelaxation* relaxation,
+                               ActivityBoundHelper* activity_helper) {
   IntegerVariable var;
   std::vector<std::pair<IntegerValue, IntegerValue>> affines;
   auto* mapping = model->GetOrCreate<CpModelMapping>();
@@ -1148,7 +1156,8 @@ void AppendMaxAffineRelaxation(const ConstraintProto& ct, Model* model,
       PositiveVarExpr(mapping->GetExprFromProto(ct.lin_max().target()));
   LinearConstraintBuilder builder(model);
   if (BuildMaxAffineUpConstraint(target_expr, var, affines, model, &builder)) {
-    relaxation->linear_constraints.push_back(builder.Build());
+    AppendLinearConstraintRelaxation(ct.enforcement_literal(), builder.Build(),
+                                     model, relaxation, activity_helper);
   }
 }
 
@@ -1250,13 +1259,15 @@ void AppendLinMaxRelaxationPart2(IntegerVariable target,
   }
 }
 
-void AppendLinearConstraintRelaxation(const ConstraintProto& ct,
-                                      bool linearize_enforced_constraints,
-                                      Model* model,
+namespace {
+bool LinearizeEnforcedConstraints(Model* model) {
+  return model->GetOrCreate<SatParameters>()->linearization_level() > 1;
+}
+}  // namespace
+
+void AppendLinearConstraintRelaxation(const ConstraintProto& ct, Model* model,
                                       LinearRelaxation* relaxation,
                                       ActivityBoundHelper* activity_helper) {
-  auto* mapping = model->Get<CpModelMapping>();
-
   // Note that we ignore the holes in the domain.
   //
   // TODO(user): In LoadLinearConstraint() we already created intermediate
@@ -1271,19 +1282,23 @@ void AppendLinearConstraintRelaxation(const ConstraintProto& ct,
       rhs_domain_max == std::numeric_limits<int64_t>::max())
     return;
 
+  LinearConstraintBuilder lc(model, rhs_domain_min, rhs_domain_max);
+  auto* mapping = model->Get<CpModelMapping>();
+  for (int i = 0; i < ct.linear().vars_size(); i++) {
+    const int ref = ct.linear().vars(i);
+    const IntegerVariable int_var = mapping->Integer(ref);
+    // Everything here should have a view.
+    CHECK_NE(int_var, kNoIntegerVariable);
+    const int64_t coeff = ct.linear().coeffs(i);
+    lc.AddTerm(int_var, IntegerValue(coeff));
+  }
   if (!HasEnforcementLiteral(ct)) {
-    LinearConstraintBuilder lc(model, rhs_domain_min, rhs_domain_max);
-    for (int i = 0; i < ct.linear().vars_size(); i++) {
-      const int ref = ct.linear().vars(i);
-      const int64_t coeff = ct.linear().coeffs(i);
-      lc.AddTerm(mapping->Integer(ref), IntegerValue(coeff));
-    }
     relaxation->linear_constraints.push_back(lc.Build());
     return;
   }
 
   // Reified version.
-  if (!linearize_enforced_constraints) return;
+  if (!LinearizeEnforcedConstraints(model)) return;
 
   // We linearize fully reified constraints of size 1 all together for a given
   // variable. But we need to process half-reified ones or constraint with
@@ -1296,9 +1311,25 @@ void AppendLinearConstraintRelaxation(const ConstraintProto& ct,
     return;
   }
 
+  AppendLinearConstraintRelaxation(ct.enforcement_literal(), lc.Build(), model,
+                                   relaxation, activity_helper);
+}
+
+void AppendLinearConstraintRelaxation(absl::Span<const int> enforcement,
+                                      LinearConstraint&& linear_constraint,
+                                      Model* model,
+                                      LinearRelaxation* relaxation,
+                                      ActivityBoundHelper* activity_helper) {
+  if (enforcement.empty()) {
+    relaxation->linear_constraints.push_back(std::move(linear_constraint));
+    return;
+  }
+  if (!LinearizeEnforcedConstraints(model)) return;
+
+  auto* mapping = model->Get<CpModelMapping>();
   std::vector<Literal> enforcing_literals;
-  enforcing_literals.reserve(ct.enforcement_literal_size());
-  for (const int enforcement_ref : ct.enforcement_literal()) {
+  enforcing_literals.reserve(enforcement.size());
+  for (const int enforcement_ref : enforcement) {
     enforcing_literals.push_back(mapping->Literal(enforcement_ref));
   }
 
@@ -1307,17 +1338,14 @@ void AppendLinearConstraintRelaxation(const ConstraintProto& ct,
   IntegerValue min_activity(0);
   IntegerValue max_activity(0);
   const auto integer_trail = model->GetOrCreate<IntegerTrail>();
-  for (int i = 0; i < ct.linear().vars_size(); i++) {
-    const int ref = ct.linear().vars(i);
-    const IntegerValue coeff(ct.linear().coeffs(i));
-    const IntegerVariable int_var = mapping->Integer(ref);
-
-    // Everything here should have a view.
-    CHECK_NE(int_var, kNoIntegerVariable);
+  for (int i = 0; i < linear_constraint.num_terms; i++) {
+    const IntegerValue coeff = linear_constraint.coeffs[i];
+    const IntegerVariable int_var = linear_constraint.vars[i];
+    const int ref = mapping->GetProtoVariableFromIntegerVariable(int_var);
 
     const IntegerValue lb = integer_trail->LowerBound(int_var);
     const IntegerValue ub = integer_trail->UpperBound(int_var);
-    if (lb == 0 && ub == 1 && activity_helper != nullptr) {
+    if (lb == 0 && ub == 1 && activity_helper != nullptr && ref != -1) {
       bool_terms.push_back({ref, coeff.value()});
     } else {
       if (coeff > 0) {
@@ -1336,42 +1364,36 @@ void AppendLinearConstraintRelaxation(const ConstraintProto& ct,
         IntegerValue(activity_helper->ComputeMaxActivity(bool_terms));
   }
 
-  if (rhs_domain_min > min_activity) {
-    // And(ei) => terms >= rhs_domain_min
-    // <=> Sum_i (~ei * (rhs_domain_min - min_activity)) + terms >=
+  if (linear_constraint.lb > min_activity) {
+    // And(ei) => terms >= linear_constraint.lb
+    // <=> Sum_i (~ei * (linear_constraint.lb - min_activity)) + terms >=
     // rhs_domain_min
-    LinearConstraintBuilder lc(model, rhs_domain_min, kMaxIntegerValue);
-    const IntegerValue term = CapSubI(rhs_domain_min, min_activity);
+    LinearConstraintBuilder lc(model, linear_constraint.lb, kMaxIntegerValue);
+    const IntegerValue term = CapSubI(linear_constraint.lb, min_activity);
     if (AtMinOrMaxInt64I(term) && !enforcing_literals.empty()) return;
     for (const Literal& literal : enforcing_literals) {
       CHECK(lc.AddLiteralTerm(literal.Negated(), term));
     }
-    for (int i = 0; i < ct.linear().vars_size(); i++) {
-      const int ref = ct.linear().vars(i);
-      const IntegerValue coeff(ct.linear().coeffs(i));
-      const IntegerVariable int_var = mapping->Integer(ref);
-      lc.AddTerm(int_var, coeff);
+    for (int i = 0; i < linear_constraint.num_terms; i++) {
+      lc.AddTerm(linear_constraint.vars[i], linear_constraint.coeffs[i]);
     }
     LinearConstraint built_ct = lc.Build();
     if (!PossibleOverflow(*integer_trail, built_ct)) {
       relaxation->linear_constraints.push_back(std::move(built_ct));
     }
   }
-  if (rhs_domain_max < max_activity) {
-    // And(ei) => terms <= rhs_domain_max
-    // <=> Sum_i (~ei * (rhs_domain_max - max_activity)) + terms <=
-    // rhs_domain_max
-    LinearConstraintBuilder lc(model, kMinIntegerValue, rhs_domain_max);
-    const IntegerValue term = CapSubI(rhs_domain_max, max_activity);
+  if (linear_constraint.ub < max_activity) {
+    // And(ei) => terms <= linear_constraint.ub
+    // <=> Sum_i (~ei * (linear_constraint.ub - max_activity)) + terms <=
+    // linear_constraint.ub
+    LinearConstraintBuilder lc(model, kMinIntegerValue, linear_constraint.ub);
+    const IntegerValue term = CapSubI(linear_constraint.ub, max_activity);
     if (AtMinOrMaxInt64I(term) && !enforcing_literals.empty()) return;
     for (const Literal& literal : enforcing_literals) {
       CHECK(lc.AddLiteralTerm(literal.Negated(), term));
     }
-    for (int i = 0; i < ct.linear().vars_size(); i++) {
-      const int ref = ct.linear().vars(i);
-      const IntegerValue coeff(ct.linear().coeffs(i));
-      const IntegerVariable int_var = mapping->Integer(ref);
-      lc.AddTerm(int_var, coeff);
+    for (int i = 0; i < linear_constraint.num_terms; i++) {
+      lc.AddTerm(linear_constraint.vars[i], linear_constraint.coeffs[i]);
     }
     LinearConstraint built_ct = lc.Build();
     if (!PossibleOverflow(*integer_trail, built_ct)) {
@@ -1422,7 +1444,7 @@ void TryToLinearizeConstraint(const CpModelProto& /*model_proto*/,
       break;
     }
     case ConstraintProto::ConstraintCase::kIntProd: {
-      // TODO(user): add support for enforcement literals?
+      // TODO(user): add support for enforcement literals.
       if (!HasEnforcementLiteral(ct)) {
         const LinearArgumentProto& int_prod = ct.int_prod();
         if (int_prod.exprs_size() == 2 &&
@@ -1438,15 +1460,16 @@ void TryToLinearizeConstraint(const CpModelProto& /*model_proto*/,
       break;
     }
     case ConstraintProto::ConstraintCase::kLinMax: {
-      AppendLinMaxRelaxationPart1(ct, model, relaxation);
+      AppendLinMaxRelaxationPart1(ct, model, relaxation, activity_helper);
       const bool is_affine_max =
           ExpressionsContainsOnlyOneVar(ct.lin_max().exprs());
       if (is_affine_max) {
-        AppendMaxAffineRelaxation(ct, model, relaxation);
+        AppendMaxAffineRelaxation(ct, model, relaxation, activity_helper);
       }
 
       // Add cut generators.
-      if (linearization_level > 1) {
+      // TODO(user): add support for enforcement literals.
+      if (linearization_level > 1 && !HasEnforcementLiteral(ct)) {
         if (is_affine_max) {
           AddMaxAffineCutGenerator(ct, model, relaxation);
         } else if (ct.lin_max().exprs().size() < 100) {
@@ -1456,27 +1479,34 @@ void TryToLinearizeConstraint(const CpModelProto& /*model_proto*/,
       break;
     }
     case ConstraintProto::ConstraintCase::kAllDiff: {
-      AddAllDiffRelaxationAndCutGenerator(ct, linearization_level, model,
-                                          relaxation);
+      // TODO(user): add support for enforcement literals.
+      if (!HasEnforcementLiteral(ct)) {
+        AddAllDiffRelaxationAndCutGenerator(ct, linearization_level, model,
+                                            relaxation);
+      }
       break;
     }
     case ConstraintProto::ConstraintCase::kLinear: {
-      AppendLinearConstraintRelaxation(
-          ct, /*linearize_enforced_constraints=*/linearization_level > 1, model,
-          relaxation, activity_helper);
+      AppendLinearConstraintRelaxation(ct, model, relaxation, activity_helper);
       break;
     }
     case ConstraintProto::ConstraintCase::kCircuit: {
-      AppendCircuitRelaxation(ct, model, relaxation);
-      if (linearization_level > 1) {
-        AddCircuitCutGenerator(ct, model, relaxation);
+      // TODO(user): add support for enforcement literals?
+      if (!HasEnforcementLiteral(ct)) {
+        AppendCircuitRelaxation(ct, model, relaxation);
+        if (linearization_level > 1) {
+          AddCircuitCutGenerator(ct, model, relaxation);
+        }
       }
       break;
     }
     case ConstraintProto::ConstraintCase::kRoutes: {
-      AppendRoutesRelaxation(ct, model, relaxation);
-      if (linearization_level > 1) {
-        AddRoutesCutGenerator(ct, model, relaxation);
+      // TODO(user): add support for enforcement literals?
+      if (!HasEnforcementLiteral(ct)) {
+        AppendRoutesRelaxation(ct, model, relaxation);
+        if (linearization_level > 1) {
+          AddRoutesCutGenerator(ct, model, relaxation);
+        }
       }
       break;
     }
@@ -1747,6 +1777,7 @@ void AddNoOverlapCutGenerator(SchedulingConstraintHelper* helper,
 
 void AddNoOverlap2dCutGenerator(const ConstraintProto& ct, Model* m,
                                 LinearRelaxation* relaxation) {
+  // TODO(user): add support for enforcement literals?
   if (HasEnforcementLiteral(ct)) return;
 
   auto* mapping = m->GetOrCreate<CpModelMapping>();
@@ -1758,7 +1789,8 @@ void AddNoOverlap2dCutGenerator(const ConstraintProto& ct, Model* m,
   IntervalsRepository* intervals_repository =
       m->GetOrCreate<IntervalsRepository>();
   NoOverlap2DConstraintHelper* no_overlap_helper =
-      intervals_repository->GetOrCreate2DHelper(x_intervals, y_intervals);
+      intervals_repository->GetOrCreate2DHelper(/*enforcement_literals=*/{},
+                                                x_intervals, y_intervals);
 
   relaxation->cut_generators.push_back(
       CreateNoOverlap2dCompletionTimeCutGenerator(no_overlap_helper, m));
diff --git a/ortools/sat/linear_relaxation.h b/ortools/sat/linear_relaxation.h
index c4f8e3cd7e..67bba950fa 100644
--- a/ortools/sat/linear_relaxation.h
+++ b/ortools/sat/linear_relaxation.h
@@ -112,8 +112,9 @@ void AppendExactlyOneRelaxation(const ConstraintProto& ct, Model* model,
 // Reference: "Strong mixed-integer programming formulations for trained neural
 // networks" by Ross Anderson et. (https://arxiv.org/pdf/1811.01988.pdf).
 // TODO(user): Support linear expression as target.
-void AppendLinMaxRelaxationPart1(const ConstraintProto& ct, Model* model,
-                                 LinearRelaxation* relaxation);
+void AppendLinMaxRelaxationPart1(
+    const ConstraintProto& ct, Model* model, LinearRelaxation* relaxation,
+    ActivityBoundHelper* activity_helper = nullptr);
 
 void AppendLinMaxRelaxationPart2(IntegerVariable target,
                                  absl::Span<const Literal> alternative_literals,
@@ -122,7 +123,8 @@ void AppendLinMaxRelaxationPart2(IntegerVariable target,
 
 // Note: This only works if all affine expressions share the same variable.
 void AppendMaxAffineRelaxation(const ConstraintProto& ct, Model* model,
-                               LinearRelaxation* relaxation);
+                               LinearRelaxation* relaxation,
+                               ActivityBoundHelper* activity_helper = nullptr);
 
 // Appends linear constraints to the relaxation. This also handles the
 // relaxation of linear constraints with enforcement literals.
@@ -133,7 +135,10 @@ void AppendMaxAffineRelaxation(const ConstraintProto& ct, Model* model,
 // Where implied_lb and implied_ub are trivial lower and upper bounds of the
 // constraint.
 void AppendLinearConstraintRelaxation(
-    const ConstraintProto& ct, bool linearize_enforced_constraints,
+    const ConstraintProto& ct, Model* model, LinearRelaxation* relaxation,
+    ActivityBoundHelper* activity_helper = nullptr);
+void AppendLinearConstraintRelaxation(
+    absl::Span<const int> enforcement, LinearConstraint&& linear_constraint,
     Model* model, LinearRelaxation* relaxation,
     ActivityBoundHelper* activity_helper = nullptr);
 
diff --git a/ortools/sat/linear_relaxation_test.cc b/ortools/sat/linear_relaxation_test.cc
index 2f6e33eb06..b8f73b7739 100644
--- a/ortools/sat/linear_relaxation_test.cc
+++ b/ortools/sat/linear_relaxation_test.cc
@@ -30,6 +30,7 @@
 #include "ortools/sat/linear_constraint.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/sat_base.h"
+#include "ortools/sat/scheduling_helpers.h"
 #include "ortools/util/sorted_interval_list.h"
 
 namespace operations_research {
@@ -386,6 +387,41 @@ TEST(TryToLinearizeConstraint, LinMaxLevel1Bis) {
   EXPECT_EQ(relaxation.linear_constraints[2].DebugString(), "-1*X2 -1*X3 <= 0");
 }
 
+TEST(TryToLinearizeConstraint, EnforcedLinMaxLevel2) {
+  const CpModelProto initial_model = ParseTestProto(R"pb(
+    variables { domain: [ 0, 5 ] }
+    variables { domain: [ -1, 7 ] }
+    variables { domain: [ -2, 9 ] }
+    variables { domain: [ -5, 10 ] }
+    variables { domain: [ 0, 1 ] }
+    constraints {
+      enforcement_literal: 4
+      lin_max {
+        target: { vars: 3 coeffs: 1 }
+        exprs: { vars: 0 coeffs: 1 }
+        exprs: { vars: 1 coeffs: 1 }
+        exprs: { vars: 2 coeffs: -1 }
+      }
+    }
+  )pb");
+
+  Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
+  LoadVariables(initial_model, true, &model);
+
+  LinearRelaxation relaxation;
+  TryToLinearizeConstraint(initial_model, initial_model.constraints(0),
+                           /*linearization_level=*/2, &model, &relaxation);
+
+  EXPECT_EQ(relaxation.linear_constraints.size(), 3);
+  EXPECT_EQ(relaxation.linear_constraints[0].DebugString(),
+            "1*X0 -1*X3 10*X4 <= 10");
+  EXPECT_EQ(relaxation.linear_constraints[1].DebugString(),
+            "1*X1 -1*X3 12*X4 <= 12");
+  EXPECT_EQ(relaxation.linear_constraints[2].DebugString(),
+            "-1*X2 -1*X3 7*X4 <= 7");
+}
+
 TEST(TryToLinearizeConstraint, LinMaxSmall) {
   const CpModelProto initial_model = ParseTestProto(R"pb(
     variables { domain: [ 0, 5 ] }
@@ -627,7 +663,8 @@ void AppendNoOverlapRelaxation(const ConstraintProto& ct, Model* model,
   const IntegerValue one(1);
   std::vector<AffineExpression> demands(intervals.size(), one);
   IntervalsRepository* repository = model->GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repository->GetOrCreateHelper(intervals);
+  SchedulingConstraintHelper* helper =
+      repository->GetOrCreateHelper(/*enforcement_literals=*/{}, intervals);
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper(demands, helper, model);
   model->TakeOwnership(demands_helper);
@@ -814,7 +851,8 @@ void AppendCumulativeRelaxation(const ConstraintProto& ct, Model* model,
       mapping->Affines(ct.cumulative().demands());
   const AffineExpression capacity = mapping->Affine(ct.cumulative().capacity());
   IntervalsRepository* repository = model->GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repository->GetOrCreateHelper(intervals);
+  SchedulingConstraintHelper* helper =
+      repository->GetOrCreateHelper(/*enforcement_literals=*/{}, intervals);
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper(demands, helper, model);
   model->TakeOwnership(demands_helper);
@@ -960,12 +998,12 @@ TEST(AppendLinearConstraintRelaxation, NoEnforcementLiteral) {
   )pb");
 
   Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/true,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
 
   EXPECT_EQ(relaxation.linear_constraints.size(), 1);
   EXPECT_EQ(relaxation.linear_constraints[0].DebugString(),
@@ -991,9 +1029,8 @@ TEST(AppendLinearConstraintRelaxation, SmallLinearizationLevel) {
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/false,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
   EXPECT_EQ(relaxation.linear_constraints.size(), 0);
 }
 
@@ -1015,9 +1052,8 @@ TEST(AppendLinearConstraintRelaxation, PbConstraint) {
   LoadVariables(initial_model, false, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/false,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
   EXPECT_EQ(relaxation.linear_constraints.size(), 1);
   EXPECT_EQ(relaxation.linear_constraints[0].DebugString(),
             "3 <= 2*X0 1*X1 3*X2 <= 5");
@@ -1038,12 +1074,12 @@ TEST(AppendLinearConstraintRelaxation, SmallConstraint) {
   )pb");
 
   Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/true,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
 
   EXPECT_EQ(relaxation.linear_constraints.size(), 0);
 }
@@ -1064,12 +1100,12 @@ TEST(AppendLinearConstraintRelaxation, SingleEnforcementLiteralLowerBound) {
   )pb");
 
   Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/true,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
 
   EXPECT_EQ(relaxation.linear_constraints.size(), 1);
   EXPECT_EQ(relaxation.linear_constraints[0].DebugString(),
@@ -1092,12 +1128,12 @@ TEST(AppendLinearConstraintRelaxation, SingleEnforcementLiteralUpperBound) {
   )pb");
 
   Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/true,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
 
   EXPECT_EQ(relaxation.linear_constraints.size(), 1);
   EXPECT_EQ(relaxation.linear_constraints[0].DebugString(),
@@ -1120,12 +1156,12 @@ TEST(AppendLinearConstraintRelaxation, SingleEnforcementLiteralBothBounds) {
   )pb");
 
   Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/true,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
 
   EXPECT_EQ(relaxation.linear_constraints.size(), 2);
   EXPECT_EQ(relaxation.linear_constraints[0].DebugString(),
@@ -1152,12 +1188,12 @@ TEST(AppendLinearConstraintRelaxation, MultipleEnforcementLiteral) {
   )pb");
 
   Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/true,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
 
   EXPECT_EQ(relaxation.linear_constraints.size(), 2);
   EXPECT_EQ(relaxation.linear_constraints[0].DebugString(),
@@ -1186,12 +1222,12 @@ TEST(AppendLinearConstraintRelaxation, BoundsNotTight) {
   )pb");
 
   Model model;
+  model.GetOrCreate<SatParameters>()->set_linearization_level(2);
   LoadVariables(initial_model, true, &model);
 
   LinearRelaxation relaxation;
-  AppendLinearConstraintRelaxation(initial_model.constraints(0),
-                                   /*linearize_enforced_constraints=*/true,
-                                   &model, &relaxation);
+  AppendLinearConstraintRelaxation(initial_model.constraints(0), &model,
+                                   &relaxation);
 
   EXPECT_EQ(relaxation.linear_constraints.size(), 0);
 }
diff --git a/ortools/sat/no_overlap_2d_helper.cc b/ortools/sat/no_overlap_2d_helper.cc
index 94484b160e..35f7c08e15 100644
--- a/ortools/sat/no_overlap_2d_helper.cc
+++ b/ortools/sat/no_overlap_2d_helper.cc
@@ -24,6 +24,7 @@
 #include "absl/types/span.h"
 #include "ortools/sat/2d_rectangle_presolve.h"
 #include "ortools/sat/diffn_util.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/sat_base.h"
@@ -94,7 +95,7 @@ ItemWithVariableSize NoOverlap2DConstraintHelper::GetItemWithVariableSize(
 namespace {
 void ClearAndAddMandatoryOverlapReason(int box1, int box2,
                                        SchedulingConstraintHelper* y) {
-  y->ClearReason();
+  y->ResetReason();
   y->AddPresenceReason(box1);
   y->AddPresenceReason(box2);
   y->AddReasonForBeingBeforeAssumingNoOverlap(box1, box2);
@@ -115,7 +116,7 @@ bool NoOverlap2DConstraintHelper::ReportConflictFromTwoBoxes(int box1,
   }
   ClearAndAddMandatoryOverlapReason(box1, box2, x_helper_.get());
   ClearAndAddMandatoryOverlapReason(box1, box2, y_helper_.get());
-  x_helper_->ImportOtherReasons(*y_helper_);
+  x_helper_->ImportReasonsFromOther(*y_helper_);
   return x_helper_->ReportConflict();
 }
 
@@ -124,8 +125,8 @@ bool NoOverlap2DConstraintHelper::ReportConflictFromInfeasibleBoxRanges(
   if (ranges.size() == 2) {
     return ReportConflictFromTwoBoxes(ranges[0].box_index, ranges[1].box_index);
   }
-  x_helper_->ClearReason();
-  y_helper_->ClearReason();
+  x_helper_->ResetReason();
+  y_helper_->ResetReason();
   for (const auto& range : ranges) {
     const int b = range.box_index;
 
@@ -141,7 +142,7 @@ bool NoOverlap2DConstraintHelper::ReportConflictFromInfeasibleBoxRanges(
     x_helper_->AddPresenceReason(b);
     y_helper_->AddPresenceReason(b);
   }
-  x_helper_->ImportOtherReasons(*y_helper_);
+  x_helper_->ImportReasonsFromOther(*y_helper_);
   return x_helper_->ReportConflict();
 }
 
@@ -156,37 +157,15 @@ namespace {
 bool LeftBoxBeforeRightBoxOnFirstDimension(int left, int right,
                                            SchedulingConstraintHelper* x,
                                            SchedulingConstraintHelper* y) {
-  // left box2 pushes right box2.
-  const IntegerValue left_end_min = x->EndMin(left);
-  if (left_end_min > x->StartMin(right)) {
-    x->ClearReason();
-    x->AddPresenceReason(left);
-    x->AddPresenceReason(right);
-    x->AddReasonForBeingBeforeAssumingNoOverlap(left, right);
-    x->AddEndMinReason(left, left_end_min);
-    // left and right must overlap on y.
-    ClearAndAddMandatoryOverlapReason(left, right, y);
-    // Propagate with the complete reason.
-    x->ImportOtherReasons(*y);
-    if (!x->IncreaseStartMin(right, left_end_min)) return false;
-  }
-
-  // right box2 pushes left box2.
-  const IntegerValue right_start_max = x->StartMax(right);
-  if (right_start_max < x->EndMax(left)) {
-    x->ClearReason();
-    x->AddPresenceReason(left);
-    x->AddPresenceReason(right);
-    x->AddReasonForBeingBeforeAssumingNoOverlap(left, right);
-    x->AddStartMaxReason(right, right_start_max);
-    // left and right must overlap on y.
-    ClearAndAddMandatoryOverlapReason(left, right, y);
-    // Propagate with the complete reason.
-    x->ImportOtherReasons(*y);
-    if (!x->DecreaseEndMax(left, right_start_max)) return false;
-  }
-
-  return true;
+  x->ResetReason();
+  x->AddPresenceReason(left);
+  x->AddPresenceReason(right);
+  x->AddReasonForBeingBeforeAssumingNoOverlap(left, right);
+  // left and right must overlap on y.
+  ClearAndAddMandatoryOverlapReason(left, right, y);
+  // Propagate with the complete reason.
+  x->ImportReasonsFromOther(*y);
+  return x->PushTaskOrderWhenPresent(left, right);
 }
 
 }  // namespace
@@ -311,11 +290,19 @@ void NoOverlap2DConstraintHelper::Reset(
   y_helper_ = std::make_unique<SchedulingConstraintHelper>(
       std::move(y_starts), std::move(y_ends), std::move(y_sizes),
       std::move(y_reason_for_presence), model_);
+  x_helper_->SetEnforcementId(enforcement_id_);
+  y_helper_->SetEnforcementId(enforcement_id_);
   x_demands_helper_ = nullptr;
   y_demands_helper_ = nullptr;
 }
 
+bool NoOverlap2DConstraintHelper::IsEnforced() const {
+  return enforcement_helper_.Status(enforcement_id_) ==
+         EnforcementStatus::IS_ENFORCED;
+}
+
 bool NoOverlap2DConstraintHelper::Propagate() {
+  if (!IsEnforced()) return true;
   for (const int id : propagators_watching_) {
     watcher_->CallOnNextPropagate(id);
   }
@@ -373,7 +360,9 @@ bool NoOverlap2DConstraintHelper::Propagate() {
   return true;
 }
 
-void NoOverlap2DConstraintHelper::RegisterWith(GenericLiteralWatcher* watcher) {
+void NoOverlap2DConstraintHelper::RegisterWith(
+    GenericLiteralWatcher* watcher,
+    absl::Span<const Literal> enforcement_literals) {
   const int id = watcher->Register(this);
   const int num_boxes = NumBoxes();
   for (int b = 0; b < num_boxes; ++b) {
@@ -391,6 +380,10 @@ void NoOverlap2DConstraintHelper::RegisterWith(GenericLiteralWatcher* watcher) {
     watcher->WatchIntegerVariable(y_helper_->Ends()[b].var, id);
   }
   watcher->SetPropagatorPriority(id, 0);
+  enforcement_id_ =
+      enforcement_helper_.Register(enforcement_literals, watcher, id);
+  x_helper_->SetEnforcementId(enforcement_id_);
+  y_helper_->SetEnforcementId(enforcement_id_);
 }
 
 }  // namespace sat
diff --git a/ortools/sat/no_overlap_2d_helper.h b/ortools/sat/no_overlap_2d_helper.h
index e0051317b2..be34f06f2e 100644
--- a/ortools/sat/no_overlap_2d_helper.h
+++ b/ortools/sat/no_overlap_2d_helper.h
@@ -21,6 +21,8 @@
 
 #include "absl/types/span.h"
 #include "ortools/sat/diffn_util.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
@@ -51,6 +53,8 @@ class NoOverlap2DConstraintHelper : public PropagatorInterface {
             x_starts, x_ends, x_sizes, x_reason_for_presence, model)),
         y_helper_(std::make_unique<SchedulingConstraintHelper>(
             y_starts, y_ends, y_sizes, y_reason_for_presence, model)),
+        enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()),
+        enforcement_id_(-1),
         model_(model),
         watcher_(model->GetOrCreate<GenericLiteralWatcher>()) {
     const int num_boxes = x_helper_->NumTasks();
@@ -63,7 +67,8 @@ class NoOverlap2DConstraintHelper : public PropagatorInterface {
     }
   }
 
-  void RegisterWith(GenericLiteralWatcher* watcher);
+  void RegisterWith(GenericLiteralWatcher* watcher,
+                    absl::Span<const Literal> enforcement_literals);
 
   bool SynchronizeAndSetDirection(bool x_is_forward_after_swap = true,
                                   bool y_is_forward_after_swap = true,
@@ -110,9 +115,11 @@ class NoOverlap2DConstraintHelper : public PropagatorInterface {
             y_helper_->LevelZeroSizeMin(index)};
   }
 
-  void ClearReason() {
-    x_helper_->ClearReason();
-    y_helper_->ClearReason();
+  bool IsEnforced() const;
+
+  void ResetReason() {
+    x_helper_->ResetReason();
+    y_helper_->ResetReason();
   }
 
   void WatchAllBoxes(int id) { propagators_watching_.push_back(id); }
@@ -203,12 +210,12 @@ class NoOverlap2DConstraintHelper : public PropagatorInterface {
   }
 
   bool IncreaseLeftMin(int index, IntegerValue new_lower_bound) {
-    x_helper_->ImportOtherReasons(*y_helper_);
+    x_helper_->ImportReasonsFromOther(*y_helper_);
     return x_helper_->IncreaseStartMin(index, new_lower_bound);
   }
 
   bool ReportConflict() {
-    x_helper_->ImportOtherReasons(*y_helper_);
+    x_helper_->ImportReasonsFromOther(*y_helper_);
     return x_helper_->ReportConflict();
   }
 
@@ -244,6 +251,8 @@ class NoOverlap2DConstraintHelper : public PropagatorInterface {
   std::unique_ptr<SchedulingConstraintHelper> y_helper_;
   std::unique_ptr<SchedulingDemandHelper> x_demands_helper_;
   std::unique_ptr<SchedulingDemandHelper> y_demands_helper_;
+  EnforcementHelper& enforcement_helper_;
+  EnforcementId enforcement_id_;
   Model* model_;
   GenericLiteralWatcher* watcher_;
   std::vector<int> propagators_watching_;
diff --git a/ortools/sat/parameters_validation.cc b/ortools/sat/parameters_validation.cc
index 7c0de26f54..1e7f52e628 100644
--- a/ortools/sat/parameters_validation.cc
+++ b/ortools/sat/parameters_validation.cc
@@ -161,11 +161,6 @@ std::string ValidateParameters(const SatParameters& params) {
   TEST_NON_NEGATIVE(symmetry_detection_deterministic_time_limit);
   TEST_POSITIVE(share_glue_clauses_dtime);
 
-  if (params.enumerate_all_solutions() &&
-      (params.num_search_workers() > 1 || params.num_workers() > 1)) {
-    return "Enumerating all solutions does not work in parallel";
-  }
-
   if (params.enumerate_all_solutions() &&
       (!params.subsolvers().empty() || !params.extra_subsolvers().empty() ||
        !params.ignore_subsolvers().empty())) {
diff --git a/ortools/sat/precedences.cc b/ortools/sat/precedences.cc
index 2ce6788e9e..13bc591b2d 100644
--- a/ortools/sat/precedences.cc
+++ b/ortools/sat/precedences.cc
@@ -347,6 +347,7 @@ EnforcedLinear2Bounds::~EnforcedLinear2Bounds() {
 void EnforcedLinear2Bounds::PushConditionalRelation(
     absl::Span<const Literal> enforcements, LinearExpression2Index lin2_index,
     IntegerValue rhs) {
+  DCHECK_EQ(trail_->CurrentDecisionLevel(), stored_level_);
   // This must be currently true.
   if (DEBUG_MODE) {
     for (const Literal l : enforcements) {
@@ -407,6 +408,7 @@ void EnforcedLinear2Bounds::CreateLevelEntryIfNeeded() {
 
 // We only pop what is needed.
 void EnforcedLinear2Bounds::SetLevel(int level) {
+  stored_level_ = level;
   while (!level_to_stack_size_.empty() &&
          level_to_stack_size_.back().first > level) {
     const int target = level_to_stack_size_.back().second;
@@ -438,6 +440,7 @@ void EnforcedLinear2Bounds::AddReasonForUpperBoundLowerThan(
     LinearExpression2Index index, IntegerValue ub,
     std::vector<Literal>* literal_reason,
     std::vector<IntegerLiteral>* /*unused*/) const {
+  DCHECK_EQ(trail_->CurrentDecisionLevel(), stored_level_);
   if (ub >= root_level_bounds_->LevelZeroUpperBound(index)) return;
   DCHECK_LT(index, conditional_relations_.size());
   const int entry_index = conditional_relations_[index];
@@ -457,6 +460,7 @@ void EnforcedLinear2Bounds::AddReasonForUpperBoundLowerThan(
 
 IntegerValue EnforcedLinear2Bounds::GetUpperBoundFromEnforced(
     LinearExpression2Index index) const {
+  DCHECK_EQ(trail_->CurrentDecisionLevel(), stored_level_);
   if (index >= conditional_relations_.size()) {
     return kMaxIntegerValue;
   }
@@ -736,6 +740,16 @@ void EnforcedLinear2Bounds::CollectPrecedences(
   }
 }
 
+BinaryRelationRepository::~BinaryRelationRepository() {
+  if (!VLOG_IS_ON(1)) return;
+  std::vector<std::pair<std::string, int64_t>> stats;
+  stats.push_back({"BinaryRelationRepository/num_enforced_relations",
+                   num_enforced_relations_});
+  stats.push_back({"BinaryRelationRepository/num_encoded_equivalences",
+                   num_encoded_equivalences_});
+  shared_stats_->AddStats(stats);
+}
+
 void BinaryRelationRepository::Add(Literal lit, LinearExpression2 expr,
                                    IntegerValue lhs, IntegerValue rhs) {
   expr.SimpleCanonicalization();
@@ -774,6 +788,91 @@ void BinaryRelationRepository::Build() {
     literal_key_values.emplace_back(r.enforcement.Index(), i);
   }
   lit_to_relations_.ResetFromPairs(literal_key_values);
+  lit_to_relations_.Add({});  // One extra unit size to make sure the negation
+                              // cannot be out of bounds in lit_to_relations_.
+
+  // If we have "l => (x <= 6)" and "~l => (x >= 9)" we can push
+  // "l <=> (x <= 6)" to the repository of fully encoded linear2 bounds.
+  // More generally, if we have:
+  //
+  //    l => (expr <= a)
+  //   ~l => (expr >= b)
+  //
+  // And if moreover a < b, we have the following truth table:
+  //
+  //   l | expr <= a | a < expr < b | expr >= b
+  //   --+-----------+---------------+----------
+  //   0 |    false  |     false     |   true    (from "~l => (expr >= b)")
+  //   1 |    true   |     false     |   false   (from "l => (expr <= a)")
+  //
+  //  So we can generalize the expressions to equivalences:
+  //    l <=> (expr <= a)
+  //   ~l <=> (expr >= b)
+  //    (a < expr < b) is impossible
+  absl::flat_hash_map<LinearExpression2, IntegerValue> lin2_to_upper_bound;
+  for (LiteralIndex lit_index{0}; lit_index < lit_to_relations_.size() - 1;
+       ++lit_index) {
+    const Literal lit(lit_index);
+    lin2_to_upper_bound.clear();
+    const absl::Span<const int> relations = lit_to_relations_[lit_index];
+    const absl::Span<const int> relations_negation =
+        lit_to_relations_[lit.NegatedIndex()];
+    if (relations.empty() || relations_negation.empty()) continue;
+    for (const int relation_index : relations) {
+      const Relation& r = relations_[relation_index];
+      LinearExpression2 expr = r.expr;
+      if (expr.coeffs[0] == 0) continue;
+      expr.SimpleCanonicalization();  // Since relations_ uses a different
+                                      // canonicalization convention.
+      DCHECK_EQ(expr.DivideByGcd(), 1);
+      {
+        const auto [it, inserted] = lin2_to_upper_bound.insert({expr, r.rhs});
+        if (!inserted) {
+          it->second = std::min(it->second, r.rhs);
+        }
+      }
+      {
+        expr.Negate();
+        const auto [it, inserted] = lin2_to_upper_bound.insert({expr, -r.lhs});
+        if (!inserted) {
+          it->second = std::min(it->second, -r.lhs);
+        }
+      }
+    }
+    for (const int relation_index : relations_negation) {
+      const Relation& r = relations_[relation_index];
+      LinearExpression2 canonical_expr = r.expr;
+      canonical_expr.SimpleCanonicalization();
+      if (canonical_expr.coeffs[0] == 0) continue;
+      DCHECK_EQ(canonical_expr.DivideByGcd(), 1);
+
+      // Let's work with lower bounds only.
+      const IntegerValue lower_bounds[2] = {r.lhs, -r.rhs};
+      LinearExpression2 exprs[2] = {canonical_expr, canonical_expr};
+      exprs[1].Negate();
+      for (int i = 0; i < 2; ++i) {
+        // We have here "~l => (exprs[i] >= lower_bounds[i])".
+        const auto it = lin2_to_upper_bound.find(exprs[i]);
+        if (it != lin2_to_upper_bound.end()) {
+          const IntegerValue ub = it->second;
+          // Here we have "l => expr <= ub".
+          if (ub >= lower_bounds[i]) {
+            // Don't obey the "a < b" condition
+            continue;
+          }
+          num_encoded_equivalences_++;
+
+          // Make both relationships two-way.
+          reified_linear2_bounds_->AddBoundEncodingIfNonTrivial(lit, exprs[i],
+                                                                ub);
+          LinearExpression2 expr = exprs[i];
+          expr.Negate();
+          reified_linear2_bounds_->AddBoundEncodingIfNonTrivial(
+              lit.Negated(), expr, -lower_bounds[i]);
+        }
+      }
+    }
+  }
 }
 
 bool BinaryRelationRepository::PropagateLocalBounds(
@@ -1326,6 +1425,24 @@ void Linear2BoundsFromLinear3::AddReasonForUpperBoundLowerThan(
   integer_reason->push_back(affine.LowerOrEqual(CapProdI(ub + 1, divisor) - 1));
 }
 
+Linear2Bounds::~Linear2Bounds() {
+  if (!VLOG_IS_ON(1)) return;
+  std::vector<std::pair<std::string, int64_t>> stats;
+  stats.push_back({"Linear2Bounds/enqueue_trivial", enqueue_trivial_});
+  stats.push_back({"Linear2Bounds/enqueue_degenerate", enqueue_degenerate_});
+  stats.push_back({"Linear2Bounds/enqueue_true_at_root_level",
+                   enqueue_true_at_root_level_});
+  stats.push_back({"Linear2Bounds/enqueue_conflict_false_at_root_level",
+                   enqueue_conflict_false_at_root_level_});
+  stats.push_back({"Linear2Bounds/enqueue_individual_var_bounds",
+                   enqueue_individual_var_bounds_});
+  stats.push_back(
+      {"Linear2Bounds/enqueue_literal_encoding", enqueue_literal_encoding_});
+  stats.push_back({"Linear2Bounds/enqueue_integer_linear3_encoding",
+                   enqueue_integer_linear3_encoding_});
+  shared_stats_->AddStats(stats);
+}
+
 IntegerValue Linear2Bounds::UpperBound(
     LinearExpression2Index lin2_index) const {
   return std::min(
@@ -1341,6 +1458,9 @@ IntegerValue Linear2Bounds::UpperBound(LinearExpression2 expr) const {
   DCHECK_NE(expr.coeffs[1], 0);
   const IntegerValue gcd = expr.DivideByGcd();
   IntegerValue ub = integer_trail_->UpperBound(expr);
+  // TODO(user): remove this when the UB in the trail in the current level is
+  // never worse than in the root level.
+  ub = std::min(ub, integer_trail_->LevelZeroUpperBound(expr));
   const LinearExpression2Index index = lin2_indices_->GetIndex(expr);
   if (index != kNoLinearExpression2Index) {
     ub = std::min(ub, root_level_bounds_->GetUpperBoundNoTrail(index));
@@ -1413,5 +1533,123 @@ RelationStatus Linear2Bounds::GetStatus(LinearExpression2 expr, IntegerValue lb,
   return RelationStatus::IS_UNKNOWN;
 }
 
+bool Linear2Bounds::EnqueueLowerOrEqual(
+    LinearExpression2 expr, IntegerValue ub,
+    absl::Span<const Literal> literal_reason,
+    absl::Span<const IntegerLiteral> integer_reason) {
+  using ReifiedBoundType = ReifiedLinear2Bounds::ReifiedBoundType;
+  expr.SimpleCanonicalization();
+  const IntegerValue gcd = expr.DivideByGcd();
+  ub = FloorRatio(ub, gcd);
+  // We have many different scenarios here, each one pushing something different
+  // in the trail.
+
+  // Trivial.
+  if (expr.coeffs[0] == 0 && expr.coeffs[1] == 0) {
+    ++enqueue_trivial_;
+    if (ub >= 0) {
+      return true;
+    } else {
+      return integer_trail_->ReportConflict(literal_reason, integer_reason);
+    }
+  }
+
+  // Degenerate single variable case, just push the IntegerLiteral.
+  if (expr.coeffs[0] == 0) {
+    ++enqueue_degenerate_;
+    return integer_trail_->Enqueue(
+        IntegerLiteral::LowerOrEqual(expr.vars[1], ub), literal_reason,
+        integer_reason);
+  }
+
+  // TODO(user): also check partially-encoded bounds, e.g. (expr <= ub) => l,
+  // which might be in BinaryRelationRepository as ~l => (-expr <= - ub - 1).
+  const auto reified_bound = reified_lin2_bounds_->GetEncodedBound(expr, ub);
+
+  // Already true.
+  if (std::holds_alternative<ReifiedBoundType>(reified_bound) &&
+      std::get<ReifiedBoundType>(reified_bound) ==
+          ReifiedBoundType::kAlwaysTrue) {
+    ++enqueue_true_at_root_level_;
+    return true;
+  }
+
+  // Conflict (ub < lb).
+  if (std::holds_alternative<ReifiedBoundType>(reified_bound) &&
+      std::get<ReifiedBoundType>(reified_bound) ==
+          ReifiedBoundType::kAlwaysFalse) {
+    ++enqueue_conflict_false_at_root_level_;
+    // It's false at level zero, so we can just report a conflict.
+    return integer_trail_->ReportConflict(literal_reason, integer_reason);
+  }
+
+  // Now all the cases below are pushing a proper linear2 bound. If we are at
+  // level zero, store this in the root_level_bounds_.
+  if (trail_->CurrentDecisionLevel() == 0) {
+    root_level_bounds_->AddUpperBound(expr, ub);
+  }
+
+  // We don't have anything encoding this linear2 bound. Push the bounds of
+  // its two variables.
+  if (std::holds_alternative<ReifiedBoundType>(reified_bound) &&
+      std::get<ReifiedBoundType>(reified_bound) ==
+          ReifiedBoundType::kNoLiteralStored) {
+    ++enqueue_individual_var_bounds_;
+    // TODO(user): create a Linear2 trail and enqueue this bound there.
+    std::vector<IntegerLiteral> tmp_integer_reason(integer_reason.begin(),
+                                                   integer_reason.end());
+    const IntegerValue var_0_ub = FloorRatio(
+        ub - integer_trail_->LowerBound(expr.vars[1]) * expr.coeffs[1],
+        expr.coeffs[0]);
+    const IntegerValue var_1_ub = FloorRatio(
+        ub - integer_trail_->LowerBound(expr.vars[0]) * expr.coeffs[0],
+        expr.coeffs[1]);
+
+    tmp_integer_reason.push_back(IntegerLiteral::GreaterOrEqual(
+        expr.vars[1], integer_trail_->LowerBound(expr.vars[1])));
+    if (!integer_trail_->Enqueue(
+            IntegerLiteral::LowerOrEqual(expr.vars[0], var_0_ub),
+            literal_reason, tmp_integer_reason)) {
+      return false;
+    }
+    tmp_integer_reason.pop_back();
+
+    tmp_integer_reason.push_back(IntegerLiteral::GreaterOrEqual(
+        expr.vars[0], integer_trail_->LowerBound(expr.vars[0])));
+    if (!integer_trail_->Enqueue(
+            IntegerLiteral::LowerOrEqual(expr.vars[1], var_1_ub),
+            literal_reason, tmp_integer_reason)) {
+      return false;
+    }
+    return true;
+  }
+
+  // We have a literal encoding for this linear2 bound, push it.
+  if (std::holds_alternative<Literal>(reified_bound)) {
+    ++enqueue_literal_encoding_;
+    const Literal literal = std::get<Literal>(reified_bound);
+    if (!integer_trail_->SafeEnqueueLiteral(literal, literal_reason,
+                                            integer_reason)) {
+      return false;
+    }
+    enforced_bounds_->PushConditionalRelation({literal}, expr, ub);
+    return true;
+  }
+
+  // We can encode this linear2 bound with an IntegerLiteral (probably coming
+  // from a linear3). Push the IntegerLiteral.
+  if (std::holds_alternative<IntegerLiteral>(reified_bound)) {
+    ++enqueue_integer_linear3_encoding_;
+    // TODO(user): push this to Linear2BoundsFromLinear3 so the same
+    // propagator that enqueued this bound will get the new linear2 bound if
+    // request it to this class without needing to wait the propagation fix
+    // point.
+    const IntegerLiteral literal = std::get<IntegerLiteral>(reified_bound);
+    return integer_trail_->Enqueue(literal, literal_reason, integer_reason);
+  }
+  LOG(FATAL) << "Unknown reified bound type";
+  return false;
+}
+
 }  // namespace sat
 }  // namespace operations_research
diff --git a/ortools/sat/precedences.h b/ortools/sat/precedences.h
index 2b120268e2..94bdc36c16 100644
--- a/ortools/sat/precedences.h
+++ b/ortools/sat/precedences.h
@@ -395,6 +395,12 @@ class EnforcedLinear2Bounds : public ReversibleInterface {
   // Called each time we change decision level.
   void SetLevel(int level) final;
 
+  void SetLevelToTrail() {
+    if (trail_->CurrentDecisionLevel() != stored_level_) {
+      SetLevel(trail_->CurrentDecisionLevel());
+    }
+  }
+
   // Returns a set of precedences such that we have a relation
   // of the form vars[index] <= var + offset.
   //
@@ -437,6 +443,7 @@ class EnforcedLinear2Bounds : public ReversibleInterface {
   Linear2Indices* lin2_indices_;
 
   int64_t num_conditional_relation_updates_ = 0;
+  int stored_level_ = 0;
 
   // Conditional stack for push/pop of conditional relations.
   //
@@ -496,12 +503,19 @@ struct Relation {
   }
 };
 
+class ReifiedLinear2Bounds;
+
 // A repository of all the enforced linear constraints of size 1 or 2.
 //
 // TODO(user): This is not always needed, find a way to clean this once we
 // don't need it.
 class BinaryRelationRepository {
  public:
+  explicit BinaryRelationRepository(Model* model)
+      : reified_linear2_bounds_(model->GetOrCreate<ReifiedLinear2Bounds>()),
+        shared_stats_(model->GetOrCreate<SharedStatistics>()) {}
+  ~BinaryRelationRepository();
+
   int size() const { return relations_.size(); }
 
   // The returned relation is guaranteed to only have positive variables.
@@ -543,8 +557,11 @@ class BinaryRelationRepository {
       absl::flat_hash_map<IntegerVariable, IntegerValue>* output) const;
 
  private:
+  ReifiedLinear2Bounds* reified_linear2_bounds_;
+  SharedStatistics* shared_stats_;
   bool is_built_ = false;
   int num_enforced_relations_ = 0;
+  int num_encoded_equivalences_ = 0;
   std::vector<Relation> relations_;
   CompactVectorVector<LiteralIndex, int> lit_to_relations_;
 };
@@ -677,7 +694,12 @@ class Linear2Bounds {
         root_level_bounds_(model->GetOrCreate<RootLevelLinear2Bounds>()),
         enforced_bounds_(model->GetOrCreate<EnforcedLinear2Bounds>()),
         linear3_bounds_(model->GetOrCreate<Linear2BoundsFromLinear3>()),
-        lin2_indices_(model->GetOrCreate<Linear2Indices>()) {}
+        lin2_indices_(model->GetOrCreate<Linear2Indices>()),
+        reified_lin2_bounds_(model->GetOrCreate<ReifiedLinear2Bounds>()),
+        trail_(model->GetOrCreate<Trail>()),
+        shared_stats_(model->GetOrCreate<SharedStatistics>()) {}
+
+  ~Linear2Bounds();
 
   // Returns the best known upper-bound of the given LinearExpression2 at the
   // current decision level. If its explanation is needed, it can be queried
@@ -697,12 +719,29 @@ class Linear2Bounds {
   // the individual variable bounds. This is faster.
   IntegerValue NonTrivialUpperBound(LinearExpression2Index lin2_index) const;
 
+  // Given the new linear2 bounds and its reason, inspect our various repository
+  // to find the strongest way to push this new upper bound.
+  bool EnqueueLowerOrEqual(LinearExpression2 expr, IntegerValue ub,
+                           absl::Span<const Literal> literal_reason,
+                           absl::Span<const IntegerLiteral> integer_reason);
+
  private:
   IntegerTrail* integer_trail_;
   RootLevelLinear2Bounds* root_level_bounds_;
   EnforcedLinear2Bounds* enforced_bounds_;
   Linear2BoundsFromLinear3* linear3_bounds_;
   Linear2Indices* lin2_indices_;
+  ReifiedLinear2Bounds* reified_lin2_bounds_;
+  Trail* trail_;
+  SharedStatistics* shared_stats_;
+
+  int64_t enqueue_trivial_ = 0;
+  int64_t enqueue_degenerate_ = 0;
+  int64_t enqueue_true_at_root_level_ = 0;
+  int64_t enqueue_conflict_false_at_root_level_ = 0;
+  int64_t enqueue_individual_var_bounds_ = 0;
+  int64_t enqueue_literal_encoding_ = 0;
+  int64_t enqueue_integer_linear3_encoding_ = 0;
 };
 
 // Detects if at least one of a subset of linear of size 2 or 1, touching the
diff --git a/ortools/sat/precedences_test.cc b/ortools/sat/precedences_test.cc
index d1c098d69e..59a64fcf59 100644
--- a/ortools/sat/precedences_test.cc
+++ b/ortools/sat/precedences_test.cc
@@ -532,7 +532,7 @@ TEST(BinaryRelationRepositoryTest, Build) {
   const IntegerVariable z = model.Add(NewIntegerVariable(-100, 100));
   const Literal lit_a = Literal(model.Add(NewBooleanVariable()), true);
   const Literal lit_b = Literal(model.Add(NewBooleanVariable()), true);
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   RootLevelLinear2Bounds* root_level_bounds =
       model.GetOrCreate<RootLevelLinear2Bounds>();
   repository.Add(lit_a, LinearExpression2(NegationOf(x), y, 1, 1), 2, 8);
@@ -836,7 +836,7 @@ TEST(BinaryRelationRepositoryTest, PropagateLocalBounds_EnforcedRelation) {
   const IntegerVariable x = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 10));
   const Literal lit_a = Literal(model.Add(NewBooleanVariable()), true);
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   RootLevelLinear2Bounds* root_level_bounds =
       model.GetOrCreate<RootLevelLinear2Bounds>();
   repository.Add(lit_a, LinearExpression2::Difference(y, x), 2,
@@ -861,7 +861,7 @@ TEST(BinaryRelationRepositoryTest, PropagateLocalBounds_UnenforcedRelation) {
   const IntegerVariable x = model.Add(NewIntegerVariable(-100, 100));
   const IntegerVariable y = model.Add(NewIntegerVariable(-100, 100));
   const Literal lit_a = Literal(model.Add(NewBooleanVariable()), true);
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(lit_a, LinearExpression2(x, y, -1, 1), -5,
                  10);  // lit_a => y => x - 5
   root_level_bounds->Add(LinearExpression2(x, y, -1, 1), 2,
@@ -888,7 +888,7 @@ TEST(BinaryRelationRepositoryTest,
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 10));
   const Literal lit_a = Literal(model.Add(NewBooleanVariable()), true);
   const Literal lit_b = Literal(model.Add(NewBooleanVariable()), true);
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(lit_a, LinearExpression2::Difference(y, x), -5,
                  10);  // lit_a => y => x - 5
   repository.Add(lit_b, LinearExpression2::Difference(y, x), 2,
@@ -911,7 +911,7 @@ TEST(BinaryRelationRepositoryTest,
   const IntegerVariable x = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 10));
   const Literal lit_a = Literal(model.Add(NewBooleanVariable()), true);
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   RootLevelLinear2Bounds* root_level_bounds =
       model.GetOrCreate<RootLevelLinear2Bounds>();
   repository.Add(lit_a, LinearExpression2::Difference(y, x), 2,
@@ -934,7 +934,7 @@ TEST(BinaryRelationRepositoryTest, PropagateLocalBounds_Infeasible) {
   const IntegerVariable x = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 10));
   const Literal lit_a = Literal(model.Add(NewBooleanVariable()), true);
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   RootLevelLinear2Bounds* root_level_bounds =
       model.GetOrCreate<RootLevelLinear2Bounds>();
   repository.Add(lit_a, LinearExpression2::Difference(y, x), 8,
diff --git a/ortools/sat/presolve_context.cc b/ortools/sat/presolve_context.cc
index 3400b25b73..85bd469bbc 100644
--- a/ortools/sat/presolve_context.cc
+++ b/ortools/sat/presolve_context.cc
@@ -32,7 +32,6 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/log/vlog_is_on.h"
-#include "absl/meta/type_traits.h"
 #include "absl/numeric/int128.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
diff --git a/ortools/sat/probing.cc b/ortools/sat/probing.cc
index e158151b22..c268279a27 100644
--- a/ortools/sat/probing.cc
+++ b/ortools/sat/probing.cc
@@ -593,7 +593,7 @@ bool FailedLiteralProbingRound(ProbingOptions options, Model* model) {
       const Literal prev_decision =
           sat_solver->Decisions()[sat_solver->CurrentDecisionLevel() - 1]
               .literal;
-      const auto& list =
+      const absl::Span<const Literal> list =
           implication_graph->Implications(prev_decision.Negated());
       const int saved_queue_size = queue.size();
       for (const Literal l : list) {
@@ -658,7 +658,7 @@ bool FailedLiteralProbingRound(ProbingOptions options, Model* model) {
     } else if (next_decision == kNoLiteralIndex) {
       const int level = sat_solver->CurrentDecisionLevel();
       const Literal prev_decision = sat_solver->Decisions()[level - 1].literal;
-      const auto& list =
+      const absl::Span<const Literal> list =
           implication_graph->Implications(prev_decision.Negated());
 
       // Probe a literal that implies previous decision.
diff --git a/ortools/sat/python/cp_model_helper.cc b/ortools/sat/python/cp_model_helper.cc
index 6675d7486e..1734bd4008 100644
--- a/ortools/sat/python/cp_model_helper.cc
+++ b/ortools/sat/python/cp_model_helper.cc
@@ -1544,6 +1544,15 @@ PYBIND11_MODULE(cp_model_helper, m) {
           },
           py::arg("other").none(false),
           DOC(operations_research, sat, python, LinearExpr, AddFloat))
+      .def(
+          "__radd__",
+          [](std::shared_ptr<SumArray> expr,
+             std::shared_ptr<LinearExpr> other) -> std::shared_ptr<LinearExpr> {
+            const int num_uses = Py_REFCNT(py::cast(expr).ptr());
+            return (num_uses == 4) ? expr->AddInPlace(other) : expr->Add(other);
+          },
+          py::arg("other").none(false),
+          DOC(operations_research, sat, python, LinearExpr, Add))
       .def(
           "__radd__",
           [](std::shared_ptr<SumArray> expr,
diff --git a/ortools/sat/python/cp_model_test.py b/ortools/sat/python/cp_model_test.py
index 92a807759c..382fdb426c 100644
--- a/ortools/sat/python/cp_model_test.py
+++ b/ortools/sat/python/cp_model_test.py
@@ -2691,6 +2691,11 @@ TRFM"""
         self.assertEqual(-2, prod.coefficient)
         self.assertEqual(2, prod.offset)
 
+    def test_issue4759(self):
+        model = cp_model.CpModel()
+        a = model.new_bool_var("a")
+        self.assertNotEmpty(str(0 * a + sum([1 * a, 2 * a])))
+
     def test_pre_pep8(self):
         model = cp_model.CpModel()
         x = [model.NewBoolVar(f"x{i}") for i in range(5)]
diff --git a/ortools/sat/python/wrappers.cc b/ortools/sat/python/wrappers.cc
index 2fd1539199..021619f5bc 100644
--- a/ortools/sat/python/wrappers.cc
+++ b/ortools/sat/python/wrappers.cc
@@ -337,7 +337,8 @@ class Generator {
         []($1 self) { return self->mutable_$2(); },
         py::return_value_policy::reference, py::keep_alive<0, 1>()))",
           field.name(), current_context_.self_mutable_name, field.name());
-      // We'll need to generate the wrapping for `proto2::RepeatedPtrField<$3>`.
+      // We'll need to generate the wrapping for
+      // `google::protobuf::RepeatedPtrField<$3>`.
       repeated_ptr_types_.insert(msg_type);
       // We'll need to generate the wrapping for this message type.
       message_stack_.push_back(ABSL_DIE_IF_NULL(field.message_type()));
@@ -350,7 +351,8 @@ class Generator {
         py::return_value_policy::reference, py::keep_alive<0, 1>()))",
                                 field.name(),
                                 current_context_.self_mutable_name);
-      // We'll need to generate the wrapping for `proto2::RepeatedField<$2>`.
+      // We'll need to generate the wrapping for
+      // `google::protobuf::RepeatedField<$2>`.
       repeated_scalar_types_.insert(GetCppType(field.cpp_type(), field));
     }
   }
diff --git a/ortools/sat/routing_cuts.cc b/ortools/sat/routing_cuts.cc
index 80f32678f8..e2f47ffb3b 100644
--- a/ortools/sat/routing_cuts.cc
+++ b/ortools/sat/routing_cuts.cc
@@ -1749,8 +1749,8 @@ std::pair<IntegerValue, IntegerValue> GetDifferenceBounds(
 }
 
 std::unique_ptr<RouteRelationsHelper> RouteRelationsHelper::Create(
-    int num_nodes, const std::vector<int>& tails, const std::vector<int>& heads,
-    const std::vector<Literal>& literals,
+    int num_nodes, absl::Span<const int> tails, absl::Span<const int> heads,
+    absl::Span<const Literal> literals,
     absl::Span<const AffineExpression> flat_node_dim_expressions,
     const BinaryRelationRepository& binary_relation_repository, Model* model) {
   CHECK(model != nullptr);
@@ -1851,7 +1851,8 @@ int ToNodeVariableIndex(IntegerVariable var) {
 // in routes constraints.
 BinaryRelationRepository ComputePartialBinaryRelationRepository(
     const CpModelProto& model) {
-  BinaryRelationRepository repository;
+  Model empty_model;
+  BinaryRelationRepository repository(&empty_model);
   for (const ConstraintProto& ct : model.constraints()) {
     if (ct.constraint_case() != ConstraintProto::kLinear) continue;
     const absl::Span<const int> vars = ct.linear().vars();
@@ -1861,7 +1862,6 @@ BinaryRelationRepository ComputePartialBinaryRelationRepository(
                                   ToPositiveIntegerVariable(vars[0]),
                                   ToPositiveIntegerVariable(vars[1]));
   }
-  Model empty_model;
   repository.Build();
   return repository;
 }
diff --git a/ortools/sat/routing_cuts.h b/ortools/sat/routing_cuts.h
index 0713f01bc4..38aea7fa52 100644
--- a/ortools/sat/routing_cuts.h
+++ b/ortools/sat/routing_cuts.h
@@ -127,8 +127,8 @@ class RouteRelationsHelper {
   // (node_expr[head] - node_expr[tail]) for each arc, assuming the arc is taken
   // (its literal is true).
   static std::unique_ptr<RouteRelationsHelper> Create(
-      int num_nodes, const std::vector<int>& tails,
-      const std::vector<int>& heads, const std::vector<Literal>& literals,
+      int num_nodes, absl::Span<const int> tails, absl::Span<const int> heads,
+      absl::Span<const Literal> literals,
       absl::Span<const AffineExpression> flat_node_dim_expressions,
       const BinaryRelationRepository& binary_relation_repository, Model* model);
 
diff --git a/ortools/sat/routing_cuts_test.cc b/ortools/sat/routing_cuts_test.cc
index 39bb0469ee..201d599d15 100644
--- a/ortools/sat/routing_cuts_test.cc
+++ b/ortools/sat/routing_cuts_test.cc
@@ -1409,7 +1409,7 @@ TEST(RouteRelationsHelperTest, Basic) {
   const IntegerVariable x = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable z = model.Add(NewIntegerVariable(0, 10));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(literals[0], LinearExpression2::Difference(a, b), 50, 1000);
   repository.Add(literals[1], LinearExpression2::Difference(a, c), 70, 1000);
   repository.Add(literals[2], LinearExpression2::Difference(c, b), 40, 1000);
@@ -1504,7 +1504,7 @@ TEST(RouteRelationsHelperTest, UnenforcedRelations) {
   const IntegerVariable b = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable c = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable d = model.Add(NewIntegerVariable(0, 100));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   RootLevelLinear2Bounds* bounds = model.GetOrCreate<RootLevelLinear2Bounds>();
   repository.Add(literals[0], LinearExpression2::Difference(b, a), 1, 1);
   repository.Add(literals[1], LinearExpression2::Difference(c, b), 2, 2);
@@ -1554,7 +1554,7 @@ TEST(RouteRelationsHelperTest, SeveralVariablesPerNode) {
   const IntegerVariable x = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable y = model.Add(NewIntegerVariable(0, 10));
   const IntegerVariable z = model.Add(NewIntegerVariable(0, 10));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(literals[0], LinearExpression2::Difference(b, a), 50, 1000);
   repository.Add(literals[1], LinearExpression2::Difference(c, b), 70, 1000);
   repository.Add(literals[0], LinearExpression2::Difference(z, y), 5, 100);
@@ -1585,7 +1585,7 @@ TEST(RouteRelationsHelperTest, ComplexVariableRelations) {
   // and 1, respectively.
   const IntegerVariable a = model.Add(NewIntegerVariable(0, 150));
   const IntegerVariable b = model.Add(NewIntegerVariable(0, 1));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   // "complex" relation with non +1/-1 coefficients.
   repository.Add(literals[0], LinearExpression2(b, a, 10, 1), 0, 150);
   repository.Build();
@@ -1620,7 +1620,7 @@ TEST(RouteRelationsHelperTest, TwoUnaryRelationsPerArc) {
   IntegerEncoder& encoder = *model.GetOrCreate<IntegerEncoder>();
   encoder.AssociateToIntegerEqualValue(literals[0], a, 20);
   encoder.AssociateToIntegerLiteral(literals[0], {b, 50});
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Build();
 
   const RoutingCumulExpressions cumuls = {
@@ -1650,7 +1650,7 @@ TEST(RouteRelationsHelperTest, SeveralRelationsPerArc) {
   const IntegerVariable a = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable b = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable c = model.Add(NewIntegerVariable(0, 100));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(literals[0], LinearExpression2::Difference(b, a), 50, 1000);
   repository.Add(literals[1], LinearExpression2::Difference(c, b), 70, 1000);
   // Add a second relation for some arc.
@@ -1686,7 +1686,7 @@ TEST(RouteRelationsHelperTest, SeveralArcsPerLiteral) {
   const IntegerVariable a = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable b = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable c = model.Add(NewIntegerVariable(0, 100));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(literals[0], LinearExpression2::Difference(b, a), 50, 1000);
   repository.Add(literals[0], LinearExpression2::Difference(c, b), 40, 1000);
   repository.Build();
@@ -1728,7 +1728,7 @@ TEST(RouteRelationsHelperTest, InconsistentRelationIsSkipped) {
   const IntegerVariable d = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable e = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable f = model.Add(NewIntegerVariable(0, 100));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(literals[0], LinearExpression2::Difference(b, a), 0, 0);
   repository.Add(literals[1], LinearExpression2::Difference(c, b), 1, 1);
   repository.Add(literals[2], LinearExpression2::Difference(d, c), 2, 2);
@@ -1788,7 +1788,7 @@ TEST(RouteRelationsHelperTest, InconsistentRelationWithMultipleArcsPerLiteral) {
   const IntegerVariable c = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable d = model.Add(NewIntegerVariable(0, 100));
   const IntegerVariable e = model.Add(NewIntegerVariable(0, 100));
-  BinaryRelationRepository repository;
+  BinaryRelationRepository repository(&model);
   repository.Add(literals[0], LinearExpression2::Difference(b, a), 0, 0);
   repository.Add(literals[1], LinearExpression2::Difference(c, b), 1, 1);
   repository.Add(literals[2], LinearExpression2::Difference(d, c), 2, 2);
diff --git a/ortools/sat/samples/BinPackingProblemSat.cs b/ortools/sat/samples/BinPackingProblemSat.cs
index 3accedacef..04384f0092 100644
--- a/ortools/sat/samples/BinPackingProblemSat.cs
+++ b/ortools/sat/samples/BinPackingProblemSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -116,3 +117,4 @@ public class BinPackingProblemSat
         Console.WriteLine(String.Format("  - wall time : {0} s", solver.WallTime()));
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/BinPackingProblemSat.java b/ortools/sat/samples/BinPackingProblemSat.java
index d3a985e464..c984e4d6a5 100644
--- a/ortools/sat/samples/BinPackingProblemSat.java
+++ b/ortools/sat/samples/BinPackingProblemSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -107,3 +108,4 @@ public class BinPackingProblemSat {
     System.out.println("  - wall time : " + solver.wallTime() + " s");
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/BoolOrSampleSat.cs b/ortools/sat/samples/BoolOrSampleSat.cs
index 14966ad8be..c8c279a7a9 100644
--- a/ortools/sat/samples/BoolOrSampleSat.cs
+++ b/ortools/sat/samples/BoolOrSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -26,3 +27,4 @@ public class BoolOrSampleSat
         model.AddBoolOr(new ILiteral[] { x, y.Not() });
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/BoolOrSampleSat.java b/ortools/sat/samples/BoolOrSampleSat.java
index a8386fbf6e..273142726a 100644
--- a/ortools/sat/samples/BoolOrSampleSat.java
+++ b/ortools/sat/samples/BoolOrSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -28,3 +29,4 @@ public class BoolOrSampleSat {
     model.addBoolOr(new Literal[] {x, y.not()});
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/ChannelingSampleSat.cs b/ortools/sat/samples/ChannelingSampleSat.cs
index 3f890f21fe..fe9e3ac3f6 100644
--- a/ortools/sat/samples/ChannelingSampleSat.cs
+++ b/ortools/sat/samples/ChannelingSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 using Google.OrTools.Util;
@@ -75,3 +76,4 @@ public class ChannelingSampleSat
         solver.Solve(model, cb);
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/ChannelingSampleSat.java b/ortools/sat/samples/ChannelingSampleSat.java
index bab7b01291..5af843bb47 100644
--- a/ortools/sat/samples/ChannelingSampleSat.java
+++ b/ortools/sat/samples/ChannelingSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -81,3 +82,4 @@ public final class ChannelingSampleSat {
 
   private ChannelingSampleSat() {}
 }
+// [END program]
diff --git a/ortools/sat/samples/EarlinessTardinessCostSampleSat.cs b/ortools/sat/samples/EarlinessTardinessCostSampleSat.cs
index 39a10c04f0..d11c7d1675 100644
--- a/ortools/sat/samples/EarlinessTardinessCostSampleSat.cs
+++ b/ortools/sat/samples/EarlinessTardinessCostSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 using Google.OrTools.Util;
@@ -80,3 +81,4 @@ public class EarlinessTardinessCostSampleSat
         solver.Solve(model, cb);
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/EarlinessTardinessCostSampleSat.java b/ortools/sat/samples/EarlinessTardinessCostSampleSat.java
index 33ec641758..bbde70186f 100644
--- a/ortools/sat/samples/EarlinessTardinessCostSampleSat.java
+++ b/ortools/sat/samples/EarlinessTardinessCostSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -94,3 +95,4 @@ public class EarlinessTardinessCostSampleSat {
     }.init(new IntVar[] {x, expr}));
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/IntervalSampleSat.cs b/ortools/sat/samples/IntervalSampleSat.cs
index 44ac1ecf18..83a9f8608c 100644
--- a/ortools/sat/samples/IntervalSampleSat.cs
+++ b/ortools/sat/samples/IntervalSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -37,3 +38,4 @@ public class IntervalSampleSat
         Console.WriteLine(fixedInterval);
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/IntervalSampleSat.java b/ortools/sat/samples/IntervalSampleSat.java
index ea71c109c6..a04d9b7d17 100644
--- a/ortools/sat/samples/IntervalSampleSat.java
+++ b/ortools/sat/samples/IntervalSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -43,3 +44,4 @@ public class IntervalSampleSat {
     System.out.println(fixedInterval);
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/LiteralSampleSat.cs b/ortools/sat/samples/LiteralSampleSat.cs
index d83abe0117..a3f3341c31 100644
--- a/ortools/sat/samples/LiteralSampleSat.cs
+++ b/ortools/sat/samples/LiteralSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -23,3 +24,4 @@ public class LiteralSampleSat
         ILiteral not_x = x.Not();
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/LiteralSampleSat.java b/ortools/sat/samples/LiteralSampleSat.java
index 1657f09a6b..5950000840 100644
--- a/ortools/sat/samples/LiteralSampleSat.java
+++ b/ortools/sat/samples/LiteralSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -28,3 +29,4 @@ public class LiteralSampleSat {
     System.out.println(notX);
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/NoOverlapSampleSat.cs b/ortools/sat/samples/NoOverlapSampleSat.cs
index af802bbcd9..57a0d4f0ce 100644
--- a/ortools/sat/samples/NoOverlapSampleSat.cs
+++ b/ortools/sat/samples/NoOverlapSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -66,3 +67,4 @@ public class NoOverlapSampleSat
         }
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/NoOverlapSampleSat.java b/ortools/sat/samples/NoOverlapSampleSat.java
index 2c723f0f2d..429fcd3bdc 100644
--- a/ortools/sat/samples/NoOverlapSampleSat.java
+++ b/ortools/sat/samples/NoOverlapSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -77,3 +78,4 @@ public class NoOverlapSampleSat {
     }
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/OptionalIntervalSampleSat.cs b/ortools/sat/samples/OptionalIntervalSampleSat.cs
index b834741635..78581479f4 100644
--- a/ortools/sat/samples/OptionalIntervalSampleSat.cs
+++ b/ortools/sat/samples/OptionalIntervalSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -39,3 +40,4 @@ public class OptionalIntervalSampleSat
         Console.WriteLine(fixedInterval);
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/OptionalIntervalSampleSat.java b/ortools/sat/samples/OptionalIntervalSampleSat.java
index ee388a2720..936aa48f90 100644
--- a/ortools/sat/samples/OptionalIntervalSampleSat.java
+++ b/ortools/sat/samples/OptionalIntervalSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -45,3 +46,4 @@ public class OptionalIntervalSampleSat {
     System.out.println(fixedInterval);
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/RabbitsAndPheasantsSat.cs b/ortools/sat/samples/RabbitsAndPheasantsSat.cs
index 59a2adc024..9eaf72e7a7 100644
--- a/ortools/sat/samples/RabbitsAndPheasantsSat.cs
+++ b/ortools/sat/samples/RabbitsAndPheasantsSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -38,3 +39,5 @@ public class RabbitsAndPheasantsSat
         }
     }
 }
+
+// [END program]
diff --git a/ortools/sat/samples/RabbitsAndPheasantsSat.java b/ortools/sat/samples/RabbitsAndPheasantsSat.java
index 56f9595945..f566e7ee27 100644
--- a/ortools/sat/samples/RabbitsAndPheasantsSat.java
+++ b/ortools/sat/samples/RabbitsAndPheasantsSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -46,3 +47,4 @@ public class RabbitsAndPheasantsSat {
     }
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/RankingSampleSat.cs b/ortools/sat/samples/RankingSampleSat.cs
index 75585a8eb7..5cb91aa278 100644
--- a/ortools/sat/samples/RankingSampleSat.cs
+++ b/ortools/sat/samples/RankingSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using System.Collections.Generic;
 using Google.OrTools.Sat;
@@ -169,3 +170,4 @@ public class RankingSampleSat
         }
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/RankingSampleSat.java b/ortools/sat/samples/RankingSampleSat.java
index 481e85d592..62895df826 100644
--- a/ortools/sat/samples/RankingSampleSat.java
+++ b/ortools/sat/samples/RankingSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -175,3 +176,4 @@ public class RankingSampleSat {
     }
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/ReifiedSampleSat.cs b/ortools/sat/samples/ReifiedSampleSat.cs
index 43e84c5ec6..688f448da2 100644
--- a/ortools/sat/samples/ReifiedSampleSat.cs
+++ b/ortools/sat/samples/ReifiedSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 
@@ -36,3 +37,4 @@ public class ReifiedSampleSat
         model.AddBoolOr(new ILiteral[] { b.Not(), y.Not() });
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/ReifiedSampleSat.java b/ortools/sat/samples/ReifiedSampleSat.java
index 04c59e6e3b..89e762fb94 100644
--- a/ortools/sat/samples/ReifiedSampleSat.java
+++ b/ortools/sat/samples/ReifiedSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -49,3 +50,4 @@ public class ReifiedSampleSat {
     model.addBoolOr(new Literal[] {b.not(), y.not()});
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/StepFunctionSampleSat.cs b/ortools/sat/samples/StepFunctionSampleSat.cs
index d528c88be0..5f0fedd340 100644
--- a/ortools/sat/samples/StepFunctionSampleSat.cs
+++ b/ortools/sat/samples/StepFunctionSampleSat.cs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 using System;
 using Google.OrTools.Sat;
 using Google.OrTools.Util;
@@ -94,3 +95,4 @@ public class StepFunctionSampleSat
         solver.Solve(model, cb);
     }
 }
+// [END program]
diff --git a/ortools/sat/samples/StepFunctionSampleSat.java b/ortools/sat/samples/StepFunctionSampleSat.java
index 0f1a8f3f10..a61437fbb6 100644
--- a/ortools/sat/samples/StepFunctionSampleSat.java
+++ b/ortools/sat/samples/StepFunctionSampleSat.java
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 package com.google.ortools.sat.samples;
 
 import com.google.ortools.Loader;
@@ -99,3 +100,4 @@ public class StepFunctionSampleSat {
     }.init(new IntVar[] {x, expr}));
   }
 }
+// [END program]
diff --git a/ortools/sat/samples/all_different_except_zero_sample_sat.py b/ortools/sat/samples/all_different_except_zero_sample_sat.py
index 9c3ea7edd8..b512fe4359 100644
--- a/ortools/sat/samples/all_different_except_zero_sample_sat.py
+++ b/ortools/sat/samples/all_different_except_zero_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Implements AllDifferentExcept0 using atomic constraints."""
 
 import collections
@@ -82,3 +83,4 @@ def all_different_except_0():
 
 
 all_different_except_0()
+# [END program]
diff --git a/ortools/sat/samples/binpacking_problem_sat.cc b/ortools/sat/samples/binpacking_problem_sat.cc
index d92fb94899..923a8a9762 100644
--- a/ortools/sat/samples/binpacking_problem_sat.cc
+++ b/ortools/sat/samples/binpacking_problem_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include <vector>
@@ -100,3 +101,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::BinpackingProblemSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/binpacking_problem_sat.go b/ortools/sat/samples/binpacking_problem_sat.go
index cfd7311261..5c10515500 100644
--- a/ortools/sat/samples/binpacking_problem_sat.go
+++ b/ortools/sat/samples/binpacking_problem_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The binpacking_problem_sat command is an example of a bin packing problem that uses channeling
 // constraints.
 package main
@@ -119,3 +120,5 @@ func main() {
 		log.Exitf("binpackingProblemSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/binpacking_problem_sat.py b/ortools/sat/samples/binpacking_problem_sat.py
index d1e671b384..29bbe84da1 100644
--- a/ortools/sat/samples/binpacking_problem_sat.py
+++ b/ortools/sat/samples/binpacking_problem_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Solves a binpacking problem using the CP-SAT solver."""
 
 
@@ -78,3 +79,4 @@ def binpacking_problem_sat():
 
 
 binpacking_problem_sat()
+# [END program]
diff --git a/ortools/sat/samples/bool_and_int_var_product_sample_sat.py b/ortools/sat/samples/bool_and_int_var_product_sample_sat.py
index 5b1144e644..6cfdd0c31a 100644
--- a/ortools/sat/samples/bool_and_int_var_product_sample_sat.py
+++ b/ortools/sat/samples/bool_and_int_var_product_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample that encodes the product of a Boolean and an integer variable."""
 
 from ortools.sat.python import cp_model
@@ -71,3 +72,4 @@ def bool_and_int_var_product_sample_sat():
 
 
 bool_and_int_var_product_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/bool_or_sample_sat.cc b/ortools/sat/samples/bool_or_sample_sat.cc
index e64e823f72..40524f371e 100644
--- a/ortools/sat/samples/bool_or_sample_sat.cc
+++ b/ortools/sat/samples/bool_or_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -41,3 +42,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::BoolOrSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/bool_or_sample_sat.go b/ortools/sat/samples/bool_or_sample_sat.go
index 06fac3ac23..ba6b47ccf3 100644
--- a/ortools/sat/samples/bool_or_sample_sat.go
+++ b/ortools/sat/samples/bool_or_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The bool_or_sample_sat command is simple example of the BoolOr constraint.
 package main
 
@@ -30,3 +31,5 @@ func boolOrSampleSat() {
 func main() {
 	boolOrSampleSat()
 }
+
+// [END program]
diff --git a/ortools/sat/samples/bool_or_sample_sat.py b/ortools/sat/samples/bool_or_sample_sat.py
index bb7ea1362f..b03c75066e 100644
--- a/ortools/sat/samples/bool_or_sample_sat.py
+++ b/ortools/sat/samples/bool_or_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrates a simple Boolean constraint."""
 
 
@@ -31,3 +32,4 @@ def bool_or_sample_sat():
 
 
 bool_or_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/boolean_product_sample_sat.go b/ortools/sat/samples/boolean_product_sample_sat.go
index cb0185be42..4af1bceccd 100644
--- a/ortools/sat/samples/boolean_product_sample_sat.go
+++ b/ortools/sat/samples/boolean_product_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The boolean_product_sample_sat command is a simple example of the product of two literals.
 package main
 
@@ -72,3 +73,5 @@ func main() {
 		log.Exitf("booleanProductSample returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/boolean_product_sample_sat.py b/ortools/sat/samples/boolean_product_sample_sat.py
index 171fd27a09..c815db67c6 100644
--- a/ortools/sat/samples/boolean_product_sample_sat.py
+++ b/ortools/sat/samples/boolean_product_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample that encodes the product of two Boolean variables."""
 
 
@@ -43,3 +44,4 @@ def boolean_product_sample_sat():
 
 
 boolean_product_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/channeling_sample_sat.cc b/ortools/sat/samples/channeling_sample_sat.cc
index a44f1f53f4..59da4d1dad 100644
--- a/ortools/sat/samples/channeling_sample_sat.cc
+++ b/ortools/sat/samples/channeling_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -75,3 +76,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::ChannelingSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/channeling_sample_sat.go b/ortools/sat/samples/channeling_sample_sat.go
index a35c6f2337..e50c176d05 100644
--- a/ortools/sat/samples/channeling_sample_sat.go
+++ b/ortools/sat/samples/channeling_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The channeling_sample_sat command is a simple example of a channeling constraint.
 package main
 
@@ -80,3 +81,5 @@ func main() {
 		log.Exitf("channelingSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/channeling_sample_sat.py b/ortools/sat/samples/channeling_sample_sat.py
index aecbad65f9..805b261d57 100644
--- a/ortools/sat/samples/channeling_sample_sat.py
+++ b/ortools/sat/samples/channeling_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Link integer constraints together."""
 
 
@@ -71,3 +72,4 @@ def channeling_sample_sat():
 
 
 channeling_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/code_samples.bzl b/ortools/sat/samples/code_samples.bzl
index 5c7f5ace28..ebe67f14d3 100644
--- a/ortools/sat/samples/code_samples.bzl
+++ b/ortools/sat/samples/code_samples.bzl
@@ -71,8 +71,6 @@ def code_sample_py(name):
             requirement("pandas"),
             "//ortools/sat/python:cp_model",
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
     py_test(
@@ -89,8 +87,6 @@ def code_sample_py(name):
             requirement("pandas"),
             requirement("protobuf"),
         ],
-        python_version = "PY3",
-        srcs_version = "PY3",
     )
 
 def code_sample_cc_go_py(name):
diff --git a/ortools/sat/samples/cumulative_variable_profile_sample_sat.py b/ortools/sat/samples/cumulative_variable_profile_sample_sat.py
index bfc4dd740c..fde43289a9 100644
--- a/ortools/sat/samples/cumulative_variable_profile_sample_sat.py
+++ b/ortools/sat/samples/cumulative_variable_profile_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Solves a scheduling problem with a min and max profile for the work load."""
 
 import io
@@ -282,3 +283,4 @@ def main(_) -> None:
 
 if __name__ == "__main__":
     app.run(main)
+# [END program]
diff --git a/ortools/sat/samples/earliness_tardiness_cost_sample_sat.cc b/ortools/sat/samples/earliness_tardiness_cost_sample_sat.cc
index c1eca56567..7faeba03fc 100644
--- a/ortools/sat/samples/earliness_tardiness_cost_sample_sat.cc
+++ b/ortools/sat/samples/earliness_tardiness_cost_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include <cstdint>
@@ -80,3 +81,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::EarlinessTardinessCostSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/earliness_tardiness_cost_sample_sat.go b/ortools/sat/samples/earliness_tardiness_cost_sample_sat.go
index cc7ca29fc1..7e38649fb3 100644
--- a/ortools/sat/samples/earliness_tardiness_cost_sample_sat.go
+++ b/ortools/sat/samples/earliness_tardiness_cost_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The earliness_tardiness_cost_sample_sat command is an example of an implementation of a convex
 // piecewise linear function.
 package main
@@ -89,3 +90,5 @@ func main() {
 		log.Exitf("earlinessTardinessCostSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/earliness_tardiness_cost_sample_sat.py b/ortools/sat/samples/earliness_tardiness_cost_sample_sat.py
index 2d90faf45a..c8a1fbe6f5 100644
--- a/ortools/sat/samples/earliness_tardiness_cost_sample_sat.py
+++ b/ortools/sat/samples/earliness_tardiness_cost_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Encodes a convex piecewise linear function."""
 
 
@@ -85,3 +86,4 @@ def earliness_tardiness_cost_sample_sat():
 
 
 earliness_tardiness_cost_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/index_first_boolvar_true_sample_sat.py b/ortools/sat/samples/index_first_boolvar_true_sample_sat.py
index 25676cbbc1..ddb78c8f31 100644
--- a/ortools/sat/samples/index_first_boolvar_true_sample_sat.py
+++ b/ortools/sat/samples/index_first_boolvar_true_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Compute the index of the first Boolean variable set to true."""
 
 from ortools.sat.python import cp_model
@@ -71,3 +72,4 @@ def index_of_first_bool_at_true_sample_sat():
 
 
 index_of_first_bool_at_true_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/interval_relations_sample_sat.py b/ortools/sat/samples/interval_relations_sample_sat.py
index 140242596c..c7991b88fc 100644
--- a/ortools/sat/samples/interval_relations_sample_sat.py
+++ b/ortools/sat/samples/interval_relations_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Builds temporal relations between intervals."""
 
 from ortools.sat.python import cp_model
@@ -77,3 +78,4 @@ def interval_relations_sample_sat():
 
 
 interval_relations_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/interval_sample_sat.cc b/ortools/sat/samples/interval_sample_sat.cc
index e6bb25a09e..76b7036dae 100644
--- a/ortools/sat/samples/interval_sample_sat.cc
+++ b/ortools/sat/samples/interval_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -68,3 +69,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::IntervalSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/interval_sample_sat.go b/ortools/sat/samples/interval_sample_sat.go
index 622e4d6514..e982de90c3 100644
--- a/ortools/sat/samples/interval_sample_sat.go
+++ b/ortools/sat/samples/interval_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The interval_sample_sat_go command is a simple example of the Interval variable.
 package main
 
@@ -56,3 +57,5 @@ func main() {
 		log.Exitf("intervalSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/interval_sample_sat.py b/ortools/sat/samples/interval_sample_sat.py
index d4ffb590db..3b4fedf39d 100644
--- a/ortools/sat/samples/interval_sample_sat.py
+++ b/ortools/sat/samples/interval_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrates how to build an interval."""
 
 
@@ -44,3 +45,4 @@ def interval_sample_sat():
 
 
 interval_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/literal_sample_sat.cc b/ortools/sat/samples/literal_sample_sat.cc
index e1a752f2ae..b959cd71cc 100644
--- a/ortools/sat/samples/literal_sample_sat.cc
+++ b/ortools/sat/samples/literal_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -39,3 +40,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::LiteralSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/literal_sample_sat.go b/ortools/sat/samples/literal_sample_sat.go
index 5d2de7e7a1..19375e7c9a 100644
--- a/ortools/sat/samples/literal_sample_sat.go
+++ b/ortools/sat/samples/literal_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The literal_sample_sat command is a simple example of literals.
 package main
 
@@ -31,3 +32,5 @@ func literalSampleSat() {
 func main() {
 	literalSampleSat()
 }
+
+// [END program]
diff --git a/ortools/sat/samples/literal_sample_sat.py b/ortools/sat/samples/literal_sample_sat.py
index a3d3c9e485..809dcab8e3 100644
--- a/ortools/sat/samples/literal_sample_sat.py
+++ b/ortools/sat/samples/literal_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrate Boolean variable and literals."""
 
 
@@ -27,3 +28,4 @@ def literal_sample_sat():
 
 
 literal_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/no_overlap_sample_sat.cc b/ortools/sat/samples/no_overlap_sample_sat.cc
index 2bfd8db2e0..8649739d9d 100644
--- a/ortools/sat/samples/no_overlap_sample_sat.cc
+++ b/ortools/sat/samples/no_overlap_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include <cstdint>
@@ -94,3 +95,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::NoOverlapSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/no_overlap_sample_sat.go b/ortools/sat/samples/no_overlap_sample_sat.go
index e24e7775e8..63873468b0 100644
--- a/ortools/sat/samples/no_overlap_sample_sat.go
+++ b/ortools/sat/samples/no_overlap_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The no_overlap_sample_sat command is an example of the NoOverlap constraints.
 package main
 
@@ -89,3 +90,5 @@ func main() {
 		log.Exitf("noOverlapSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/no_overlap_sample_sat.py b/ortools/sat/samples/no_overlap_sample_sat.py
index 51fcac9135..3335d529ff 100644
--- a/ortools/sat/samples/no_overlap_sample_sat.py
+++ b/ortools/sat/samples/no_overlap_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrate how to build a NoOverlap constraint."""
 
 from ortools.sat.python import cp_model
@@ -67,3 +68,4 @@ def no_overlap_sample_sat():
 
 
 no_overlap_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/optional_interval_sample_sat.cc b/ortools/sat/samples/optional_interval_sample_sat.cc
index a597933f3b..0fb64abfde 100644
--- a/ortools/sat/samples/optional_interval_sample_sat.cc
+++ b/ortools/sat/samples/optional_interval_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -65,3 +66,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::OptionalIntervalSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/optional_interval_sample_sat.go b/ortools/sat/samples/optional_interval_sample_sat.go
index 8be22a201d..a94e561678 100644
--- a/ortools/sat/samples/optional_interval_sample_sat.go
+++ b/ortools/sat/samples/optional_interval_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The optional_interval_sample_sat command is an example of an Interval variable that is
 // marked as optional.
 package main
@@ -54,3 +55,5 @@ func main() {
 		log.Exitf("optionalIntervalSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/optional_interval_sample_sat.py b/ortools/sat/samples/optional_interval_sample_sat.py
index fa43a96fba..b130e3b79f 100644
--- a/ortools/sat/samples/optional_interval_sample_sat.py
+++ b/ortools/sat/samples/optional_interval_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrates how to build an optional interval."""
 
 from ortools.sat.python import cp_model
@@ -48,3 +49,4 @@ def optional_interval_sample_sat():
 
 
 optional_interval_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/overlapping_intervals_sample_sat.py b/ortools/sat/samples/overlapping_intervals_sample_sat.py
index 7ac771e242..636cdf26ac 100644
--- a/ortools/sat/samples/overlapping_intervals_sample_sat.py
+++ b/ortools/sat/samples/overlapping_intervals_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrates how to detect if two intervals overlap."""
 
 from ortools.sat.python import cp_model
@@ -94,3 +95,4 @@ def overlapping_interval_sample_sat():
 
 
 overlapping_interval_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/rabbits_and_pheasants_sat.cc b/ortools/sat/samples/rabbits_and_pheasants_sat.cc
index 23358fe112..74527cfc00 100644
--- a/ortools/sat/samples/rabbits_and_pheasants_sat.cc
+++ b/ortools/sat/samples/rabbits_and_pheasants_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -54,3 +55,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::RabbitsAndPheasantsSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/rabbits_and_pheasants_sat.go b/ortools/sat/samples/rabbits_and_pheasants_sat.go
index 3dc6a51190..179e7fe222 100644
--- a/ortools/sat/samples/rabbits_and_pheasants_sat.go
+++ b/ortools/sat/samples/rabbits_and_pheasants_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The rabbits_and_pheasants_sat command is an example of a simple sat program that
 // solves the rabbits and pheasants problem.
 package main
@@ -62,3 +63,5 @@ func main() {
 		log.Exitf("rabbitsAndPheasants returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/rabbits_and_pheasants_sat.py b/ortools/sat/samples/rabbits_and_pheasants_sat.py
index f7a91050b2..2e0203bdac 100644
--- a/ortools/sat/samples/rabbits_and_pheasants_sat.py
+++ b/ortools/sat/samples/rabbits_and_pheasants_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Rabbits and Pheasants quizz."""
 
 from ortools.sat.python import cp_model
@@ -38,3 +39,4 @@ def rabbits_and_pheasants_sat():
 
 
 rabbits_and_pheasants_sat()
+# [END program]
diff --git a/ortools/sat/samples/ranking_circuit_sample_sat.py b/ortools/sat/samples/ranking_circuit_sample_sat.py
index 69a9cb7833..6a93bf82b0 100644
--- a/ortools/sat/samples/ranking_circuit_sample_sat.py
+++ b/ortools/sat/samples/ranking_circuit_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrates how to rank intervals using a circuit."""
 
 
@@ -177,3 +178,4 @@ def ranking_sample_sat() -> None:
 
 
 ranking_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/ranking_sample_sat.cc b/ortools/sat/samples/ranking_sample_sat.cc
index 5bf0b130ce..5e0631a3c4 100644
--- a/ortools/sat/samples/ranking_sample_sat.cc
+++ b/ortools/sat/samples/ranking_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -164,3 +165,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::RankingSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/ranking_sample_sat.go b/ortools/sat/samples/ranking_sample_sat.go
index 838d8c6e80..9ce8460be6 100644
--- a/ortools/sat/samples/ranking_sample_sat.go
+++ b/ortools/sat/samples/ranking_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The ranking_sample_sat command is an example of ranking intervals in a NoOverlap constraint.
 package main
 
@@ -164,3 +165,5 @@ func main() {
 		log.Exitf("rankingSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/ranking_sample_sat.py b/ortools/sat/samples/ranking_sample_sat.py
index 13bd9bbb98..d0c5d46092 100644
--- a/ortools/sat/samples/ranking_sample_sat.py
+++ b/ortools/sat/samples/ranking_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrates how to rank intervals."""
 
 from ortools.sat.python import cp_model
@@ -158,3 +159,4 @@ def ranking_sample_sat() -> None:
 
 
 ranking_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/reified_sample_sat.cc b/ortools/sat/samples/reified_sample_sat.cc
index af158deb11..3ffafc0607 100644
--- a/ortools/sat/samples/reified_sample_sat.cc
+++ b/ortools/sat/samples/reified_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -50,3 +51,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::ReifiedSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/reified_sample_sat.go b/ortools/sat/samples/reified_sample_sat.go
index c6e91df8f6..204e69dc16 100644
--- a/ortools/sat/samples/reified_sample_sat.go
+++ b/ortools/sat/samples/reified_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The reified_sample_sat command is a simple example of implication constraints.
 package main
 
@@ -40,3 +41,5 @@ func reifiedSampleSat() {
 func main() {
 	reifiedSampleSat()
 }
+
+// [END program]
diff --git a/ortools/sat/samples/reified_sample_sat.py b/ortools/sat/samples/reified_sample_sat.py
index 48d95cd577..cd6a8bbc8e 100644
--- a/ortools/sat/samples/reified_sample_sat.py
+++ b/ortools/sat/samples/reified_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Simple model with a reified constraint."""
 
 from ortools.sat.python import cp_model
@@ -38,3 +39,4 @@ def reified_sample_sat():
 
 
 reified_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/scheduling_with_calendar_sample_sat.py b/ortools/sat/samples/scheduling_with_calendar_sample_sat.py
index c74a2fe01e..6b76b92a8a 100644
--- a/ortools/sat/samples/scheduling_with_calendar_sample_sat.py
+++ b/ortools/sat/samples/scheduling_with_calendar_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Code sample to demonstrate how an interval can span across a break."""
 
 from ortools.sat.python import cp_model
@@ -78,3 +79,4 @@ def scheduling_with_calendar_sample_sat():
 
 
 scheduling_with_calendar_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/search_for_all_solutions_sample_sat.go b/ortools/sat/samples/search_for_all_solutions_sample_sat.go
index 15ba8ec56d..33723dc2cc 100644
--- a/ortools/sat/samples/search_for_all_solutions_sample_sat.go
+++ b/ortools/sat/samples/search_for_all_solutions_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The search_for_all_solutions_sample_sat command is an example for how to search for
 // all solutions.
 package main
@@ -67,3 +68,5 @@ func main() {
 		log.Exitf("searchForAllSolutionsSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/sequences_in_no_overlap_sample_sat.py b/ortools/sat/samples/sequences_in_no_overlap_sample_sat.py
index 46ef5034f8..e37b508aa8 100644
--- a/ortools/sat/samples/sequences_in_no_overlap_sample_sat.py
+++ b/ortools/sat/samples/sequences_in_no_overlap_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Implements sequence constraints in a no_overlap constraint."""
 
 from collections.abc import Sequence
@@ -296,3 +297,4 @@ def sequences_in_no_overlap_sample_sat():
 
 
 sequences_in_no_overlap_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/simple_sat_program.go b/ortools/sat/samples/simple_sat_program.go
index 588ceed1ea..b064a836a1 100644
--- a/ortools/sat/samples/simple_sat_program.go
+++ b/ortools/sat/samples/simple_sat_program.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The simple_sat_program command is an example of a simple sat program.
 package main
 
@@ -59,3 +60,5 @@ func main() {
 		log.Exitf("simpleSatProgram returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/solution_hinting_sample_sat.go b/ortools/sat/samples/solution_hinting_sample_sat.go
index 8ad6434151..0f1427e116 100644
--- a/ortools/sat/samples/solution_hinting_sample_sat.go
+++ b/ortools/sat/samples/solution_hinting_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The solution_hinting_sample_sat command is an example of setting solution hints on the model.
 package main
 
@@ -64,3 +65,5 @@ func main() {
 		log.Exitf("solutionHintingSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/solve_and_print_intermediate_solutions_sample_sat.go b/ortools/sat/samples/solve_and_print_intermediate_solutions_sample_sat.go
index 46b85cb548..2cec92f3e2 100644
--- a/ortools/sat/samples/solve_and_print_intermediate_solutions_sample_sat.go
+++ b/ortools/sat/samples/solve_and_print_intermediate_solutions_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The solve_and_print_intermediate_solutions_sample_sat command
 package main
 
@@ -69,3 +70,5 @@ func main() {
 		log.Exitf("solveAndPrintIntermediateSolutionsSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/solve_with_time_limit_sample_sat.go b/ortools/sat/samples/solve_with_time_limit_sample_sat.go
index c7b89e8d51..9b1bf01f6d 100644
--- a/ortools/sat/samples/solve_with_time_limit_sample_sat.go
+++ b/ortools/sat/samples/solve_with_time_limit_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The solve_with_time_limit_sample_sat command is an example of setting a time limit on the model.
 package main
 
@@ -67,3 +68,5 @@ func main() {
 		log.Exitf("solveWithTimeLimitSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/step_function_sample_sat.cc b/ortools/sat/samples/step_function_sample_sat.cc
index f5bbbfe86d..78d716d574 100644
--- a/ortools/sat/samples/step_function_sample_sat.cc
+++ b/ortools/sat/samples/step_function_sample_sat.cc
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 #include <stdlib.h>
 
 #include "absl/base/log_severity.h"
@@ -93,3 +94,4 @@ int main(int argc, char* argv[]) {
   operations_research::sat::StepFunctionSampleSat();
   return EXIT_SUCCESS;
 }
+// [END program]
diff --git a/ortools/sat/samples/step_function_sample_sat.go b/ortools/sat/samples/step_function_sample_sat.go
index 7fa569d7da..b6ab620733 100644
--- a/ortools/sat/samples/step_function_sample_sat.go
+++ b/ortools/sat/samples/step_function_sample_sat.go
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// [START program]
 // The step_function_sample_sat command is an example of an implementation of a step function.
 package main
 
@@ -98,3 +99,5 @@ func main() {
 		log.Exitf("stepFunctionSampleSat returned with error: %v", err)
 	}
 }
+
+// [END program]
diff --git a/ortools/sat/samples/step_function_sample_sat.py b/ortools/sat/samples/step_function_sample_sat.py
index 5098bc6619..1f0f174a33 100644
--- a/ortools/sat/samples/step_function_sample_sat.py
+++ b/ortools/sat/samples/step_function_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Implements a step function."""
 
 from ortools.sat.python import cp_model
@@ -89,3 +90,4 @@ def step_function_sample_sat():
 
 
 step_function_sample_sat()
+# [END program]
diff --git a/ortools/sat/samples/transitions_in_no_overlap_sample_sat.py b/ortools/sat/samples/transitions_in_no_overlap_sample_sat.py
index 441e549061..d413869f9f 100644
--- a/ortools/sat/samples/transitions_in_no_overlap_sample_sat.py
+++ b/ortools/sat/samples/transitions_in_no_overlap_sample_sat.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# [START program]
 """Implements transition times and costs in a no_overlap constraint."""
 
 from collections.abc import Sequence
@@ -202,3 +203,4 @@ def transitions_in_no_overlap_sample_sat():
 
 
 transitions_in_no_overlap_sample_sat()
+# [END program]
diff --git a/ortools/sat/sat_parameters.proto b/ortools/sat/sat_parameters.proto
index f6502cdfdb..7bbdc61a3d 100644
--- a/ortools/sat/sat_parameters.proto
+++ b/ortools/sat/sat_parameters.proto
@@ -24,7 +24,7 @@ option java_multiple_files = true;
 // Contains the definitions for all the sat algorithm parameters and their
 // default values.
 //
-// NEXT TAG: 329
+// NEXT TAG: 330
 message SatParameters {
   // In some context, like in a portfolio of search, it makes sense to name a
   // given parameters set for logging purpose.
@@ -715,7 +715,7 @@ message SatParameters {
 
   // Allows sharing of short glue clauses between workers.
   // Implicitly disabled if share_binary_clauses is false.
-  optional bool share_glue_clauses = 285 [default = false];
+  optional bool share_glue_clauses = 285 [default = true];
 
   // Minimize and detect subsumption of shared clauses immediately after they
   // are imported.
@@ -1282,13 +1282,15 @@ message SatParameters {
   // the number of too-easy subtrees that are generates.
   optional double shared_tree_split_min_dtime = 328 [default = 0.1];
 
-  // Whether we enumerate all solutions of a problem without objective. Note
-  // that setting this to true automatically disable some presolve reduction
-  // that can remove feasible solution. That is it has the same effect as
-  // setting keep_all_feasible_solutions_in_presolve.
+  // Whether we enumerate all solutions of a problem without objective.
   //
-  // TODO(user): Do not do that and let the user choose what behavior is best by
-  // setting keep_all_feasible_solutions_in_presolve ?
+  // WARNING:
+  // - This can be used with num_workers > 1 but then each solutions can be
+  //   found more than once, so it is up to the client to deduplicate them.
+  // - If keep_all_feasible_solutions_in_presolve is unset, we will set it to
+  //   true as otherwise, many feasible solution can just be removed by the
+  //   presolve. It is still possible to manually set this to false if one only
+  //   wants to enumerate all solutions of the presolved model.
   optional bool enumerate_all_solutions = 87 [default = false];
 
   // If true, we disable the presolve reductions that remove feasible solutions
@@ -1357,6 +1359,12 @@ message SatParameters {
   // impact the "base" solution chosen for a LNS/LS fragment.
   optional int32 solution_pool_size = 193 [default = 3];
 
+  // If solution_pool_size is <= this, we will use DP to keep a "diverse" set
+  // of solutions (the one further apart via hamming distance) in the pool.
+  // Setting this to large value might be slow, especially if your solution are
+  // large.
+  optional int32 solution_pool_diversity_limit = 329 [default = 10];
+
   // In order to not get stuck in local optima, when this is non-zero, we try to
   // also work on "older" solutions with a worse objective value so we get a
   // chance to follow a different LS/LNS trajectory.
diff --git a/ortools/sat/sat_solver.cc b/ortools/sat/sat_solver.cc
index c27cc650f5..9c1bd8f5d5 100644
--- a/ortools/sat/sat_solver.cc
+++ b/ortools/sat/sat_solver.cc
@@ -39,6 +39,7 @@
 #include "ortools/port/sysinfo.h"
 #include "ortools/sat/clause.h"
 #include "ortools/sat/drat_proof_handler.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/pb_constraint.h"
 #include "ortools/sat/restart.h"
@@ -65,6 +66,7 @@ SatSolver::SatSolver(Model* model)
     : model_(model),
       binary_implication_graph_(model->GetOrCreate<BinaryImplicationGraph>()),
       clauses_propagator_(model->GetOrCreate<ClauseManager>()),
+      enforcement_propagator_(model->GetOrCreate<EnforcementPropagator>()),
       pb_constraints_(model->GetOrCreate<PbConstraints>()),
       track_binary_clauses_(false),
       trail_(model->GetOrCreate<Trail>()),
@@ -1013,7 +1015,7 @@ SatSolver::Status SatSolver::EnqueueDecisionAndBacktrackOnConflict(
 
 bool SatSolver::EnqueueDecisionIfNotConflicting(Literal true_literal) {
   SCOPED_TIME_STAT(&stats_);
-  if (model_is_unsat_) return kUnsatTrailIndex;
+  if (model_is_unsat_) return false;
   DCHECK(PropagationIsDone());
 
   const int current_level = CurrentDecisionLevel();
@@ -1965,6 +1967,7 @@ void SatSolver::InitializePropagators() {
   propagators_.clear();
   propagators_.push_back(binary_implication_graph_);
   propagators_.push_back(clauses_propagator_);
+  propagators_.push_back(enforcement_propagator_);
   propagators_.push_back(pb_constraints_);
   for (int i = 0; i < external_propagators_.size(); ++i) {
     propagators_.push_back(external_propagators_[i]);
diff --git a/ortools/sat/sat_solver.h b/ortools/sat/sat_solver.h
index e0032bb699..28559af0b6 100644
--- a/ortools/sat/sat_solver.h
+++ b/ortools/sat/sat_solver.h
@@ -35,6 +35,7 @@
 #include "ortools/base/timer.h"
 #include "ortools/sat/clause.h"
 #include "ortools/sat/drat_proof_handler.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/model.h"
 #include "ortools/sat/pb_constraint.h"
 #include "ortools/sat/restart.h"
@@ -746,6 +747,7 @@ class SatSolver {
   // SatPropagator interface for them.
   BinaryImplicationGraph* binary_implication_graph_;
   ClauseManager* clauses_propagator_;
+  EnforcementPropagator* enforcement_propagator_;
   PbConstraints* pb_constraints_;
 
   // Ordered list of propagators used by Propagate()/Untrail().
diff --git a/ortools/sat/scheduling_cuts_test.cc b/ortools/sat/scheduling_cuts_test.cc
index 5a51c9b535..8cc568b410 100644
--- a/ortools/sat/scheduling_cuts_test.cc
+++ b/ortools/sat/scheduling_cuts_test.cc
@@ -70,7 +70,8 @@ TEST(CumulativeEnergyCutGenerator, TestCutTimeTableGenerator) {
   const IntegerVariable demand2 = model.Add(NewIntegerVariable(3, 10));
   const IntegerVariable capacity = model.Add(NewIntegerVariable(10, 10));
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper({i1, i2});
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, {i1, i2});
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({demand1, demand2}, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -132,7 +133,8 @@ TEST(CumulativeEnergyCutGenerator, SameDemand) {
   e2.coeffs.push_back(IntegerValue(7));
 
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper({i1, i2, i3});
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, {i1, i2, i3});
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({demand, demand, demand2}, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -209,7 +211,8 @@ TEST(CumulativeEnergyCutGenerator, SameDemandTimeTableGenerator) {
   const IntegerVariable capacity = model.Add(NewIntegerVariable(10, 10));
 
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper({i1, i2, i3});
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, {i1, i2, i3});
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({demand, demand, demand2}, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -263,10 +266,11 @@ TEST(CumulativeEnergyCutGenerator, DetectedPrecedence) {
       start2, AffineExpression(start2, one, size2), AffineExpression(size2),
       kNoLiteralIndex, /*add_linear_relation=*/false);
   CutGenerator disjunctive = CreateNoOverlapPrecedenceCutGenerator(
-      intervals_repository->GetOrCreateHelper({
-          i1,
-          i2,
-      }),
+      intervals_repository->GetOrCreateHelper(/*enforcement_literals=*/{},
+                                              {
+                                                  i1,
+                                                  i2,
+                                              }),
       &model);
   LinearConstraintManager* const manager =
       model.GetOrCreate<LinearConstraintManager>();
@@ -305,10 +309,11 @@ TEST(CumulativeEnergyCutGenerator, DetectedPrecedenceRev) {
       kNoLiteralIndex, /*add_linear_relation=*/false);
 
   CutGenerator disjunctive = CreateNoOverlapPrecedenceCutGenerator(
-      intervals_repository->GetOrCreateHelper({
-          i2,
-          i1,
-      }),
+      intervals_repository->GetOrCreateHelper(/*enforcement_literals=*/{},
+                                              {
+                                                  i2,
+                                                  i1,
+                                              }),
       &model);
   LinearConstraintManager* const manager =
       model.GetOrCreate<LinearConstraintManager>();
@@ -347,10 +352,11 @@ TEST(CumulativeEnergyCutGenerator, DisjunctionOnStart) {
       kNoLiteralIndex, /*add_linear_relation=*/false);
 
   CutGenerator disjunctive = CreateNoOverlapPrecedenceCutGenerator(
-      intervals_repository->GetOrCreateHelper({
-          i2,
-          i1,
-      }),
+      intervals_repository->GetOrCreateHelper(/*enforcement_literals=*/{},
+                                              {
+                                                  i2,
+                                                  i1,
+                                              }),
       &model);
   LinearConstraintManager* const manager =
       model.GetOrCreate<LinearConstraintManager>();
@@ -397,7 +403,8 @@ TEST(ComputeMinSumOfEndMinsTest, CombinationOf3) {
       /*add_linear_relation=*/false);
 
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper({i1, i2, i3});
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, {i1, i2, i3});
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({two, one, one}, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -448,7 +455,8 @@ TEST(ComputeMinSumOfEndMinsTest, CombinationOf3ConstraintStart) {
       /*add_linear_relation=*/false);
 
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper({i1, i2, i3});
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, {i1, i2, i3});
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({two, one, one}, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -500,7 +508,8 @@ TEST(ComputeMinSumOfEndMinsTest, Abort) {
       /*add_linear_relation=*/false);
 
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper({i1, i2, i3});
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, {i1, i2, i3});
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({two, one, one}, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -550,7 +559,8 @@ TEST(ComputeMinSumOfEndMinsTest, Infeasible) {
       /*add_linear_relation=*/false);
 
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper({i1, i2, i3});
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, {i1, i2, i3});
   SchedulingDemandHelper* demands_helper =
       new SchedulingDemandHelper({two, one, one}, helper, &model);
   model.TakeOwnership(demands_helper);
@@ -610,7 +620,8 @@ double ExactMakespanBruteForce(absl::Span<const int> sizes,
   }
 
   SchedulingConstraintHelper* helper =
-      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(intervals);
+      model.GetOrCreate<IntervalsRepository>()->GetOrCreateHelper(
+          /*enforcement_literals=*/{}, intervals);
   std::vector<AffineExpression> demands_expr;
   for (int i = 0; i < demands.size(); ++i) {
     demands_expr.push_back(AffineExpression(demands[i]));
diff --git a/ortools/sat/scheduling_helpers.cc b/ortools/sat/scheduling_helpers.cc
index 7016ed3280..96936a911a 100644
--- a/ortools/sat/scheduling_helpers.cc
+++ b/ortools/sat/scheduling_helpers.cc
@@ -14,7 +14,6 @@
 #include "ortools/sat/scheduling_helpers.h"
 
 #include <algorithm>
-#include <cstdint>
 #include <functional>
 #include <string>
 #include <utility>
@@ -24,6 +23,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/types/span.h"
 #include "ortools/base/logging.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/implied_bounds.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
@@ -46,10 +46,13 @@ SchedulingConstraintHelper::SchedulingConstraintHelper(
     : model_(model),
       sat_solver_(model->GetOrCreate<SatSolver>()),
       assignment_(sat_solver_->Assignment()),
+      trail_(model->GetOrCreate<Trail>()),
       integer_trail_(model->GetOrCreate<IntegerTrail>()),
       watcher_(model->GetOrCreate<GenericLiteralWatcher>()),
       linear2_bounds_(model->GetOrCreate<Linear2Bounds>()),
       root_level_lin2_bounds_(model->GetOrCreate<RootLevelLinear2Bounds>()),
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()),
+      enforcement_id_(-1),
       starts_(std::move(starts)),
       ends_(std::move(ends)),
       sizes_(std::move(sizes)),
@@ -86,9 +89,12 @@ SchedulingConstraintHelper::SchedulingConstraintHelper(int num_tasks,
     : model_(model),
       sat_solver_(model->GetOrCreate<SatSolver>()),
       assignment_(sat_solver_->Assignment()),
+      trail_(model->GetOrCreate<Trail>()),
       integer_trail_(model->GetOrCreate<IntegerTrail>()),
       linear2_bounds_(model->GetOrCreate<Linear2Bounds>()),
       root_level_lin2_bounds_(model->GetOrCreate<RootLevelLinear2Bounds>()),
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()),
+      enforcement_id_(-1),
       capacity_(num_tasks),
       cached_size_min_(new IntegerValue[capacity_]),
       cached_start_min_(new IntegerValue[capacity_]),
@@ -101,7 +107,13 @@ SchedulingConstraintHelper::SchedulingConstraintHelper(int num_tasks,
   CHECK_EQ(NumTasks(), num_tasks);
 }
 
+bool SchedulingConstraintHelper::IsEnforced() const {
+  return enforcement_helper_.Status(enforcement_id_) ==
+         EnforcementStatus::IS_ENFORCED;
+}
+
 bool SchedulingConstraintHelper::Propagate() {
+  if (!IsEnforced()) return true;
   recompute_all_cache_ = true;
   for (const int id : propagator_ids_) watcher_->CallOnNextPropagate(id);
   return true;
@@ -109,12 +121,15 @@ bool SchedulingConstraintHelper::Propagate() {
 
 bool SchedulingConstraintHelper::IncrementalPropagate(
     const std::vector<int>& watch_indices) {
+  if (!IsEnforced()) return true;
   for (const int t : watch_indices) recompute_cache_.Set(t);
   for (const int id : propagator_ids_) watcher_->CallOnNextPropagate(id);
   return true;
 }
 
-void SchedulingConstraintHelper::RegisterWith(GenericLiteralWatcher* watcher) {
+void SchedulingConstraintHelper::RegisterWith(
+    GenericLiteralWatcher* watcher,
+    absl::Span<const Literal> enforcement_literals) {
   const int id = watcher->Register(this);
   const int num_tasks = starts_.size();
   for (int t = 0; t < num_tasks; ++t) {
@@ -129,10 +144,12 @@ void SchedulingConstraintHelper::RegisterWith(GenericLiteralWatcher* watcher) {
     // Note that IncrementalPropagate() will do nothing if this is the only
     // change except waking up registered propagators.
     if (!IsPresent(t) && !IsAbsent(t)) {
-      watcher_->WatchLiteral(Literal(reason_for_presence_[t]), id);
+      watcher->WatchLiteral(Literal(reason_for_presence_[t]), id);
     }
   }
   watcher->SetPropagatorPriority(id, 0);
+  enforcement_id_ =
+      enforcement_helper_.Register(enforcement_literals, watcher, id);
 }
 
 bool SchedulingConstraintHelper::UpdateCachedValues(int t) {
@@ -154,19 +171,19 @@ bool SchedulingConstraintHelper::UpdateCachedValues(int t) {
 
   // Detect first if we have a conflict using the relation start + size = end.
   if (dmax < 0) {
-    ClearReason();
+    ResetReason();
     AddSizeMaxReason(t, dmax);
     return PushTaskAbsence(t);
   }
   if (smin + dmin - emax > 0) {
-    ClearReason();
+    ResetReason();
     AddStartMinReason(t, smin);
     AddSizeMinReason(t, dmin);
     AddEndMaxReason(t, emax);
     return PushTaskAbsence(t);
   }
   if (smax + dmax - emin < 0) {
-    ClearReason();
+    ResetReason();
     AddStartMaxReason(t, smax);
     AddSizeMaxReason(t, dmax);
     AddEndMinReason(t, emin);
@@ -451,6 +468,24 @@ SchedulingConstraintHelper::TaskByIncreasingShiftedStartMin() {
   return task_by_increasing_shifted_start_min_;
 }
 
+absl::Span<const CachedTaskBounds>
+SchedulingConstraintHelper::TaskByIncreasingNegatedShiftedEndMax() {
+  if (recompute_negated_shifted_end_max_) {
+    recompute_negated_shifted_end_max_ = false;
+    bool is_sorted = true;
+    IntegerValue previous = kMinIntegerValue;
+    for (CachedTaskBounds& ref : task_by_negated_shifted_end_max_) {
+      ref.time = -ShiftedEndMax(ref.task_index);
+      is_sorted = is_sorted && ref.time >= previous;
+      previous = ref.time;
+    }
+    if (is_sorted) return task_by_negated_shifted_end_max_;
+    IncrementalSort(task_by_negated_shifted_end_max_.begin(),
+                    task_by_negated_shifted_end_max_.end());
+  }
+  return task_by_negated_shifted_end_max_;
+}
+
 // TODO(user): Avoid recomputing it if nothing changed.
 const std::vector<SchedulingConstraintHelper::ProfileEvent>&
 SchedulingConstraintHelper::GetEnergyProfile() {
@@ -477,10 +512,17 @@ SchedulingConstraintHelper::GetEnergyProfile() {
   return energy_profile_;
 }
 
+bool SchedulingConstraintHelper::TaskIsBeforeOrIsOverlapping(int before,
+                                                             int after) {
+  const auto [expr, ub] =
+      EncodeDifferenceLowerThan(starts_[before], ends_[after], -1);
+  return linear2_bounds_->UpperBound(expr) <= ub;
+}
+
 void SchedulingConstraintHelper::AddReasonForBeingBeforeAssumingNoOverlap(
     int before, int after) {
-  AddOtherReason(before);
-  AddOtherReason(after);
+  FlagItemAsUsedInReason(before);
+  FlagItemAsUsedInReason(after);
 
   // We compute this as an optimization, since for fixed sizes all linear2
   // options are equivalent.
@@ -576,15 +618,15 @@ void SchedulingConstraintHelper::AddReasonForBeingBeforeAssumingNoOverlap(
 }
 
 bool SchedulingConstraintHelper::PushIntegerLiteral(IntegerLiteral lit) {
-  CHECK(other_helper_ == nullptr);
+  CHECK(extra_explanation_callback_ == nullptr);
   return integer_trail_->Enqueue(lit, literal_reason_, integer_reason_);
 }
 
 bool SchedulingConstraintHelper::PushIntegerLiteralIfTaskPresent(
     int t, IntegerLiteral lit) {
   if (IsAbsent(t)) return true;
-  AddOtherReason(t);
-  ImportOtherReasons();
+  FlagItemAsUsedInReason(t);
+  RunCallbackIfSet();
   if (IsOptional(t)) {
     return integer_trail_->ConditionalEnqueue(
         PresenceLiteral(t), lit, &literal_reason_, &integer_reason_);
@@ -635,13 +677,13 @@ bool SchedulingConstraintHelper::PushTaskAbsence(int t) {
   if (IsAbsent(t)) return true;
   if (!IsOptional(t)) return ReportConflict();
 
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
 
   if (IsPresent(t)) {
     literal_reason_.push_back(Literal(reason_for_presence_[t]).Negated());
     return ReportConflict();
   }
-  ImportOtherReasons();
+  RunCallbackIfSet();
   integer_trail_->EnqueueLiteral(Literal(reason_for_presence_[t]).Negated(),
                                  literal_reason_, integer_reason_);
   return true;
@@ -651,20 +693,65 @@ bool SchedulingConstraintHelper::PushTaskPresence(int t) {
   DCHECK_NE(reason_for_presence_[t], kNoLiteralIndex);
   DCHECK(!IsPresent(t));
 
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
 
   if (IsAbsent(t)) {
     literal_reason_.push_back(Literal(reason_for_presence_[t]));
     return ReportConflict();
   }
-  ImportOtherReasons();
+  RunCallbackIfSet();
   integer_trail_->EnqueueLiteral(Literal(reason_for_presence_[t]),
                                  literal_reason_, integer_reason_);
   return true;
 }
 
+bool SchedulingConstraintHelper::PushTaskOrderWhenPresent(int t_before,
+                                                          int t_after) {
+  CHECK_NE(t_before, t_after);
+  if (IsAbsent(t_before)) return true;
+  if (IsAbsent(t_after)) return true;
+  if (!IsPresent(t_before) && !IsPresent(t_after)) return true;
+
+  const auto [expr, rhs] =
+      EncodeDifferenceLowerThan(ends_[t_before], starts_[t_after], 0);
+  const auto status = linear2_bounds_->GetStatus(expr, kMinIntegerValue, rhs);
+
+  if (status == RelationStatus::IS_TRUE) return true;
+
+  if (status == RelationStatus::IS_FALSE) {
+    LinearExpression2 negated_expr = expr;
+    negated_expr.Negate();
+    linear2_bounds_->AddReasonForUpperBoundLowerThan(
+        negated_expr, -rhs - 1, &literal_reason_, &integer_reason_);
+    if (!IsPresent(t_before)) {
+      AddPresenceReason(t_after);
+      return PushTaskAbsence(t_before);
+    } else if (!IsPresent(t_after)) {
+      AddPresenceReason(t_before);
+      return PushTaskAbsence(t_after);
+    } else {
+      AddPresenceReason(t_before);
+      AddPresenceReason(t_after);
+      return ReportConflict();
+    }
+  }
+
+  if (!IsPresent(t_before) || !IsPresent(t_after)) return true;
+
+  AddPresenceReason(t_before);
+  AddPresenceReason(t_after);
+
+  FlagItemAsUsedInReason(t_before);
+  FlagItemAsUsedInReason(t_after);
+  RunCallbackIfSet();
+
+  return linear2_bounds_->EnqueueLowerOrEqual(expr, rhs, literal_reason_,
+                                              integer_reason_);
+}
+
 bool SchedulingConstraintHelper::ReportConflict() {
-  ImportOtherReasons();
+  RunCallbackIfSet();
+
   return integer_trail_->ReportConflict(literal_reason_, integer_reason_);
 }
 
@@ -675,20 +762,22 @@ void SchedulingConstraintHelper::WatchAllTasks(int id) {
   propagator_ids_.push_back(id);
 }
 
-void SchedulingConstraintHelper::AddOtherReason(int t) {
-  if (other_helper_ == nullptr || already_added_to_other_reasons_[t]) return;
-  already_added_to_other_reasons_[t] = true;
-  const int mapped_t = map_to_other_helper_[t];
-  other_helper_->AddStartMaxReason(mapped_t, event_for_other_helper_);
-  other_helper_->AddEndMinReason(mapped_t, event_for_other_helper_ + 1);
+void SchedulingConstraintHelper::FlagItemAsUsedInReason(int t) {
+  if (extra_explanation_callback_ == nullptr) {
+    return;
+  }
+  used_items_for_reason_.Set(t);
 }
 
-void SchedulingConstraintHelper::ImportOtherReasons() {
-  if (other_helper_ != nullptr) ImportOtherReasons(*other_helper_);
+void SchedulingConstraintHelper::RunCallbackIfSet() {
+  if (extra_explanation_callback_ == nullptr) return;
+  extra_explanation_callback_(used_items_for_reason_.PositionsSetAtLeastOnce(),
+                              &literal_reason_, &integer_reason_);
 }
 
-void SchedulingConstraintHelper::ImportOtherReasons(
+void SchedulingConstraintHelper::ImportReasonsFromOther(
     const SchedulingConstraintHelper& other_helper) {
+  CHECK(other_helper.extra_explanation_callback_ == nullptr);
   literal_reason_.insert(literal_reason_.end(),
                          other_helper.literal_reason_.begin(),
                          other_helper.literal_reason_.end());
@@ -872,7 +961,7 @@ bool SchedulingDemandHelper::DecreaseEnergyMax(int t, IntegerValue value) {
         if (assignment_.LiteralIsTrue(lit)) {
           // Task must be absent.
           if (helper_->PresenceLiteral(t) != lit) {
-            helper_->MutableLiteralReason()->push_back(lit.Negated());
+            helper_->AddLiteralReason(lit.Negated());
           }
           return helper_->PushTaskAbsence(t);
         }
@@ -894,7 +983,7 @@ bool SchedulingDemandHelper::DecreaseEnergyMax(int t, IntegerValue value) {
 void SchedulingDemandHelper::AddDemandMinReason(int t) {
   DCHECK_LT(t, demands_.size());
   if (demands_[t].var != kNoIntegerVariable) {
-    helper_->MutableIntegerReason()->push_back(
+    helper_->AddIntegerReason(
         integer_trail_->LowerBoundAsLiteral(demands_[t].var));
   }
 }
@@ -903,8 +992,7 @@ void SchedulingDemandHelper::AddDemandMinReason(int t,
                                                 IntegerValue min_demand) {
   DCHECK_LT(t, demands_.size());
   if (demands_[t].var != kNoIntegerVariable) {
-    helper_->MutableIntegerReason()->push_back(
-        demands_[t].GreaterOrEqual(min_demand));
+    helper_->AddIntegerReason(demands_[t].GreaterOrEqual(min_demand));
   }
 }
 
@@ -912,16 +1000,16 @@ void SchedulingDemandHelper::AddEnergyMinReason(int t) {
   // We prefer these reason in order.
   const IntegerValue value = cached_energies_min_[t];
   if (DecomposedEnergyMin(t) >= value) {
-    auto* reason = helper_->MutableLiteralReason();
-    const int old_size = reason->size();
     for (const auto [lit, fixed_size, fixed_demand] : decomposed_energies_[t]) {
       if (assignment_.LiteralIsTrue(lit)) {
-        reason->resize(old_size);
-        reason->push_back(lit.Negated());
+        helper_->AddLiteralReason(lit.Negated());
         return;
-      } else if (fixed_size * fixed_demand < value &&
-                 assignment_.LiteralIsFalse(lit)) {
-        reason->push_back(lit);
+      }
+    }
+    for (const auto [lit, fixed_size, fixed_demand] : decomposed_energies_[t]) {
+      if (fixed_size * fixed_demand < value &&
+          assignment_.LiteralIsFalse(lit)) {
+        helper_->AddLiteralReason(lit);
       }
     }
   } else if (SimpleEnergyMin(t) >= value) {
@@ -1011,17 +1099,15 @@ void SchedulingDemandHelper::AddEnergyMinInWindowReason(
   helper_->AddEndMinReason(t, end_min);
   helper_->AddEndMaxReason(t, end_max);
 
-  auto* literal_reason = helper_->MutableLiteralReason();
-  const int old_size = literal_reason->size();
-
   DCHECK(!decomposed_energies_[t].empty());
   for (const auto [lit, fixed_size, fixed_demand] : decomposed_energies_[t]) {
     // Should be the same in most cases.
     if (assignment_.LiteralIsTrue(lit)) {
-      literal_reason->resize(old_size);
-      literal_reason->push_back(lit.Negated());
+      helper_->AddLiteralReason(lit.Negated());
       return;
     }
+  }
+  for (const auto [lit, fixed_size, fixed_demand] : decomposed_energies_[t]) {
     if (assignment_.LiteralIsFalse(lit)) {
       const IntegerValue alt_em = std::max(end_min, start_min + fixed_size);
       const IntegerValue alt_sm = std::min(start_max, end_max - fixed_size);
@@ -1029,11 +1115,30 @@ void SchedulingDemandHelper::AddEnergyMinInWindowReason(
           fixed_demand *
           std::min({alt_em - window_start, window_end - alt_sm, fixed_size});
       if (energy_min >= actual_energy_min) continue;
-      literal_reason->push_back(lit);
+      helper_->AddLiteralReason(lit);
     }
   }
 }
 
+void SchedulingConstraintHelper::AddReasonForUpperBoundLowerThan(
+    LinearExpression2 expr, IntegerValue ub) {
+  linear2_bounds_->AddReasonForUpperBoundLowerThan(expr, ub, &literal_reason_,
+                                                   &integer_reason_);
+}
+
+void SchedulingConstraintHelper::AppendAndResetReason(
+    std::vector<IntegerLiteral>* integer_reason,
+    std::vector<Literal>* literal_reason) {
+  RunCallbackIfSet();
+  for (const IntegerLiteral l : integer_reason_) {
+    integer_reason->push_back(l);
+  }
+  for (const Literal l : literal_reason_) {
+    literal_reason->push_back(l);
+  }
+  ResetReason();
+}
+
 void AddIntegerVariableFromIntervals(const SchedulingConstraintHelper* helper,
                                      Model* model,
                                      std::vector<IntegerVariable>* vars,
diff --git a/ortools/sat/scheduling_helpers.h b/ortools/sat/scheduling_helpers.h
index 2d1daa3876..ff281d3603 100644
--- a/ortools/sat/scheduling_helpers.h
+++ b/ortools/sat/scheduling_helpers.h
@@ -16,14 +16,18 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/base/attributes.h"
 #include "absl/log/check.h"
 #include "absl/types/span.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/implied_bounds.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
@@ -101,6 +105,9 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   // to fetch the maximum possible number of task at construction.
   SchedulingConstraintHelper(int num_tasks, Model* model);
 
+  // Returns true if and only if all the enforcement literals are true.
+  bool IsEnforced() const;
+
   // This is a propagator so we can "cache" all the intervals relevant
   // information. This gives good speedup. Note however that the info is stale
   // except if a bound was pushed by this helper or if this was called. We run
@@ -108,10 +115,16 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   // beginning of each Propagate() call of the classes using this.
   bool Propagate() final;
   bool IncrementalPropagate(const std::vector<int>& watch_indices) final;
-  void RegisterWith(GenericLiteralWatcher* watcher);
+  void RegisterWith(GenericLiteralWatcher* watcher,
+                    absl::Span<const Literal> enforcement_literals);
+
+  // Sets the enforcement ID without registering this propagator with a watcher.
+  // This is used by NoOverlap2DConstraintHelper, which registers itself but
+  // does not register its x and y SchedulingConstraintHelpers.
+  void SetEnforcementId(EnforcementId id) { enforcement_id_ = id; }
 
   // Resets the class to the same state as if it was constructed with
-  // the given subset of tasks from other.
+  // the given subset of tasks from other (and the same enforcement literals).
   ABSL_MUST_USE_RESULT bool ResetFromSubset(
       const SchedulingConstraintHelper& other, absl::Span<const int> tasks);
 
@@ -225,6 +238,8 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   // Note: this is different from the mandatory part of an interval.
   IntegerValue GetMinOverlap(int t, IntegerValue start, IntegerValue end) const;
 
+  bool TaskIsBeforeOrIsOverlapping(int before, int after);
+
   // Returns a string with the current task bounds.
   std::string TaskDebugString(int t) const;
 
@@ -241,6 +256,7 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   absl::Span<const TaskTime> TaskByIncreasingEndMin();
 
   absl::Span<const CachedTaskBounds> TaskByIncreasingShiftedStartMin();
+  absl::Span<const CachedTaskBounds> TaskByIncreasingNegatedShiftedEndMax();
 
   // Returns a sorted vector where each task appear twice, the first occurrence
   // is at size (end_min - size_min) and the second one at (end_min).
@@ -261,8 +277,9 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   };
   const std::vector<ProfileEvent>& GetEnergyProfile();
 
-  // Functions to clear and then set the current reason.
-  void ClearReason();
+  // Functions to reset and then set the current reason.
+  void ResetReason();
+  void ImportReasonsFromOther(const SchedulingConstraintHelper& other_helper);
   void AddPresenceReason(int t);
   void AddAbsenceReason(int t);
   void AddSizeMinReason(int t);
@@ -277,6 +294,9 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   void AddEnergyAfterReason(int t, IntegerValue energy_min, IntegerValue time);
   void AddEnergyMinInIntervalReason(int t, IntegerValue min, IntegerValue max);
 
+  void AddLiteralReason(Literal l);
+  void AddIntegerReason(IntegerLiteral l);
+
   // Adds the reason why the task "before" must be before task "after", in
   // the sense that "after" can only start at the same time or later than the
   // task "before" ends.
@@ -294,12 +314,10 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   // complex cases where Start() and End() do not use the same integer variable.
   void AddReasonForBeingBeforeAssumingNoOverlap(int before, int after);
 
-  // It is also possible to directly manipulates the underlying reason vectors
-  // that will be used when pushing something.
-  std::vector<Literal>* MutableLiteralReason() { return &literal_reason_; }
-  std::vector<IntegerLiteral>* MutableIntegerReason() {
-    return &integer_reason_;
-  }
+  void AddReasonForUpperBoundLowerThan(LinearExpression2 expr, IntegerValue ub);
+
+  void AppendAndResetReason(std::vector<IntegerLiteral>* integer_reason,
+                            std::vector<Literal>* literal_reason);
 
   // Push something using the current reason. Note that IncreaseStartMin() will
   // also increase the end-min, and DecreaseEndMax() will also decrease the
@@ -321,6 +339,11 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   ABSL_MUST_USE_RESULT bool PushIntegerLiteralIfTaskPresent(int t,
                                                             IntegerLiteral lit);
 
+  // Push that t_before must end at the same time or before t_after starts.
+  // This function does the correct thing if t_before or t_after are optional
+  // and their presence is unknown. Returns false on conflict.
+  ABSL_MUST_USE_RESULT bool PushTaskOrderWhenPresent(int t_before, int t_after);
+
   absl::Span<const AffineExpression> Starts() const { return starts_; }
   absl::Span<const AffineExpression> Ends() const { return ends_; }
   absl::Span<const AffineExpression> Sizes() const { return sizes_; }
@@ -344,30 +367,28 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   // in this class change. Note that we do not watch size max though.
   void WatchAllTasks(int id);
 
-  // Manages the other helper (used by the diffn constraint).
+  // Sometimes, typically for no_overlap_2d, we can use the variables that are
+  // fixed at current decision level to define a scheduling sub-problem. For
+  // example, if all the x coordinates are fixed and the intervals overlap on
+  // the x axis, we can just run the disjunction propagators on the y
+  // coordinates.
   //
-  // For each interval appearing in a reason on this helper, another reason
-  // will be added. This other reason specifies that on the other helper, the
-  // corresponding interval overlaps 'event'.
-  void SetOtherHelper(SchedulingConstraintHelper* other_helper,
-                      absl::Span<const int> map_to_other_helper,
-                      IntegerValue event) {
-    CHECK(other_helper != nullptr);
-    other_helper_ = other_helper;
-    map_to_other_helper_ = map_to_other_helper;
-    event_for_other_helper_ = event;
+  // To be able to run scheduling propagators on a sub-problem, we can register
+  // a callback that before any explanation or when one of the bounds of an item
+  // is pushed. The callback will get the list of all items that participated in
+  // the reason and/or the bound push and allows the caller to introduce any new
+  // literals needed to make sure that the conditions making it a sub-problem
+  // hold.
+  void SetExtraExplanationForItemCallback(
+      std::function<void(absl::Span<const int> items,
+                         std::vector<Literal>* reason,
+                         std::vector<IntegerLiteral>* integer_reason)>
+          extra_explanation_callback) {
+    used_items_for_reason_.ClearAndResize(
+        extra_explanation_callback == nullptr ? 0 : capacity_);
+    extra_explanation_callback_ = std::move(extra_explanation_callback);
   }
 
-  bool HasOtherHelper() const { return other_helper_ != nullptr; }
-
-  void ClearOtherHelper() { other_helper_ = nullptr; }
-
-  // Adds to this helper reason all the explanation of the other helper.
-  // This checks that other_helper_ is null.
-  //
-  // This is used in the 2D energetic reasoning in the diffn constraint.
-  void ImportOtherReasons(const SchedulingConstraintHelper& other_helper);
-
   // TODO(user): Change the propagation loop code so that we don't stop
   // pushing in the middle of the propagation as more advanced propagator do
   // not handle this correctly.
@@ -377,6 +398,11 @@ class SchedulingConstraintHelper : public PropagatorInterface {
     return sat_solver_->CurrentDecisionLevel();
   }
 
+  // This increase as soon as we propagate something.
+  int64_t PropagationTimestamp() const {
+    return integer_trail_->timestamp() + trail_->NumberOfEnqueues();
+  }
+
  private:
   // Tricky: when a task is optional, it is possible it size min is negative,
   // but we know that if a task is present, its size should be >= 0. So in the
@@ -400,22 +426,22 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   // Internal function for IncreaseStartMin()/DecreaseEndMax().
   bool PushIntervalBound(int t, IntegerLiteral lit);
 
-  // This will be called on any interval that is part of a reason or
-  // a bound push. Since the last call to ClearReason(), for each unique
-  // t, we will add once to other_helper_ the reason for t containing
-  // the point event_for_other_helper_.
-  void AddOtherReason(int t);
+  // This should be called every time a task that is part of a reason or a
+  // bound push to update the items_in_reason_ vector.
+  void FlagItemAsUsedInReason(int t);
 
-  // Import the reasons on the other helper into this helper.
-  void ImportOtherReasons();
+  void RunCallbackIfSet();
 
   Model* model_;
   SatSolver* sat_solver_;
   const VariablesAssignment& assignment_;
+  Trail* trail_;
   IntegerTrail* integer_trail_;
   GenericLiteralWatcher* watcher_;
   Linear2Bounds* linear2_bounds_;
   RootLevelLinear2Bounds* root_level_lin2_bounds_;
+  EnforcementHelper& enforcement_helper_;
+  EnforcementId enforcement_id_;
 
   // The current direction of time, true for forward, false for backward.
   bool current_time_direction_ = true;
@@ -484,11 +510,11 @@ class SchedulingConstraintHelper : public PropagatorInterface {
   std::vector<Literal> literal_reason_;
   std::vector<IntegerLiteral> integer_reason_;
 
-  // Optional 'proxy' helper used in the diffn constraint.
-  SchedulingConstraintHelper* other_helper_ = nullptr;
-  absl::Span<const int> map_to_other_helper_;
-  IntegerValue event_for_other_helper_;
-  std::vector<bool> already_added_to_other_reasons_;
+  std::function<void(absl::Span<const int> items, std::vector<Literal>*,
+                     std::vector<IntegerLiteral>*)>
+      extra_explanation_callback_ = nullptr;
+
+  SparseBitset<int> used_items_for_reason_;
 
   // List of watcher to "wake-up" each time one of the task bounds changes.
   std::vector<int> propagator_ids_;
@@ -670,18 +696,16 @@ inline bool SchedulingConstraintHelper::IsAbsent(LiteralIndex lit) const {
   return assignment_.LiteralIsFalse(Literal(lit));
 }
 
-inline void SchedulingConstraintHelper::ClearReason() {
+inline void SchedulingConstraintHelper::ResetReason() {
   integer_reason_.clear();
   literal_reason_.clear();
-  if (other_helper_) {
-    other_helper_->ClearReason();
-    already_added_to_other_reasons_.assign(NumTasks(), false);
-  }
+  enforcement_helper_.AddEnforcementReason(enforcement_id_, &literal_reason_);
+  used_items_for_reason_.ClearAndResize(capacity_);
 }
 
 inline void SchedulingConstraintHelper::AddPresenceReason(int t) {
   DCHECK(IsPresent(t));
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   if (reason_for_presence_[t] != kNoLiteralIndex) {
     literal_reason_.push_back(Literal(reason_for_presence_[t]).Negated());
   }
@@ -689,7 +713,7 @@ inline void SchedulingConstraintHelper::AddPresenceReason(int t) {
 
 inline void SchedulingConstraintHelper::AddAbsenceReason(int t) {
   DCHECK(IsAbsent(t));
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   if (reason_for_presence_[t] != kNoLiteralIndex) {
     literal_reason_.push_back(Literal(reason_for_presence_[t]));
   }
@@ -728,7 +752,7 @@ inline void SchedulingConstraintHelper::AddGenericReason(
 
 inline void SchedulingConstraintHelper::AddSizeMinReason(
     int t, IntegerValue lower_bound) {
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   DCHECK(!IsAbsent(t));
   if (lower_bound <= 0) return;
   AddGenericReason(sizes_[t].Negated(), -lower_bound, minus_ends_[t],
@@ -737,28 +761,28 @@ inline void SchedulingConstraintHelper::AddSizeMinReason(
 
 inline void SchedulingConstraintHelper::AddSizeMaxReason(
     int t, IntegerValue upper_bound) {
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   DCHECK(!IsAbsent(t));
   AddGenericReason(sizes_[t], upper_bound, ends_[t], minus_starts_[t]);
 }
 
 inline void SchedulingConstraintHelper::AddStartMinReason(
     int t, IntegerValue lower_bound) {
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   DCHECK(!IsAbsent(t));
   AddGenericReason(minus_starts_[t], -lower_bound, minus_ends_[t], sizes_[t]);
 }
 
 inline void SchedulingConstraintHelper::AddStartMaxReason(
     int t, IntegerValue upper_bound) {
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   DCHECK(!IsAbsent(t));
   AddGenericReason(starts_[t], upper_bound, ends_[t], NegatedSizeOrZero(t));
 }
 
 inline void SchedulingConstraintHelper::AddEndMinReason(
     int t, IntegerValue lower_bound) {
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   DCHECK(!IsAbsent(t));
   AddGenericReason(minus_ends_[t], -lower_bound, minus_starts_[t],
                    NegatedSizeOrZero(t));
@@ -766,7 +790,7 @@ inline void SchedulingConstraintHelper::AddEndMinReason(
 
 inline void SchedulingConstraintHelper::AddEndMaxReason(
     int t, IntegerValue upper_bound) {
-  AddOtherReason(t);
+  FlagItemAsUsedInReason(t);
   DCHECK(!IsAbsent(t));
   AddGenericReason(ends_[t], upper_bound, starts_[t], sizes_[t]);
 }
@@ -803,6 +827,14 @@ inline void SchedulingConstraintHelper::AddEnergyMinInIntervalReason(
   AddSizeMinReason(t, energy_min);
 }
 
+inline void SchedulingConstraintHelper::AddLiteralReason(Literal l) {
+  literal_reason_.push_back(l);
+}
+
+inline void SchedulingConstraintHelper::AddIntegerReason(IntegerLiteral l) {
+  integer_reason_.push_back(l);
+}
+
 // Cuts helpers.
 enum IntegerVariablesToAddMask {
   kStart = 1 << 0,
diff --git a/ortools/sat/scheduling_helpers_test.cc b/ortools/sat/scheduling_helpers_test.cc
index 526b195d08..e6245037d2 100644
--- a/ortools/sat/scheduling_helpers_test.cc
+++ b/ortools/sat/scheduling_helpers_test.cc
@@ -43,7 +43,7 @@ TEST(SchedulingConstraintHelperTest, PushConstantBoundWithOptionalIntervals) {
       repo->CreateInterval(start, end, size, presence2.Index(), false);
 
   SchedulingConstraintHelper* helper =
-      repo->GetOrCreateHelper({inter1, inter2});
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {inter1, inter2});
 
   EXPECT_TRUE(helper->IncreaseStartMin(1, IntegerValue(20)));
   EXPECT_FALSE(model.Get(Value(presence2)));
@@ -61,7 +61,8 @@ TEST(SchedulingDemandHelperTest, EnergyInWindow) {
 
   const AffineExpression demand(model.Add(NewIntegerVariable(2, 10)));
 
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({inter});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {inter});
   SchedulingDemandHelper demands_helper({demand}, helper, &model);
   demands_helper.CacheAllEnergyValues();
   EXPECT_EQ(demands_helper.EnergyMin(0), IntegerValue(4));
@@ -93,7 +94,8 @@ TEST(SchedulingDemandHelperTest, EnergyInWindowTakeIntoAccountWindowSize) {
 
   const AffineExpression demand(model.Add(NewIntegerVariable(6, 10)));
 
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({inter});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {inter});
   SchedulingDemandHelper demands_helper({demand}, helper, &model);
   demands_helper.CacheAllEnergyValues();
 
@@ -121,7 +123,8 @@ TEST(SchedulingDemandHelperTest, LinearizedDemandWithAffineExpression) {
   const AffineExpression demand(
       AffineExpression(model.Add(NewIntegerVariable(2, 10)), 2, 5));
 
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({inter});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {inter});
   SchedulingDemandHelper demands_helper({demand}, helper, &model);
   demands_helper.CacheAllEnergyValues();
 
@@ -142,7 +145,8 @@ TEST(SchedulingDemandHelperTest, LinearizedDemandWithDecomposedEnergy) {
 
   const AffineExpression demand(model.Add(NewIntegerVariable(2, 10)));
 
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({inter});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {inter});
   SchedulingDemandHelper demands_helper({demand}, helper, &model);
   demands_helper.CacheAllEnergyValues();
   EXPECT_EQ(demands_helper.EnergyMin(0), IntegerValue(4));
@@ -179,7 +183,8 @@ TEST(SchedulingDemandHelperTest, FilteredDecomposedEnergy) {
 
   const AffineExpression demand(model.Add(NewIntegerVariable(2, 10)));
 
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({inter});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {inter});
   SchedulingDemandHelper demands_helper({demand}, helper, &model);
   demands_helper.CacheAllEnergyValues();
   EXPECT_EQ(demands_helper.EnergyMin(0), IntegerValue(4));
@@ -222,7 +227,8 @@ TEST(SchedulingDemandHelperTest, FilteredDecomposedEnergyWithFalseLiteral) {
 
   const AffineExpression demand(model.Add(NewIntegerVariable(2, 10)));
 
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper({inter});
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, {inter});
   SchedulingDemandHelper demands_helper({demand}, helper, &model);
   demands_helper.CacheAllEnergyValues();
   EXPECT_EQ(demands_helper.EnergyMin(0), IntegerValue(4));
diff --git a/ortools/sat/solution_crush.cc b/ortools/sat/solution_crush.cc
index cad64f1252..e80da65753 100644
--- a/ortools/sat/solution_crush.cc
+++ b/ortools/sat/solution_crush.cc
@@ -443,6 +443,13 @@ void SolutionCrush::SetReservoirCircuitVars(
   for (int i = 0; i < active_event_values.size(); ++i) {
     active_event_value_index[active_event_values[i].index] = i;
   }
+  // Set the level vars of inactive events to an arbitrary value.
+  for (int i = 0; i < num_events; ++i) {
+    if (active_event_value_index[i] == -1) {
+      SetVarValue(level_vars[i], min_level);
+    }
+  }
+
   for (int i = 0; i < circuit.literals_size(); ++i) {
     const int head = circuit.heads(i);
     const int tail = circuit.tails(i);
diff --git a/ortools/sat/stat_tables.cc b/ortools/sat/stat_tables.cc
index 4203822526..3d0c5b8f1a 100644
--- a/ortools/sat/stat_tables.cc
+++ b/ortools/sat/stat_tables.cc
@@ -61,7 +61,7 @@ SharedStatTables::SharedStatTables() {
                              "Overflow", "Bad", "BadScaling"});
 
   lp_manager_table_.push_back({"Lp pool", "Constraints", "Updates", "Simplif",
-                               "Merged", "Shortened", "Split", "Strenghtened",
+                               "Merged", "Shortened", "Split", "Strengthened",
                                "Cuts/Call"});
 
   lns_table_.push_back(
@@ -129,7 +129,7 @@ void SharedStatTables::AddLpStat(absl::string_view name, Model* model) {
   int64_t num_merged_constraints = 0;
   int64_t num_shortened_constraints = 0;
   int64_t num_split_constraints = 0;
-  int64_t num_coeff_strenghtening = 0;
+  int64_t num_coeff_strengthening = 0;
   int64_t num_cuts = 0;
   int64_t num_add_cut_calls = 0;
 
@@ -187,7 +187,7 @@ void SharedStatTables::AddLpStat(absl::string_view name, Model* model) {
     num_merged_constraints += manager.num_merged_constraints();
     num_shortened_constraints += manager.num_shortened_constraints();
     num_split_constraints += manager.num_split_constraints();
-    num_coeff_strenghtening += manager.num_coeff_strenghtening();
+    num_coeff_strengthening += manager.num_coeff_strenghtening();
     num_cuts += manager.num_cuts();
     num_add_cut_calls += manager.num_add_cut_calls();
 
@@ -222,7 +222,7 @@ void SharedStatTables::AddLpStat(absl::string_view name, Model* model) {
                                FormatCounter(num_merged_constraints),
                                FormatCounter(num_shortened_constraints),
                                FormatCounter(num_split_constraints),
-                               FormatCounter(num_coeff_strenghtening),
+                               FormatCounter(num_coeff_strengthening),
                                absl::StrCat(FormatCounter(num_cuts), "/",
                                             FormatCounter(num_add_cut_calls))});
 }
diff --git a/ortools/sat/synchronization.h b/ortools/sat/synchronization.h
index 1eb9590fcc..e6cd92e29c 100644
--- a/ortools/sat/synchronization.h
+++ b/ortools/sat/synchronization.h
@@ -171,9 +171,12 @@ class SharedSolutionRepository {
 
   int num_solutions_to_keep() const { return num_solutions_to_keep_; }
 
+  void SetDiversityLimit(int value) { diversity_limit_ = value; }
+
  protected:
   const std::string name_;
   const int num_solutions_to_keep_;
+  int diversity_limit_ = 10;
 
   mutable absl::Mutex mutex_;
   int source_id_ ABSL_GUARDED_BY(mutex_);
@@ -212,7 +215,10 @@ class SharedSolutionPool {
   explicit SharedSolutionPool(const SatParameters& parameters_)
       : best_solutions_(parameters_.solution_pool_size(), "best_solutions"),
         alternative_path_(parameters_.alternative_pool_size(),
-                          "alternative_path", /*source_id=*/0) {}
+                          "alternative_path", /*source_id=*/0) {
+    best_solutions_.SetDiversityLimit(
+        parameters_.solution_pool_diversity_limit());
+  }
 
   const SharedSolutionRepository<int64_t>& BestSolutions() const {
     return best_solutions_;
@@ -1170,7 +1176,8 @@ void SharedSolutionRepository<ValueType>::Synchronize(
       ++num_best;
     }
 
-    if (num_best > num_solutions_to_keep_ && num_solutions_to_keep_ < 10) {
+    if (num_best > num_solutions_to_keep_ &&
+        num_solutions_to_keep_ <= diversity_limit_) {
       // We should only be here if a new solution (not in our current set) was
       // found. It could be one we saw before but forgot about. We put one
       // first.
@@ -1182,8 +1189,9 @@ void SharedSolutionRepository<ValueType>::Synchronize(
         }
       }
 
-      // We are going to be in O(n^2 * solution_size), so keep n <= 10.
-      solutions_.resize(std::min(10, num_best));
+      // We are going to be in O(n^2 * solution_size + 2^n),
+      // so keep n <= diversity_limit_.
+      solutions_.resize(std::min(diversity_limit_, num_best));
 
       // Fill the pairwise distances.
       const int n = solutions_.size();
@@ -1208,6 +1216,9 @@ void SharedSolutionRepository<ValueType>::Synchronize(
       // with the rest.
       //
       // This way, as we find new solution, the set changes slowly.
+      //
+      // TODO(user): When n == num_solutions_to_keep_ + 1, there is
+      // a faster algo thant 2^n since there is only n possible sets. Fix.
       const std::vector<int> selected =
           FindMostDiverseSubset(num_solutions_to_keep_, n, distances_, buffer_,
                                 /*always_pick_mask = */ 1);
diff --git a/ortools/sat/table_test.cc b/ortools/sat/table_test.cc
index 43669185dd..1e94f08789 100644
--- a/ortools/sat/table_test.cc
+++ b/ortools/sat/table_test.cc
@@ -119,23 +119,6 @@ TEST(TableConstraintTest, EmptyOrTrivialSemantics) {
               }
             )pb"),
             CpSolverStatus::OPTIMAL);
-
-  // Invalid: not affine
-  EXPECT_EQ(SolveTextProto(R"pb(
-              variables { domain: [ 0, 0 ] }
-              variables { domain: [ 0, 0 ] }
-              constraints {
-                table {
-                  values: [ 0 ]
-                  exprs:
-                  [ {
-                    vars: [ 0, 1 ]
-                    coeffs: [ 1, 1 ]
-                  }]
-                }
-              }
-            )pb"),
-            CpSolverStatus::MODEL_INVALID);
 }
 
 TEST(TableConstraintTest, EnumerationAndEncoding) {
diff --git a/ortools/sat/timetable.cc b/ortools/sat/timetable.cc
index b8d194297b..24a3f9b4d5 100644
--- a/ortools/sat/timetable.cc
+++ b/ortools/sat/timetable.cc
@@ -19,6 +19,7 @@
 
 #include "absl/log/check.h"
 #include "absl/types/span.h"
+#include "ortools/sat/enforcement.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
@@ -29,10 +30,12 @@
 namespace operations_research {
 namespace sat {
 
-void AddReservoirConstraint(std::vector<AffineExpression> times,
-                            std::vector<AffineExpression> deltas,
-                            std::vector<Literal> presences, int64_t min_level,
-                            int64_t max_level, Model* model) {
+void AddReservoirConstraint(absl::Span<const Literal> enforcement_literals,
+                            absl::Span<const AffineExpression> times,
+                            absl::Span<const AffineExpression> deltas,
+                            absl::Span<const Literal> presences,
+                            int64_t min_level, int64_t max_level,
+                            Model* model) {
   // We only create a side if it can fail.
   IntegerValue min_possible(0);
   IntegerValue max_possible(0);
@@ -42,51 +45,69 @@ void AddReservoirConstraint(std::vector<AffineExpression> times,
     max_possible += std::max(IntegerValue(0), integer_trail->UpperBound(d));
   }
   if (max_possible > max_level) {
-    model->TakeOwnership(new ReservoirTimeTabling(
-        times, deltas, presences, IntegerValue(max_level), model));
+    model->TakeOwnership(
+        new ReservoirTimeTabling(enforcement_literals, times, deltas, presences,
+                                 IntegerValue(max_level), model));
   }
   if (min_possible < min_level) {
-    for (AffineExpression& ref : deltas) ref = ref.Negated();
-    model->TakeOwnership(new ReservoirTimeTabling(
-        times, deltas, presences, IntegerValue(-min_level), model));
+    std::vector<AffineExpression> negated_deltas;
+    for (const AffineExpression& ref : deltas) {
+      negated_deltas.push_back(ref.Negated());
+    }
+    model->TakeOwnership(
+        new ReservoirTimeTabling(enforcement_literals, times, negated_deltas,
+                                 presences, IntegerValue(-min_level), model));
   }
 }
 
 ReservoirTimeTabling::ReservoirTimeTabling(
-    const std::vector<AffineExpression>& times,
-    const std::vector<AffineExpression>& deltas,
-    const std::vector<Literal>& presences, IntegerValue capacity, Model* model)
-    : times_(times),
-      deltas_(deltas),
-      presences_(presences),
+    absl::Span<const Literal> enforcement_literals,
+    absl::Span<const AffineExpression> times,
+    absl::Span<const AffineExpression> deltas,
+    absl::Span<const Literal> presences, IntegerValue capacity, Model* model)
+    : enforcement_literals_(enforcement_literals.begin(),
+                            enforcement_literals.end()),
+      times_(times.begin(), times.end()),
+      deltas_(deltas.begin(), deltas.end()),
+      presences_(presences.begin(), presences.end()),
       capacity_(capacity),
       assignment_(model->GetOrCreate<Trail>()->Assignment()),
-      integer_trail_(model->GetOrCreate<IntegerTrail>()) {
+      integer_trail_(*model->GetOrCreate<IntegerTrail>()),
+      enforcement_helper_(*model->GetOrCreate<EnforcementHelper>()) {
   auto* watcher = model->GetOrCreate<GenericLiteralWatcher>();
   const int id = watcher->Register(this);
   const int num_events = times.size();
   for (int e = 0; e < num_events; e++) {
     watcher->WatchLowerBound(deltas_[e], id);
-    if (integer_trail_->UpperBound(deltas_[e]) > 0) {
+    if (integer_trail_.UpperBound(deltas_[e]) > 0) {
       watcher->WatchUpperBound(times_[e].var, id);
       watcher->WatchLiteral(presences_[e], id);
     }
-    if (integer_trail_->LowerBound(deltas_[e]) < 0) {
+    if (integer_trail_.LowerBound(deltas_[e]) < 0) {
       watcher->WatchLowerBound(times_[e].var, id);
       watcher->WatchLiteral(presences_[e].Negated(), id);
     }
   }
   watcher->NotifyThatPropagatorMayNotReachFixedPointInOnePass(id);
+  enforcement_id_ =
+      enforcement_helper_.Register(enforcement_literals, watcher, id);
 }
 
 bool ReservoirTimeTabling::Propagate() {
+  const EnforcementStatus status = enforcement_helper_.Status(enforcement_id_);
+  if (status == EnforcementStatus::IS_FALSE ||
+      status == EnforcementStatus::CANNOT_PROPAGATE) {
+    return true;
+  }
+
   const int num_events = times_.size();
   if (!BuildProfile()) return false;
+  if (status != EnforcementStatus::IS_ENFORCED) return true;
   for (int e = 0; e < num_events; e++) {
     if (assignment_.LiteralIsFalse(presences_[e])) continue;
 
     // For positive delta_min, we can maybe increase the min.
-    const IntegerValue min_d = integer_trail_->LowerBound(deltas_[e]);
+    const IntegerValue min_d = integer_trail_.LowerBound(deltas_[e]);
     if (min_d > 0 && !TryToIncreaseMin(e)) return false;
 
     // For negative delta_min, we can maybe decrease the max.
@@ -105,16 +126,16 @@ bool ReservoirTimeTabling::BuildProfile() {
   const int num_events = times_.size();
   profile_.emplace_back(kMinIntegerValue, IntegerValue(0));  // Sentinel.
   for (int e = 0; e < num_events; e++) {
-    const IntegerValue min_d = integer_trail_->LowerBound(deltas_[e]);
+    const IntegerValue min_d = integer_trail_.LowerBound(deltas_[e]);
     if (min_d > 0) {
       // Only consider present event for positive delta.
       if (!assignment_.LiteralIsTrue(presences_[e])) continue;
-      const IntegerValue ub = integer_trail_->UpperBound(times_[e]);
+      const IntegerValue ub = integer_trail_.UpperBound(times_[e]);
       profile_.push_back({ub, min_d});
     } else if (min_d < 0) {
       // Only consider non-absent event for negative delta.
       if (assignment_.LiteralIsFalse(presences_[e])) continue;
-      profile_.push_back({integer_trail_->LowerBound(times_[e]), min_d});
+      profile_.push_back({integer_trail_.LowerBound(times_[e]), min_d});
     }
   }
   profile_.emplace_back(kMaxIntegerValue, IntegerValue(0));  // Sentinel.
@@ -134,11 +155,19 @@ bool ReservoirTimeTabling::BuildProfile() {
   profile_.resize(last + 1);
 
   // Conflict?
+  const bool is_enforced = enforcement_helper_.Status(enforcement_id_) ==
+                           EnforcementStatus::IS_ENFORCED;
   for (const ProfileRectangle& rect : profile_) {
     if (rect.height <= capacity_) continue;
 
     FillReasonForProfileAtGivenTime(rect.start);
-    return integer_trail_->ReportConflict(literal_reason_, integer_reason_);
+    if (is_enforced) {
+      return enforcement_helper_.ReportConflict(
+          enforcement_id_, literal_reason_, integer_reason_);
+    } else {
+      return enforcement_helper_.PropagateWhenFalse(
+          enforcement_id_, literal_reason_, integer_reason_);
+    }
   }
 
   return true;
@@ -173,10 +202,10 @@ void ReservoirTimeTabling::FillReasonForProfileAtGivenTime(
   const int num_events = times_.size();
   for (int e = 0; e < num_events; e++) {
     if (e == event_to_ignore) continue;
-    const IntegerValue min_d = integer_trail_->LowerBound(deltas_[e]);
+    const IntegerValue min_d = integer_trail_.LowerBound(deltas_[e]);
     if (min_d > 0) {
       if (!assignment_.LiteralIsTrue(presences_[e])) continue;
-      if (integer_trail_->UpperBound(times_[e]) > t) continue;
+      if (integer_trail_.UpperBound(times_[e]) > t) continue;
       AddGreaterOrEqual(deltas_[e], min_d, &integer_reason_);
       AddLowerOrEqual(times_[e], t, &integer_reason_);
       literal_reason_.push_back(presences_[e].Negated());
@@ -186,7 +215,7 @@ void ReservoirTimeTabling::FillReasonForProfileAtGivenTime(
         continue;
       }
       AddGreaterOrEqual(deltas_[e], min_d, &integer_reason_);
-      if (min_d < 0 && integer_trail_->LowerBound(times_[e]) > t) {
+      if (min_d < 0 && integer_trail_.LowerBound(times_[e]) > t) {
         AddGreaterOrEqual(times_[e], t + 1, &integer_reason_);
       }
     }
@@ -196,10 +225,10 @@ void ReservoirTimeTabling::FillReasonForProfileAtGivenTime(
 // Note that a negative event will always be in the profile, even if its
 // presence is still not settled.
 bool ReservoirTimeTabling::TryToDecreaseMax(int event) {
-  const IntegerValue min_d = integer_trail_->LowerBound(deltas_[event]);
+  const IntegerValue min_d = integer_trail_.LowerBound(deltas_[event]);
   CHECK_LT(min_d, 0);
-  const IntegerValue start = integer_trail_->LowerBound(times_[event]);
-  const IntegerValue end = integer_trail_->UpperBound(times_[event]);
+  const IntegerValue start = integer_trail_.LowerBound(times_[event]);
+  const IntegerValue end = integer_trail_.UpperBound(times_[event]);
 
   // We already tested for conflict in BuildProfile().
   if (start == end) return true;
@@ -235,7 +264,8 @@ bool ReservoirTimeTabling::TryToDecreaseMax(int event) {
   // updated, better be defensive.
   if (new_end < start) {
     AddGreaterOrEqual(times_[event], new_end + 1, &integer_reason_);
-    return integer_trail_->ReportConflict(literal_reason_, integer_reason_);
+    return enforcement_helper_.ReportConflict(enforcement_id_, literal_reason_,
+                                              integer_reason_);
   }
 
   // First, the task MUST be present, otherwise we have a conflict.
@@ -243,20 +273,21 @@ bool ReservoirTimeTabling::TryToDecreaseMax(int event) {
   // TODO(user): We actually need to look after 'end' to potentially push the
   // presence in more situation.
   if (!assignment_.LiteralIsTrue(presences_[event])) {
-    integer_trail_->EnqueueLiteral(presences_[event], literal_reason_,
-                                   integer_reason_);
+    enforcement_helper_.EnqueueLiteral(enforcement_id_, presences_[event],
+                                       literal_reason_, integer_reason_);
   }
 
   // Push new_end too. Note that we don't need the presence reason.
-  return integer_trail_->Enqueue(times_[event].LowerOrEqual(new_end),
-                                 literal_reason_, integer_reason_);
+  return enforcement_helper_.Enqueue(enforcement_id_,
+                                     times_[event].LowerOrEqual(new_end),
+                                     literal_reason_, integer_reason_);
 }
 
 bool ReservoirTimeTabling::TryToIncreaseMin(int event) {
-  const IntegerValue min_d = integer_trail_->LowerBound(deltas_[event]);
+  const IntegerValue min_d = integer_trail_.LowerBound(deltas_[event]);
   CHECK_GT(min_d, 0);
-  const IntegerValue start = integer_trail_->LowerBound(times_[event]);
-  const IntegerValue end = integer_trail_->UpperBound(times_[event]);
+  const IntegerValue start = integer_trail_.LowerBound(times_[event]);
+  const IntegerValue end = integer_trail_.UpperBound(times_[event]);
 
   // We already tested for conflict in BuildProfile().
   if (start == end) return true;
@@ -302,9 +333,10 @@ bool ReservoirTimeTabling::TryToIncreaseMin(int event) {
   // The reason is simply the capacity at new_start - 1;
   FillReasonForProfileAtGivenTime(new_start - 1, event);
   AddGreaterOrEqual(deltas_[event], min_d, &integer_reason_);
-  return integer_trail_->ConditionalEnqueue(
-      presences_[event], times_[event].GreaterOrEqual(new_start),
-      &literal_reason_, &integer_reason_);
+  return enforcement_helper_.ConditionalEnqueue(
+      enforcement_id_, presences_[event],
+      times_[event].GreaterOrEqual(new_start), literal_reason_,
+      integer_reason_);
 }
 
 TimeTablingPerTask::TimeTablingPerTask(AffineExpression capacity,
@@ -355,8 +387,9 @@ void TimeTablingPerTask::RegisterWith(GenericLiteralWatcher* watcher) {
   watcher->NotifyThatPropagatorMayNotReachFixedPointInOnePass(id);
 }
 
-// Note that we relly on being called again to reach a fixed point.
+// Note that we rely on being called again to reach a fixed point.
 bool TimeTablingPerTask::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   // This can fail if the profile exceeds the resource capacity.
   if (!BuildProfile()) return false;
 
@@ -573,7 +606,7 @@ bool TimeTablingPerTask::SweepTask(int task_id, IntegerValue initial_start_min,
 
         // Note that the task_id is already part of the profile reason, so
         // there is nothing else needed.
-        helper_->ClearReason();
+        helper_->ResetReason();
         const IntegerValue time = std::max(start_max, profile_[rec_id].start);
         AddProfileReason(task_id, time, time + 1, CapacityMax());
         if (!helper_->PushIntegerLiteralIfTaskPresent(
@@ -614,11 +647,11 @@ bool TimeTablingPerTask::SweepTask(int task_id, IntegerValue initial_start_min,
 bool TimeTablingPerTask::UpdateStartingTime(int task_id, IntegerValue left,
                                             IntegerValue right) {
   DCHECK_LT(left, right);
-  helper_->ClearReason();
+  helper_->ResetReason();
   AddProfileReason(task_id, left, right,
                    CapacityMax() - demands_->DemandMin(task_id));
   if (capacity_.var != kNoIntegerVariable) {
-    helper_->MutableIntegerReason()->push_back(
+    helper_->AddIntegerReason(
         integer_trail_->UpperBoundAsLiteral(capacity_.var));
   }
 
@@ -701,7 +734,7 @@ bool TimeTablingPerTask::IncreaseCapacity(IntegerValue time,
   // and we can optimize the reason a bit.
   new_min = std::min(CapacityMax() + 1, new_min);
 
-  helper_->ClearReason();
+  helper_->ResetReason();
   AddProfileReason(-1, time, time + 1, new_min);
   if (capacity_.var == kNoIntegerVariable) {
     return helper_->ReportConflict();
diff --git a/ortools/sat/timetable.h b/ortools/sat/timetable.h
index ba937c0844..cff5a54ac2 100644
--- a/ortools/sat/timetable.h
+++ b/ortools/sat/timetable.h
@@ -17,6 +17,9 @@
 #include <cstdint>
 #include <vector>
 
+#include "absl/types/span.h"
+#include "ortools/sat/enforcement.h"
+#include "ortools/sat/enforcement_helper.h"
 #include "ortools/sat/integer.h"
 #include "ortools/sat/integer_base.h"
 #include "ortools/sat/model.h"
@@ -33,10 +36,11 @@ namespace sat {
 //
 // This instantiate one or more ReservoirTimeTabling class to perform the
 // propagation.
-void AddReservoirConstraint(std::vector<AffineExpression> times,
-                            std::vector<AffineExpression> deltas,
-                            std::vector<Literal> presences, int64_t min_level,
-                            int64_t max_level, Model* model);
+void AddReservoirConstraint(absl::Span<const Literal> enforcement_literals,
+                            absl::Span<const AffineExpression> times,
+                            absl::Span<const AffineExpression> deltas,
+                            absl::Span<const Literal> presences,
+                            int64_t min_level, int64_t max_level, Model* model);
 
 // The piecewise constant function must be below the given capacity. The initial
 // function value is zero. Note that a negative capacity will thus be trivially
@@ -47,9 +51,10 @@ void AddReservoirConstraint(std::vector<AffineExpression> times,
 // full horizon, we could have taken < t with no behavior change.
 class ReservoirTimeTabling : public PropagatorInterface {
  public:
-  ReservoirTimeTabling(const std::vector<AffineExpression>& times,
-                       const std::vector<AffineExpression>& deltas,
-                       const std::vector<Literal>& presences,
+  ReservoirTimeTabling(absl::Span<const Literal> enforcement_literals,
+                       absl::Span<const AffineExpression> times,
+                       absl::Span<const AffineExpression> deltas,
+                       absl::Span<const Literal> presences,
                        IntegerValue capacity, Model* model);
 
   bool Propagate() final;
@@ -86,6 +91,7 @@ class ReservoirTimeTabling : public PropagatorInterface {
   bool TryToDecreaseMax(int event);
 
   // Input.
+  std::vector<Literal> enforcement_literals_;
   std::vector<AffineExpression> times_;
   std::vector<AffineExpression> deltas_;
   std::vector<Literal> presences_;
@@ -93,7 +99,9 @@ class ReservoirTimeTabling : public PropagatorInterface {
 
   // Model class.
   const VariablesAssignment& assignment_;
-  IntegerTrail* integer_trail_;
+  const IntegerTrail& integer_trail_;
+  EnforcementHelper& enforcement_helper_;
+  EnforcementId enforcement_id_;
 
   // Temporary data.
   std::vector<Literal> literal_reason_;
diff --git a/ortools/sat/timetable_edgefinding.cc b/ortools/sat/timetable_edgefinding.cc
index 00f2081402..78a9353143 100644
--- a/ortools/sat/timetable_edgefinding.cc
+++ b/ortools/sat/timetable_edgefinding.cc
@@ -58,6 +58,7 @@ void TimeTableEdgeFinding::RegisterWith(GenericLiteralWatcher* watcher) {
 }
 
 bool TimeTableEdgeFinding::Propagate() {
+  if (!helper_->IsEnforced()) return true;
   if (!helper_->SynchronizeAndSetTimeDirection(true)) return false;
   if (!TimeTableEdgeFindingPass()) return false;
   if (!helper_->SynchronizeAndSetTimeDirection(false)) return false;
@@ -371,11 +372,11 @@ bool TimeTableEdgeFinding::TimeTableEdgeFindingPass() {
 void TimeTableEdgeFinding::FillEnergyInWindowReason(IntegerValue window_min,
                                                     IntegerValue window_max,
                                                     int task_index) {
-  helper_->ClearReason();
+  helper_->ResetReason();
 
   // Capacity of the resource.
   if (capacity_.var != kNoIntegerVariable) {
-    helper_->MutableIntegerReason()->push_back(
+    helper_->AddIntegerReason(
         integer_trail_->UpperBoundAsLiteral(capacity_.var));
   }
 
diff --git a/ortools/sat/timetable_test.cc b/ortools/sat/timetable_test.cc
index 10733ba526..4098954e7e 100644
--- a/ortools/sat/timetable_test.cc
+++ b/ortools/sat/timetable_test.cc
@@ -97,7 +97,8 @@ bool TestTimeTablingPropagation(absl::Span<const CumulativeTasks> tasks,
   EXPECT_TRUE(precedences->Propagate());
 
   auto* repo = model.GetOrCreate<IntervalsRepository>();
-  SchedulingConstraintHelper* helper = repo->GetOrCreateHelper(interval_vars);
+  SchedulingConstraintHelper* helper =
+      repo->GetOrCreateHelper(/*enforcement_literals=*/{}, interval_vars);
   SchedulingDemandHelper* demands_helper =
       model.TakeOwnership(new SchedulingDemandHelper(demands, helper, &model));
 
@@ -218,7 +219,8 @@ TEST(TimeTablingSolve, FindAll) {
     demand_exprs[i] = AffineExpression(IntegerValue(demands[i]));
   }
 
-  model.Add(Cumulative(intervals, demand_exprs, capacity_expr));
+  model.Add(Cumulative(/*enforcement_literals=*/{}, intervals, demand_exprs,
+                       capacity_expr));
 
   int num_solutions_found = 0;
   auto* integer_trail = model.GetOrCreate<IntegerTrail>();
@@ -265,7 +267,8 @@ TEST(TimeTablingSolve, FindAllWithVaryingCapacity) {
       demand_exprs[i] = AffineExpression(IntegerValue(demands[i]));
     }
 
-    model.Add(Cumulative(intervals, demand_exprs, capacity_expr));
+    model.Add(Cumulative(/*enforcement_literals=*/{}, intervals, demand_exprs,
+                         capacity_expr));
 
     int num_solutions_found = 0;
     auto* integer_trail = model.GetOrCreate<IntegerTrail>();
@@ -305,7 +308,8 @@ TEST(TimeTablingSolve, FindAllWithVaryingCapacity) {
     demand_exprs[i] = AffineExpression(IntegerValue(demands[i]));
   }
 
-  model.Add(Cumulative(intervals, demand_exprs, capacity_expr));
+  model.Add(Cumulative(/*enforcement_literals=*/{}, intervals, demand_exprs,
+                       capacity_expr));
 
   int num_solutions_found = 0;
   auto* integer_trail = model.GetOrCreate<IntegerTrail>();
@@ -355,7 +359,8 @@ TEST(TimeTablingSolve, FindAllWithOptionals) {
     demand_exprs[i] = AffineExpression(IntegerValue(demands[i]));
   }
 
-  model.Add(Cumulative(intervals, demand_exprs, capacity_expr));
+  model.Add(Cumulative(/*enforcement_literals=*/{}, intervals, demand_exprs,
+                       capacity_expr));
 
   int num_solutions_found = 0;
   auto* integer_trail = model.GetOrCreate<IntegerTrail>();
@@ -406,7 +411,8 @@ TEST(ReservoirTest, FindAllParenthesis) {
   std::vector<Literal> all_true(size, true_lit);
 
   model.Add(AllDifferentOnBounds(vars));
-  AddReservoirConstraint(times, deltas, all_true, 0, size, &model);
+  AddReservoirConstraint(/*enforcement_literals=*/{}, times, deltas, all_true,
+                         0, size, &model);
 
   absl::btree_map<std::string, int> sequence_to_count;
   int num_solutions_found = 0;
@@ -462,7 +468,8 @@ TEST(ReservoirTest, FindAllParenthesisWithOptionality) {
   }
 
   model.Add(AllDifferentOnBounds(vars));
-  AddReservoirConstraint(times, deltas, present, 0, size, &model);
+  AddReservoirConstraint(/*enforcement_literals=*/{}, times, deltas, present, 0,
+                         size, &model);
 
   absl::btree_map<std::string, int> sequence_to_count;
   int num_solutions_found = 0;
@@ -512,7 +519,8 @@ TEST(ReservoirTest, VariableLevelChange) {
 
   const int min_level = 0;
   const int max_level = 1;
-  AddReservoirConstraint(times, deltas, all_true, min_level, max_level, &model);
+  AddReservoirConstraint(/*enforcement_literals=*/{}, times, deltas, all_true,
+                         min_level, max_level, &model);
 
   absl::btree_map<std::string, int> sequence_to_count;
   int num_solutions_found = 0;
@@ -552,6 +560,26 @@ TEST(ReservoirTest, VariableLevelChange) {
   EXPECT_EQ(num_solutions_found, 1 << size);
 }
 
+TEST(ReservoirTimeTablingTest, WithUnassignedEnforcementLiteral) {
+  Model model;
+  std::vector<AffineExpression> times(4);
+  std::vector<AffineExpression> deltas(4);
+  std::vector<Literal> presences(4);
+  for (int i = 0; i < 4; ++i) {
+    times.push_back(AffineExpression(i + 1));
+    deltas.push_back(AffineExpression(i + 2));
+    presences.push_back(model.GetOrCreate<IntegerEncoder>()->GetTrueLiteral());
+  }
+  const Literal b = Literal(model.Add(NewBooleanVariable()), true);
+  // Always false is enforced (sum(deltas) = 2+3+4+5 > 10).
+  model.TakeOwnership(new ReservoirTimeTabling({b}, times, deltas, presences,
+                                               IntegerValue(10), &model));
+
+  EXPECT_TRUE(model.GetOrCreate<SatSolver>()->Propagate());
+  EXPECT_TRUE(model.GetOrCreate<Trail>()->Assignment().LiteralIsFalse(b));
+  EXPECT_EQ(model.GetOrCreate<IntegerTrail>()->num_enqueues(), 0);
+}
+
 }  // namespace
 }  // namespace sat
 }  // namespace operations_research
diff --git a/ortools/sat/util.cc b/ortools/sat/util.cc
index 8f212eacf8..8e29e93780 100644
--- a/ortools/sat/util.cc
+++ b/ortools/sat/util.cc
@@ -129,7 +129,7 @@ void RandomizeDecisionHeuristic(absl::BitGenRef random,
 namespace {
 
 // This will be optimized into one division. I tested that in other places:
-// 3/ortools/sat/integer_test.cc;l=1223-1228;bpv=0
+// https://source.corp.google.com/piper///depot/ortools/sat/integer_test.cc;l=1223-1228;bpv=0
 //
 // Note that I am not 100% sure we need the indirection for the optimization
 // to kick in though, but this seemed safer given our weird r[i ^ 1] inputs.
@@ -1014,7 +1014,40 @@ std::vector<int> FindMostDiverseSubset(int k, int n,
                                        absl::Span<const int64_t> distances,
                                        std::vector<int64_t>& buffer,
                                        int always_pick_mask) {
-  CHECK_LE(n, 20);
+  DCHECK_LE(k, n);
+  std::vector<int> result;
+  result.reserve(k);
+
+  if (k == n) {
+    for (int i = 0; i < n; ++i) result.push_back(i);
+    return result;
+  }
+
+  if (k == n - 1) {
+    // We just exclude the one closer to all the other.
+    int64_t worse = std::numeric_limits<int64_t>::max();
+    int to_exclude = -1;
+    for (int i = 0; i < n; ++i) {
+      if ((always_pick_mask >> i) & 1) continue;
+
+      int64_t score = 0;
+      for (int j = 0; j < n; ++j) {
+        if (i != j) score += distances[i * n + j];
+      }
+      if (score < worse) {
+        worse = score;
+        to_exclude = i;
+      }
+    }
+
+    CHECK_NE(to_exclude, -1);
+    for (int i = 0; i < n; ++i) {
+      if (i != to_exclude) result.push_back(i);
+    }
+    return result;
+  }
+
+  CHECK_LE(n, 25);
   const int limit = 1 << n;
   buffer.assign(limit, 0);
   int best_mask;
@@ -1043,8 +1076,7 @@ std::vector<int> FindMostDiverseSubset(int k, int n,
       best_mask = mask;
     }
   }
-  std::vector<int> result;
-  result.reserve(k);
+
   for (int i = 0; i < n; ++i) {
     if ((best_mask >> i) & 1) {
       result.push_back(i);
diff --git a/ortools/sat/util.h b/ortools/sat/util.h
index 030fc254da..c36e9ffa4a 100644
--- a/ortools/sat/util.h
+++ b/ortools/sat/util.h
@@ -394,9 +394,10 @@ int MoveOneUnprocessedLiteralLast(
 // Selects k out of n such that the sum of pairwise distances is maximal.
 // distances[i * n + j] = distances[j * n + j] = distances between i and j.
 //
-// This shall only be called with small n, we CHECK_LE(n, 20).
-// Complexity is in O(2 ^ n + n_choose_k * n).
-// Memory is in O(2 ^ n).
+// In the special case k >= n - 1, we use a faster algo.
+//
+// Otherwise, this shall only be called with small n, we CHECK_LE(n, 25).
+// Complexity is in O(2 ^ n + n_choose_k * n). Memory is in O(2 ^ n).
 //
 // In case of tie, this will choose deterministically, so one can randomize the
 // order first to get a random subset. The returned subset will always be
diff --git a/ortools/sat/util_test.cc b/ortools/sat/util_test.cc
index 76f1dd3407..f9a0c928c4 100644
--- a/ortools/sat/util_test.cc
+++ b/ortools/sat/util_test.cc
@@ -1164,46 +1164,47 @@ TEST(DagTopologicalSortIteratorTest, RandomTest) {
 
 TEST(FindMostDiverseSubsetTest, Random) {
   const int k = 4;
-  const int n = 10;
-  absl::BitGen random;
-  std::vector<int64_t> distances(n * n);
-  std::vector<int64_t> buffer;
-  for (int i = 0; i < n; ++i) {
-    for (int j = i + 1; j < n; ++j) {
-      distances[i * n + j] = distances[j * n + i] =
-          absl::Uniform<int>(random, 0, 1000);
-    }
-  }
-
-  const std::vector<int> result =
-      FindMostDiverseSubset(k, n, distances, buffer);
-  CHECK(std::is_sorted(result.begin(), result.end()));
-  int64_t result_value = 0;
-  for (const int i : result) {
-    for (const int j : result) {
-      if (i < j) result_value += distances[i * n + j];
-    }
-  }
-
-  int64_t best_seen = 0;
-  std::vector<int> subset;
-  const int limit = 1 << n;
-  for (unsigned int mask = 0; mask < limit; ++mask) {
-    if (absl::popcount(mask) != k) continue;
-    subset.clear();
+  for (const int n : {4, 5, 10}) {  // We test the two special cases.
+    absl::BitGen random;
+    std::vector<int64_t> distances(n * n);
+    std::vector<int64_t> buffer;
     for (int i = 0; i < n; ++i) {
-      if ((mask >> i) & 1) subset.push_back(i);
-    }
-    int64_t value = 0;
-    for (const int i : subset) {
-      for (const int j : subset) {
-        if (i < j) value += distances[i * n + j];
+      for (int j = i + 1; j < n; ++j) {
+        distances[i * n + j] = distances[j * n + i] =
+            absl::Uniform<int>(random, 0, 1000);
       }
     }
-    ASSERT_LE(value, result_value);
-    best_seen = std::max(best_seen, value);
+
+    const std::vector<int> result =
+        FindMostDiverseSubset(k, n, distances, buffer);
+    CHECK(std::is_sorted(result.begin(), result.end()));
+    int64_t result_value = 0;
+    for (const int i : result) {
+      for (const int j : result) {
+        if (i < j) result_value += distances[i * n + j];
+      }
+    }
+
+    int64_t best_seen = 0;
+    std::vector<int> subset;
+    const int limit = 1 << n;
+    for (unsigned int mask = 0; mask < limit; ++mask) {
+      if (absl::popcount(mask) != k) continue;
+      subset.clear();
+      for (int i = 0; i < n; ++i) {
+        if ((mask >> i) & 1) subset.push_back(i);
+      }
+      int64_t value = 0;
+      for (const int i : subset) {
+        for (const int j : subset) {
+          if (i < j) value += distances[i * n + j];
+        }
+      }
+      ASSERT_LE(value, result_value);
+      best_seen = std::max(best_seen, value);
+    }
+    EXPECT_EQ(best_seen, result_value);
   }
-  EXPECT_EQ(best_seen, result_value);
 }
 
 TEST(FindMostDiverseSubsetTest, RandomButAlwaysPickZero) {
diff --git a/ortools/scheduling/python/BUILD.bazel b/ortools/scheduling/python/BUILD.bazel
index 2eff545f5a..bf588fe58e 100644
--- a/ortools/scheduling/python/BUILD.bazel
+++ b/ortools/scheduling/python/BUILD.bazel
@@ -35,7 +35,6 @@ py_test(
     data = [
         "//ortools/scheduling/testdata:j301_1.sm",
     ],
-    python_version = "PY3",
     deps = [
         ":rcpsp",
         "//ortools/scheduling:rcpsp_py_proto",
diff --git a/ortools/service/v1/BUILD.bazel b/ortools/service/v1/BUILD.bazel
index 83bcc12f15..69c6fbc45c 100644
--- a/ortools/service/v1/BUILD.bazel
+++ b/ortools/service/v1/BUILD.bazel
@@ -12,6 +12,7 @@
 # limitations under the License.
 
 load("@protobuf//bazel:cc_proto_library.bzl", "cc_proto_library")
+load("@protobuf//bazel:java_proto_library.bzl", "java_proto_library")
 load("@protobuf//bazel:proto_library.bzl", "proto_library")
 load("@protobuf//bazel:py_proto_library.bzl", "py_proto_library")
 
diff --git a/ortools/set_cover/BUILD.bazel b/ortools/set_cover/BUILD.bazel
index 3e936cfd33..114fa2971b 100644
--- a/ortools/set_cover/BUILD.bazel
+++ b/ortools/set_cover/BUILD.bazel
@@ -38,6 +38,7 @@ cc_proto_library(
 
 py_proto_library(
     name = "set_cover_py_pb2",
+    visibility = ["//visibility:public"],
     deps = [":set_cover_proto"],
 )
 
diff --git a/ortools/set_cover/python/BUILD.bazel b/ortools/set_cover/python/BUILD.bazel
index 68b5c6ed66..777e8fab30 100644
--- a/ortools/set_cover/python/BUILD.bazel
+++ b/ortools/set_cover/python/BUILD.bazel
@@ -35,7 +35,6 @@ pybind_extension(
 py_test(
     name = "set_cover_test",
     srcs = ["set_cover_test.py"],
-    python_version = "PY3",
     deps = [
         ":set_cover",
         "//ortools/set_cover:set_cover_py_pb2",
diff --git a/ortools/third_party_solvers/BUILD.bazel b/ortools/third_party_solvers/BUILD.bazel
index a7eb2776a6..7c9c628922 100644
--- a/ortools/third_party_solvers/BUILD.bazel
+++ b/ortools/third_party_solvers/BUILD.bazel
@@ -15,28 +15,11 @@ load("@rules_cc//cc:cc_library.bzl", "cc_library")
 
 package(default_visibility = ["//visibility:public"])
 
-config_setting(
-    name = "on_linux",
-    constraint_values = ["@platforms//os:linux"],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = ["@platforms//os:macos"],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = ["@platforms//os:windows"],
-)
-
 cc_library(
     name = "dynamic_library",
     hdrs = ["dynamic_library.h"],
     linkopts = select({
-        "on_linux": ["-Wl,--no-as-needed -ldl"],
-        "on_macos": [],
-        "on_windows": [],
+        "@platforms//os:linux": ["-Wl,--no-as-needed -ldl"],
         "//conditions:default": [],
     }),
     deps = [
diff --git a/ortools/third_party_solvers/xpress_environment.cc b/ortools/third_party_solvers/xpress_environment.cc
index 04d872d7a6..b41ca59b08 100644
--- a/ortools/third_party_solvers/xpress_environment.cc
+++ b/ortools/third_party_solvers/xpress_environment.cc
@@ -247,7 +247,7 @@ absl::Status LoadXpressDynamicLibrary(std::string& xpresspath) {
   static DynamicLibrary* xpress_library = new DynamicLibrary;
   static absl::Mutex mutex(absl::kConstInit);
 
-  absl::MutexLock lock(&mutex);
+  absl::MutexLock lock(mutex);
 
   absl::call_once(xpress_loading_done, []() {
     const std::vector<std::string> canonical_paths =
diff --git a/ortools/util/BUILD.bazel b/ortools/util/BUILD.bazel
index fca66bd277..744a1940c7 100644
--- a/ortools/util/BUILD.bazel
+++ b/ortools/util/BUILD.bazel
@@ -18,27 +18,6 @@ load("@rules_cc//cc:cc_library.bzl", "cc_library")
 
 package(default_visibility = ["//visibility:public"])
 
-config_setting(
-    name = "on_linux",
-    constraint_values = [
-        "@platforms//os:linux",
-    ],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = [
-        "@platforms//os:macos",
-    ],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = [
-        "@platforms//os:windows",
-    ],
-)
-
 # OptionalBoolean
 proto_library(
     name = "optional_boolean_proto",
@@ -132,9 +111,7 @@ cc_library(
     srcs = ["piecewise_linear_function.cc"],
     hdrs = ["piecewise_linear_function.h"],
     copts = select({
-        "on_linux": [],
-        "on_macos": [],
-        "on_windows": ["/Zc:preprocessor"],
+        "@platforms//os:windows": ["/Zc:preprocessor"],
         "//conditions:default": [],
     }),
     deps = [
@@ -232,6 +209,7 @@ cc_library(
     hdrs = ["sigint.h"],
     deps = [
         "//ortools/base",
+        "//ortools/port:os",
     ],
 )
 
@@ -243,9 +221,9 @@ cc_library(
     # You must also set this flag if you depend on this target and use
     # its methods related to IEEE-754 rounding modes.
     copts = select({
-        "on_linux": ["-frounding-math"],
-        "on_macos": ["-frounding-math"],
-        "on_windows": [],
+        "@platforms//os:linux": ["-frounding-math"],
+        "@platforms//os:macos": ["-frounding-math"],
+        "@platforms//os:windows": [],
         "//conditions:default": ["-frounding-math"],
     }),
     deps = [
diff --git a/ortools/util/java/BUILD.bazel b/ortools/util/java/BUILD.bazel
index 1496f51923..b0c2818d0c 100644
--- a/ortools/util/java/BUILD.bazel
+++ b/ortools/util/java/BUILD.bazel
@@ -11,71 +11,38 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Description: java wrapping of the code in ../
+# Description: java wrapping of (some of) the code in ../, plus
+# some generic utilities for SWIG java.
 
-load("//bazel:swig_java.bzl", "ortools_java_wrap_cc")
+load("//bazel:swig_java.bzl", "java_wrap_cc")
 
-config_setting(
-    name = "on_linux",
-    constraint_values = ["@platforms//os:linux"],
-)
-
-config_setting(
-    name = "on_macos",
-    constraint_values = ["@platforms//os:macos"],
-)
-
-config_setting(
-    name = "on_windows",
-    constraint_values = ["@platforms//os:windows"],
-)
-
-filegroup(
-    name = "vector_swig",
-    srcs = [
+# These .swig files are currently just included in other .swig files.
+# TODO(user): Create dedicated java_wrap_cc rules and unit tests.
+exports_files(
+    [
+        "absl_string_view.swig",
+        "proto.i",
+        "sorted_interval_list.swig",
+        "tuple_set.swig",
         "vector.swig",
     ],
-    visibility = ["//visibility:public"],
 )
 
-filegroup(
-    name = "proto_swig",
-    srcs = [
-        "proto.i",
-    ],
-    visibility = ["//visibility:public"],
-)
-
-filegroup(
-    name = "absl_string_view_swig",
-    srcs = [
-        "absl_string_view.swig",
-    ],
-    visibility = ["//visibility:public"],
-)
-
-filegroup(
-    name = "sorted_interval_list_swig",
-    srcs = [
-        "sorted_interval_list.swig",
-    ],
-    visibility = ["//visibility:public"],
-)
-
-ortools_java_wrap_cc(
+java_wrap_cc(
     name = "sorted_interval_list",
-    src = "sorted_interval_list.swig",
+    srcs = ["sorted_interval_list.swig"],
     package = "com.google.ortools.util",
     swig_includes = [
-        ":vector_swig",
+        ":vector.swig",
         "//ortools/base:base_swig",
     ],
     swig_opt = select({
-        "on_linux": "-DSWIGWORDSIZE64",
+        "@platforms//os:linux": "-DSWIGWORDSIZE64",
         "//conditions:default": "",
     }),
     visibility = ["//visibility:public"],
     deps = [
+        "//ortools/base",
         "//ortools/util:sorted_interval_list",
     ],
 )
diff --git a/ortools/util/proto_tools.cc b/ortools/util/proto_tools.cc
index a21f9ffe1a..510eb5a4b4 100644
--- a/ortools/util/proto_tools.cc
+++ b/ortools/util/proto_tools.cc
@@ -13,7 +13,10 @@
 
 #include "ortools/util/proto_tools.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <string>
+#include <vector>
 
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/descriptor.h"
diff --git a/ortools/util/proto_tools.h b/ortools/util/proto_tools.h
index e6305c9460..0a7ea33d4c 100644
--- a/ortools/util/proto_tools.h
+++ b/ortools/util/proto_tools.h
@@ -17,6 +17,8 @@
 #include <string>
 
 #include "absl/base/casts.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
@@ -42,6 +44,55 @@ absl::StatusOr<const Proto*> SafeProtoConstDownCast(
 std::string FullProtocolMessageAsString(
     const google::protobuf::Message& message, int indent_level);
 
+// This recursive function returns all the proto fields that are set(*) in a
+// proto instance, along with how many times they appeared. A repeated field is
+// only counted once as itself, regardless of its (non-zero) size, but then the
+// nested child fields of a repeated message are counted once per instance.
+// EXAMPLE: with these .proto message definitions:
+//   message YY { repeated int z; }
+//   message XX { int a; int b; repeated int c; repeated YY d; }
+// and this instance of `XX`:
+//   XX x = Parse("a: 10 c: [ 11, 12] d: {z: [13, 14]} d: {z: [15]}"");
+// We'd expect ExploreAndCountAllProtoPathsInInstance() to yield the map:
+//   {"a": 1, "c": 1, "d": 1, "d.z": 3}
+//
+// (*) The term 'set' has the usual semantic, which varies depending on proto
+//     version. Extensions and unknown fields are ignored by this function.
+void ExploreAndCountAllProtoPathsInInstance(
+    const google::protobuf::Message& message,
+    // Output. Must be non-nullptr. Entries are added to the map, i.e., the map
+    // is not cleared. That allows cumulative use of this function across
+    // several proto instances to build a global count of proto paths.
+    absl::flat_hash_map<std::string, int>* proto_path_counts);
+
+// This recursive function lists all the fields of a given proto *type*
+// (not a proto instance), up to the given depth of nested sub-messages, and
+// inserts their proto paths into `proto_paths`.
+//
+// SIMPLE EXAMPLE: with this .proto message definition:
+//   message YY { repeated int z; }
+//   message XX { int a; int b; repeated int c; repeated YY d; },
+// ExploreAndInsertAllProtoPathsInType(
+//     XX().GetDescriptor(), {}, {}, /*max_depth=*/3)
+// Returns: {"a", "b", "c", "d", "d.z"}.
+// See the unit test for more complex examples.
+absl::flat_hash_set<std::string> ExploreAndInsertAllProtoPathsInType(
+    const google::protobuf::Descriptor* descriptor,
+    // ADVANCED USAGE: Pruning the proto tree exploration with two possible
+    // mechanisms: 1) based on proto path, or 2) based on proto type.
+    // 1) List of proto paths to skip: those fields will not be output nor
+    //    explored, meaning that their descendants is also skipped.
+    const absl::flat_hash_set<std::string>& skip_these_proto_paths,
+    // 2) Maps a field's full *type* name (as in Descriptor::full_name(), e.g.,
+    //    "operations_research.MyProto") to the subset of its child field names
+    //    that may be explored.
+    const absl::flat_hash_map<std::string, absl::flat_hash_set<std::string>>&
+        proto_type_names_to_field_name_allowlist,
+    // The maximum depth, when diving into sub-messages. Note that some protos
+    // may have infinite potential depth, e.g. message X { X x; }, so we must
+    // limit the recursion depth.
+    int max_depth);
+
 // =============================================================================
 // Implementation of function templates.
 
@@ -51,8 +102,7 @@ absl::StatusOr<Proto*> SafeProtoDownCast(google::protobuf::Message* proto) {
       Proto::default_instance().GetDescriptor();
   const google::protobuf::Descriptor* actual_descriptor =
       proto->GetDescriptor();
-  if (actual_descriptor == expected_descriptor)
-    return reinterpret_cast<Proto*>(proto);
+  if (actual_descriptor == expected_descriptor) return reinterpret_cast<Proto*>(proto);
   return absl::InvalidArgumentError(absl::StrFormat(
       "Expected message type '%s', but got type '%s'",
       expected_descriptor->full_name(), actual_descriptor->full_name()));
diff --git a/ortools/util/python/BUILD.bazel b/ortools/util/python/BUILD.bazel
index 26fba1de17..1f78f70ae7 100644
--- a/ortools/util/python/BUILD.bazel
+++ b/ortools/util/python/BUILD.bazel
@@ -11,7 +11,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Python wrapper for sorted_interval_list.
+# Description: python wrapping of (some of) the code in ../, plus
+# some generic utilities for SWIG python.
 
 load("@pip_deps//:requirements.bzl", "requirement")
 load("@pybind11_bazel//:build_defs.bzl", "pybind_extension")
@@ -39,7 +40,6 @@ pybind_extension(
 py_test(
     name = "sorted_interval_list_test",
     srcs = ["sorted_interval_list_test.py"],
-    python_version = "PY3",
     deps = [
         ":sorted_interval_list",
         requirement("absl-py"),
diff --git a/ortools/util/python/py_solve_interrupter.cc b/ortools/util/python/py_solve_interrupter.cc
index 20d7aef543..1e3c0bfa2a 100644
--- a/ortools/util/python/py_solve_interrupter.cc
+++ b/ortools/util/python/py_solve_interrupter.cc
@@ -57,7 +57,7 @@ PySolveInterrupter::CleanupAndGetTargets(
 
 void PySolveInterrupter::AddTriggerTarget(
     absl_nonnull std::shared_ptr<PySolveInterrupter> target) {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
   CleanupAndGetTargets();
   // Note that we don't test if targets_ already contain the interrupter as
   // interrupter are triggerable only once. Thus having duplicates won't result
@@ -70,14 +70,14 @@ void PySolveInterrupter::AddTriggerTarget(
 
 void PySolveInterrupter::RemoveTriggerTarget(
     absl_nonnull std::shared_ptr<PySolveInterrupter> target) {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
   CleanupAndGetTargets(/*to_remove=*/target.get());
 }
 
 void PySolveInterrupter::TriggerTargets() {
   std::vector<absl_nonnull std::shared_ptr<PySolveInterrupter>> targets;
   {  // Limit `lock` scope.
-    const absl::MutexLock lock(&mutex_);
+    const absl::MutexLock lock(mutex_);
     targets = CleanupAndGetTargets();
   }
 
diff --git a/ortools/util/sigint.cc b/ortools/util/sigint.cc
index bd4f40cfac..bc27d669d9 100644
--- a/ortools/util/sigint.cc
+++ b/ortools/util/sigint.cc
@@ -18,6 +18,9 @@
 #include <functional>
 
 #include "ortools/base/logging.h"
+#include "ortools/port/os.h"
+
+#if ORTOOLS_TARGET_OS_SUPPORTS_THREADS
 
 namespace operations_research {
 
@@ -67,3 +70,5 @@ SigtermHandler::~SigtermHandler() {
 thread_local std::function<void()> SigtermHandler::handler_;
 
 }  // namespace operations_research
+
+#endif  // ORTOOLS_TARGET_OS_SUPPORTS_THREADS
diff --git a/ortools/util/sigint.h b/ortools/util/sigint.h
index 1d9fcd1b81..11e78181ef 100644
--- a/ortools/util/sigint.h
+++ b/ortools/util/sigint.h
@@ -17,6 +17,10 @@
 #include <atomic>
 #include <functional>
 
+#include "ortools/port/os.h"
+
+#if ORTOOLS_TARGET_OS_SUPPORTS_THREADS
+
 namespace operations_research {
 
 class SigintHandler {
@@ -51,4 +55,6 @@ class SigtermHandler {
 
 }  // namespace operations_research
 
+#endif  // ORTOOLS_TARGET_OS_SUPPORTS_THREADS
+
 #endif  // OR_TOOLS_UTIL_SIGINT_H_
diff --git a/ortools/util/solve_interrupter.cc b/ortools/util/solve_interrupter.cc
index e494879385..2a0285c697 100644
--- a/ortools/util/solve_interrupter.cc
+++ b/ortools/util/solve_interrupter.cc
@@ -15,19 +15,17 @@
 
 #include <atomic>
 #include <functional>
-#include <memory>
 #include <optional>
 #include <utility>
 
 #include "absl/synchronization/mutex.h"
 #include "ortools/base/linked_hash_map.h"
 #include "ortools/base/logging.h"
-#include "ortools/base/strong_int.h"
 
 namespace operations_research {
 
 void SolveInterrupter::Interrupt() {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
 
   // Here we don't use compare_exchange_strong since we need to hold the lock
   // before changing the value of interrupted_ anyway. So there is no need to
@@ -53,7 +51,7 @@ void SolveInterrupter::Interrupt() {
 
 SolveInterrupter::CallbackId SolveInterrupter::AddInterruptionCallback(
     Callback callback) const {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
 
   // We must make this call while holding the lock since we want to be sure that
   // the calls to the callbacks_ won't occur before we registered the new
@@ -74,7 +72,7 @@ SolveInterrupter::CallbackId SolveInterrupter::AddInterruptionCallback(
 }
 
 void SolveInterrupter::RemoveInterruptionCallback(CallbackId id) const {
-  const absl::MutexLock lock(&mutex_);
+  const absl::MutexLock lock(mutex_);
   CHECK_EQ(callbacks_.erase(id), 1) << "unregistered callback id: " << id;
 }
 
diff --git a/ortools/util/time_limit.h b/ortools/util/time_limit.h
index 2fd664b182..23e0642d62 100644
--- a/ortools/util/time_limit.h
+++ b/ortools/util/time_limit.h
@@ -343,37 +343,37 @@ class SharedTimeLimit {
   bool LimitReached() const {
     // Note, time_limit_->LimitReached() is not const, and changes internal
     // state of time_limit_, hence we need a writer's lock.
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return time_limit_->LimitReached();
   }
 
   void Stop() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     *stopped_ = true;
   }
 
   void UpdateLocalLimit(TimeLimit* local_limit) {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     local_limit->MergeWithGlobalTimeLimit(time_limit_);
   }
 
   void AdvanceDeterministicTime(double deterministic_duration) {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     time_limit_->AdvanceDeterministicTime(deterministic_duration);
   }
 
   double GetTimeLeft() const {
-    absl::ReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(mutex_);
     return time_limit_->GetTimeLeft();
   }
 
   double GetElapsedDeterministicTime() const {
-    absl::ReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(mutex_);
     return time_limit_->GetElapsedDeterministicTime();
   }
 
   std::atomic<bool>* ExternalBooleanAsLimit() const {
-    absl::ReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(mutex_);
     // We can simply return the "external bool" and remain thread-safe because
     // it's wrapped in std::atomic.
     return time_limit_->ExternalBooleanAsLimit();
diff --git a/patches/BUILD.bazel b/patches/BUILD.bazel
index f73a6d5b4b..f58fc9c0ef 100644
--- a/patches/BUILD.bazel
+++ b/patches/BUILD.bazel
@@ -12,11 +12,6 @@
 # limitations under the License.
 
 exports_files([
-    "abseil-cpp-20250512.0.patch",
-    "protobuf-v31.1.patch",
     "pybind11_bazel.patch",
     "pybind11_abseil.patch",
-    "pybind11_protobuf.patch",
-    "pybind11-v2.13.6.patch",
-    "scip-v922.patch",
 ])
diff --git a/patches/abseil-cpp-20250512.0.patch b/patches/abseil-cpp-20250512.0.patch
deleted file mode 100644
index 78af605623..0000000000
--- a/patches/abseil-cpp-20250512.0.patch
+++ /dev/null
@@ -1,20 +0,0 @@
-diff --git a/absl/flags/declare.h b/absl/flags/declare.h
-index 8d2a856..a154046 100644
---- a/absl/flags/declare.h
-+++ b/absl/flags/declare.h
-@@ -59,10 +59,15 @@ ABSL_NAMESPACE_END
- 
- // Internal implementation of ABSL_DECLARE_FLAG to allow macro expansion of its
- // arguments. Clients must use ABSL_DECLARE_FLAG instead.
-+#if defined(_MSC_VER)
-+#define ABSL_DECLARE_FLAG_INTERNAL(type, name) \
-+  extern absl::Flag<type> FLAGS_##name
-+#else
- #define ABSL_DECLARE_FLAG_INTERNAL(type, name)               \
-   extern absl::Flag<type> FLAGS_##name;                      \
-   namespace absl /* block flags in namespaces */ {}          \
-   /* second redeclaration is to allow applying attributes */ \
-   extern absl::Flag<type> FLAGS_##name
-+#endif  // _MSC_VER
- 
- #endif  // ABSL_FLAGS_DECLARE_H_
diff --git a/patches/abseil-cpp-20250814.0.patch b/patches/abseil-cpp-20250814.0.patch
new file mode 100644
index 0000000000..ad52cb5629
--- /dev/null
+++ b/patches/abseil-cpp-20250814.0.patch
@@ -0,0 +1,125 @@
+diff --git a/absl/flags/declare.h b/absl/flags/declare.h
+index 8d2a856e..a1540467 100644
+--- a/absl/flags/declare.h
++++ b/absl/flags/declare.h
+@@ -59,10 +59,15 @@ ABSL_NAMESPACE_END
+ 
+ // Internal implementation of ABSL_DECLARE_FLAG to allow macro expansion of its
+ // arguments. Clients must use ABSL_DECLARE_FLAG instead.
++#if defined(_MSC_VER)
++#define ABSL_DECLARE_FLAG_INTERNAL(type, name) \
++  extern absl::Flag<type> FLAGS_##name
++#else
+ #define ABSL_DECLARE_FLAG_INTERNAL(type, name)               \
+   extern absl::Flag<type> FLAGS_##name;                      \
+   namespace absl /* block flags in namespaces */ {}          \
+   /* second redeclaration is to allow applying attributes */ \
+   extern absl::Flag<type> FLAGS_##name
++#endif  // _MSC_VER
+ 
+ #endif  // ABSL_FLAGS_DECLARE_H_
+diff --git a/absl/log/CMakeLists.txt b/absl/log/CMakeLists.txt
+index eb19bec0..13b2d240 100644
+--- a/absl/log/CMakeLists.txt
++++ b/absl/log/CMakeLists.txt
+@@ -47,6 +47,7 @@ absl_cc_library(
+     absl::base
+     absl::config
+     absl::core_headers
++    absl::has_ostream_operator
+     absl::leak_check
+     absl::log_internal_nullguard
+     absl::log_internal_nullstream
+diff --git a/absl/log/check_test_impl.inc b/absl/log/check_test_impl.inc
+index 5a7caf47..7bcedd40 100644
+--- a/absl/log/check_test_impl.inc
++++ b/absl/log/check_test_impl.inc
+@@ -13,6 +13,8 @@
+ // See the License for the specific language governing permissions and
+ // limitations under the License.
+ 
++// SKIP_ABSL_INLINE_NAMESPACE_CHECK
++
+ #ifndef ABSL_LOG_CHECK_TEST_IMPL_H_
+ #define ABSL_LOG_CHECK_TEST_IMPL_H_
+ 
+@@ -241,6 +243,18 @@ TEST(CHECKTest, TestBinaryChecksWithPrimitives) {
+   ABSL_TEST_CHECK_LT(1, 2);
+ }
+ 
++TEST(CHECKTest, TestBinaryChecksWithStringComparison) {
++  const std::string a = "a";
++  ABSL_TEST_CHECK_EQ(a, "a");
++  ABSL_TEST_CHECK_NE(a, "b");
++  ABSL_TEST_CHECK_GE(a, a);
++  ABSL_TEST_CHECK_GE("b", a);
++  ABSL_TEST_CHECK_LE(a, "a");
++  ABSL_TEST_CHECK_LE(a, "b");
++  ABSL_TEST_CHECK_GT("b", a);
++  ABSL_TEST_CHECK_LT(a, "b");
++}
++
+ // For testing using CHECK*() on anonymous enums.
+ enum { CASE_A, CASE_B };
+ 
+diff --git a/absl/log/internal/BUILD.bazel b/absl/log/internal/BUILD.bazel
+index 1ba9d766..005861f9 100644
+--- a/absl/log/internal/BUILD.bazel
++++ b/absl/log/internal/BUILD.bazel
+@@ -82,6 +82,7 @@ cc_library(
+         "//absl/base:nullability",
+         "//absl/debugging:leak_check",
+         "//absl/strings",
++        "//absl/strings:has_ostream_operator",
+     ],
+ )
+ 
+diff --git a/absl/log/internal/check_op.h b/absl/log/internal/check_op.h
+index 4554475d..c6078640 100644
+--- a/absl/log/internal/check_op.h
++++ b/absl/log/internal/check_op.h
+@@ -40,6 +40,7 @@
+ #include "absl/log/internal/nullstream.h"
+ #include "absl/log/internal/strip.h"
+ #include "absl/strings/has_absl_stringify.h"
++#include "absl/strings/has_ostream_operator.h"
+ #include "absl/strings/string_view.h"
+ 
+ // `ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL` wraps string literals that
+@@ -357,21 +358,12 @@ std::enable_if_t<HasAbslStringify<T>::value,
+                  StringifyToStreamWrapper<T>>
+ Detect(...);  // Ellipsis has lowest preference when int passed.
+ 
+-// is_streamable is true for types that have an output stream operator<<.
+-template <class T, class = void>
+-struct is_streamable : std::false_type {};
+-
+-template <class T>
+-struct is_streamable<T, std::void_t<decltype(std::declval<std::ostream&>()
+-                                             << std::declval<T>())>>
+-    : std::true_type {};
+-
+ // This overload triggers when T is neither possible to print nor an enum.
+ template <typename T>
+ std::enable_if_t<std::negation_v<std::disjunction<
+                      std::is_convertible<T, int>, std::is_enum<T>,
+                      std::is_pointer<T>, std::is_same<T, std::nullptr_t>,
+-                     is_streamable<T>, HasAbslStringify<T>>>,
++                     HasOstreamOperator<T>, HasAbslStringify<T>>>,
+                  UnprintableWrapper>
+ Detect(...);
+ 
+@@ -382,9 +374,10 @@ Detect(...);
+ // one backed by another integer is converted to (u)int64_t.
+ template <typename T>
+ std::enable_if_t<
+-    std::conjunction_v<
+-        std::is_enum<T>, std::negation<std::is_convertible<T, int>>,
+-        std::negation<is_streamable<T>>, std::negation<HasAbslStringify<T>>>,
++    std::conjunction_v<std::is_enum<T>,
++                       std::negation<std::is_convertible<T, int>>,
++                       std::negation<HasOstreamOperator<T>>,
++                       std::negation<HasAbslStringify<T>>>,
+     std::conditional_t<
+         std::is_same_v<std::underlying_type_t<T>, bool> ||
+             std::is_same_v<std::underlying_type_t<T>, char> ||
diff --git a/patches/fuzztest-2025-02-14.patch b/patches/fuzztest-2025-08-05.patch
similarity index 57%
rename from patches/fuzztest-2025-02-14.patch
rename to patches/fuzztest-2025-08-05.patch
index d288eb5418..d46f92ff34 100644
--- a/patches/fuzztest-2025-02-14.patch
+++ b/patches/fuzztest-2025-08-05.patch
@@ -1,8 +1,8 @@
 diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 1e34de3..dbacb91 100644
+index f9f71df..321caf5 100644
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
-@@ -13,7 +13,7 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
+@@ -28,7 +28,7 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
  elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    set (COMPILER_CLANG 1)
  else ()
@@ -12,22 +12,21 @@ index 1e34de3..dbacb91 100644
  
  if (COMPILER_GCC AND (FUZZTEST_FUZZING_MODE OR (FUZZTEST_COMPATIBILITY_MODE STREQUAL "libfuzzer")))
 diff --git a/cmake/BuildDependencies.cmake b/cmake/BuildDependencies.cmake
-index 1f4f08d..cc4d0ba 100644
+index d8565c0..24b7f52 100644
 --- a/cmake/BuildDependencies.cmake
 +++ b/cmake/BuildDependencies.cmake
-@@ -3,20 +3,20 @@ cmake_minimum_required(VERSION 3.19)
+@@ -17,20 +17,20 @@ cmake_minimum_required(VERSION 3.19)
  include(FetchContent)
  
  set(absl_URL https://github.com/abseil/abseil-cpp.git)
--set(absl_TAG 20240116.0)
-+set(absl_TAG 20250512.0)
+-set(absl_TAG d04b964d82ed5146f7e5e34701a5ba69f9514c9a)
++set(absl_TAG 20250814.0)
  
  set(re2_URL https://github.com/google/re2.git)
--set(re2_TAG 2024-02-01)
-+set(re2_TAG 2024-07-02)
+ set(re2_TAG 2024-07-02)
  
  set(gtest_URL https://github.com/google/googletest.git)
--set(gtest_TAG v1.14.0)
+-set(gtest_TAG v1.16.0)
 +set(gtest_TAG v1.17.0)
  
  # From https://www.antlr.org/download.html
@@ -35,12 +34,12 @@ index 1f4f08d..cc4d0ba 100644
  set(antlr_cpp_MD5 acf7371bd7562188712751266d8a7b90)
  
  set(proto_URL https://github.com/protocolbuffers/protobuf.git)
--set(proto_TAG v28.2)
-+set(proto_TAG v31.1)
+-set(proto_TAG v30.2)
++set(proto_TAG v32.0)
  
  set(nlohmann_json_URL https://github.com/nlohmann/json.git)
- set(nlohmann_json_TAG v3.11.2)
-@@ -27,7 +27,7 @@ if(POLICY CMP0135)
+ set(nlohmann_json_TAG v3.11.3)
+@@ -44,7 +44,7 @@ if(POLICY CMP0135)
  endif()
  
  FetchContent_Declare(
@@ -49,7 +48,7 @@ index 1f4f08d..cc4d0ba 100644
    GIT_REPOSITORY ${absl_URL}
    GIT_TAG        ${absl_TAG}
  )
-@@ -68,7 +68,7 @@ endif ()
+@@ -93,7 +93,7 @@ endif ()
  
  set(ABSL_PROPAGATE_CXX_STD ON)
  set(ABSL_ENABLE_INSTALL ON)
@@ -58,7 +57,7 @@ index 1f4f08d..cc4d0ba 100644
  
  set(RE2_BUILD_TESTING OFF)
  FetchContent_MakeAvailable(re2)
-@@ -76,6 +76,7 @@ FetchContent_MakeAvailable(re2)
+@@ -101,6 +101,7 @@ FetchContent_MakeAvailable(re2)
  set(GTEST_HAS_ABSL ON)
  FetchContent_MakeAvailable(googletest)
  
@@ -67,10 +66,10 @@ index 1f4f08d..cc4d0ba 100644
  
  if (FUZZTEST_BUILD_TESTING)
 diff --git a/cmake/FuzzTestHelpers.cmake b/cmake/FuzzTestHelpers.cmake
-index b907ff8..bcd3328 100644
+index 2869a77..8462fdd 100644
 --- a/cmake/FuzzTestHelpers.cmake
 +++ b/cmake/FuzzTestHelpers.cmake
-@@ -100,6 +100,13 @@ function(fuzztest_cc_library)
+@@ -114,6 +114,13 @@ function(fuzztest_cc_library)
        ${FUZZTEST_CC_LIB_LINKOPTS}
        ${FUZZTEST_DEFAULT_LINKOPTS}
      )
@@ -84,96 +83,46 @@ index b907ff8..bcd3328 100644
  
      set_property(
        TARGET ${_NAME}
-diff --git a/fuzztest/CMakeLists.txt b/fuzztest/CMakeLists.txt
-index 3d41c8b..7e4dc30 100644
---- a/fuzztest/CMakeLists.txt
-+++ b/fuzztest/CMakeLists.txt
-@@ -122,41 +122,43 @@ fuzztest_cc_library(
-     GTest::gtest
+diff --git a/fuzztest/internal/CMakeLists.txt b/fuzztest/internal/CMakeLists.txt
+index 61f6da8..84fe3a7 100644
+--- a/fuzztest/internal/CMakeLists.txt
++++ b/fuzztest/internal/CMakeLists.txt
+@@ -434,35 +434,6 @@ fuzztest_cc_library(
+     absl::cord
  )
  
 -fuzztest_cc_library(
 -  NAME
--    llvm_fuzzer_main
+-    subprocess
+-  HDRS
+-    "subprocess.h"
 -  SRCS
--    "llvm_fuzzer_main.cc"
+-    "subprocess.cc"
 -  DEPS
--    fuzztest::init_fuzztest
--    absl::flags
--    absl::flags_parse
--    GTest::gtest
--)
-+if (FUZZTEST_BUILD_TESTING)
-+  fuzztest_cc_library(
-+    NAME
-+      llvm_fuzzer_main
-+    SRCS
-+      "llvm_fuzzer_main.cc"
-+    DEPS
-+      fuzztest::init_fuzztest
-+      absl::flags
-+      absl::flags_parse
-+      GTest::gtest
-+  )
- 
--fuzztest_cc_library(
--  NAME
--    llvm_fuzzer_wrapper
--  SRCS
--    "llvm_fuzzer_wrapper.cc"
--  DEPS
--    fuzztest::coverage
--    fuzztest::domain_core
--    fuzztest::fuzztest
--    fuzztest::io
--    fuzztest::llvm_fuzzer_main
 -    fuzztest::logging
--    absl::core_headers
--    absl::flags
--    absl::log
--    absl::no_destructor
--    absl::random_random
--    absl::random_bit_gen_ref
+-    absl::flat_hash_map
+-    absl::function_ref
+-    absl::span
 -    absl::strings
 -    absl::string_view
--    absl::synchronization
--    re2::re2
+-    absl::time
 -)
-+  fuzztest_cc_library(
-+    NAME
-+      llvm_fuzzer_wrapper
-+    SRCS
-+      "llvm_fuzzer_wrapper.cc"
-+    DEPS
-+      fuzztest::coverage
-+      fuzztest::domain_core
-+      fuzztest::fuzztest
-+      fuzztest::io
-+      fuzztest::llvm_fuzzer_main
-+      fuzztest::logging
-+      absl::core_headers
-+      absl::flags
-+      absl::log
-+      absl::no_destructor
-+      absl::random_random
-+      absl::random_bit_gen_ref
-+      absl::strings
-+      absl::string_view
-+      absl::synchronization
-+      re2::re2
-+  )
-+endif()
- 
- ################################################################################
- # Internal
-@@ -484,6 +486,7 @@ fuzztest_cc_library(
-     "internal/logging.cc"
-   DEPS
-     absl::strings
-+    absl::synchronization
- )
- 
+-
+-fuzztest_cc_test(
+-  NAME
+-    subprocess_test
+-  SRCS
+-    "subprocess_test.cc"
+-  DEPS
+-    fuzztest::subprocess
+-    absl::strings
+-    absl::time
+-    GTest::gmock_main
+-)
+-
  fuzztest_cc_library(
+   NAME
+     table_of_recent_compares
 diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
 index 79ada1a..124c76b 100644
 --- a/tools/CMakeLists.txt
diff --git a/patches/protobuf-v31.1.patch b/patches/protobuf-v32.0.patch
similarity index 100%
rename from patches/protobuf-v31.1.patch
rename to patches/protobuf-v32.0.patch
diff --git a/tools/doc/doxygen_filter.py b/tools/doc/doxygen_filter.py
index 4fcb95b667..9fa6f7c4dd 100644
--- a/tools/doc/doxygen_filter.py
+++ b/tools/doc/doxygen_filter.py
@@ -78,7 +78,7 @@ class DoxygenFormatter:
             # or more spaces, pull it back to the left so doxygen's Markdown engine
             # doesn't treat it like a code block.
             (re.compile(r"(^\s*)//\s{4,}([-\d*].*)"), r"\1 \2", self.COMMENT),
-            # Replace TODO(user) in a comment with @todo (someone)
+            # Replace TODO(someone) in a comment with @todo (someone)
             (re.compile(r"TODO"), r"@todo ", self.COMMENT),
             # Replace leading 'Note:' or 'Note that' in a comment with @note
             (