Skip to content

discopt v0.12.0

Latest

Choose a tag to compare

@jkitchin jkitchin released this 07 Nov 15:10
· 410 commits to main since this release
8c13df8

Highlights

  • Correctness. This release fixes a series of cases where a solve could report a certified (gap_certified=True) but wrong optimum. Several came from an outside soundness audit, among them:

    • the sign of nested powers in products (#2200),
    • the odd-power hull near zero (#2198),
    • sin/cos enclosures after argument reduction (#2190),
    • exponents and Hessians that were close to special values but treated as exactly special (#2191, #2192),
    • exact collection of cancelling like terms (#2090, #2097–#2100),
    • the bit semantics of .nl complementarity flags (#2056).

    Each fix ships with a regression test.

  • Complementarity and ReLU networks.

    • New relu_complementarity strategy.
    • discopt.mpec.solve_mpec(method="native") and solve_mpec_multistart.
    • Partition-based (Tsay et al.) and extended convex-hull (Anderson et al.) ReLU encodings, plus Anderson's ideal cuts.
    • Smooth ReLU-like activations (softplus, squareplus, Swish, GELU) with a sharpness beta.
  • Infeasibility diagnosis for MILPs. compute_iis(include_integrality=True) can name integrality as part of the conflict. It uses SAT, parity and exact certificates, and portfolio= runs several deletion orders in parallel. The browser page explains an IIS.

  • GDP. Feasibility-first fallback, the LOA proposer's proved bound, and certification of GDPlib syngas (hull and big-M) and cstr (big-M).

  • Defaults.

    • The open branch-and-bound frontier now has a memory budget (DISCOPT_FRONTIER_MEMORY_MB, 2 GiB).
    • pounce-solver>=0.16.
  • Tooling. Relaxation soundness fuzzers (scripts/fuzz/), and the developer /adversary command now has a soundness-fuzzing mode.

Known issues: on macOS/arm64, MINLPLib nous1 no longer certifies within 150 s with the new default DISCOPT_DUAL_PROOF_PROPAGATION (#2202); importing cyipopt and torch in one macOS process aborts (duplicate libomp). Details are below.


Added

  • Faster, smaller irreducible infeasible subsystems for MILPs (#2093, #2108,
    #2110–#2114, #2118, #2122).
    compute_iis(include_integrality=True) treats an
    integrality restriction as an IIS member and gains several candidate generators
    and confirmation routes, all decided exactly: an in-house CDCL SAT solver
    (discopt._rust.PySatSolver) for clause, cardinality and pseudo-Boolean rows; a
    GF(2) parity certificate for integer equality rows; a staged-oracle ladder for
    big-M models; and an exact decider that projects continuous columns out first
    (about 2000x faster on MIPcc27 otra). portfolio= / workers= run several
    deletion orders in parallel against one total_time_limit and return the
    smallest result; under a deadline the base set is confirmed up front, so a run
    that times out still returns a valid (if large) subsystem.

  • The browser page shows and explains an IIS (#2109): member table, a
    constraint–variable graph, and links back to the declaring line.

  • Smooth ReLU-like activations with a sharpness parameter (#2135, #2139).
    DenseLayer.beta for SOFTPLUS, SQUAREPLUS, SWISH (alias "silu") and
    GELU; the torch reader keeps Softplus(beta). Each activation is defined once
    (value, exact interval image, symbolic form) in discopt/ml/activations.py.

  • Stronger MILP encodings for trained ReLU networks (#2134, #2140):
    strategy="relu_partition" (Tsay et al. 2021) and strategy="relu_extended"
    (Anderson et al. 2020), plus the AndersonCutSeparator ideal-cut callback.

  • GDP primal heuristics. A feasibility-first fallback for the disjunct
    configuration search, default ON (DISCOPT_GDP_CONFIG_FEAS_FALLBACK; #2144,
    #2173); the root LOA proposer's proved bound now reaches the tree, so GDPlib
    syngas certifies under hull and big-M at 120 s (#2143, #2166).

  • Relaxation soundness fuzzers (#2200): scripts/fuzz/fuzz_relax_atoms.py and
    scripts/fuzz/fuzz_relax_trees.py search for a point that violates a relaxation
    bound and confirm it in mpmath. The developer /adversary command
    (discopt-dev adversary) is tracked in the repository again and documents the
    method as its soundness-fuzzing mode.

  • The benchmark harness refuses to run on a broken external solver (#2186). Each
    configured solver must solve a probe with a known optimum first; a missing or
    demo-licensed binary no longer shows up as a solver column of timeouts.

  • A discopt-expert subagent, the generalist beside the domain
    specialists. It knows the codebase as a whole: the repository map, the order
    Model.solve and solve_model route a model, how a status,
    algorithm_route or gap_certified traces back to code, how incumbents are
    verified, how to debug a solve, and the rules in CLAUDE.md for changing
    discopt. It routes each question to the specialist that owns it, and for
    POUNCE internals to pounce's pounce-expert (installed from pounce). It reads
    the source rather than answering from memory. It complements the discopt
    skill, which covers using discopt. Ships with discopt install-skills and
    uvx knowhow add jkitchin/discopt.

  • relu_complementarity strategy for ReLU networks (#2167, slice 1).
    NNFormulation(m, net, strategy="relu_complementarity") encodes each unstable ReLU
    neuron as y - s == z with a declared complementarity relation 0 <= y ⊥ s >= 0
    (new role ComplementarityRole.FROM_ACTIVATION, parent = layer, index = neuron)
    instead of an indicator binary and big-M rows; the relations are on nn.relations.
    They are registered but not lowered, so Model.solve() refuses until
    solve_mpec(m, nn.relations, method=...) picks "sos1"/"gdp" (exact; reproduces
    relu_bigm's certified objective) or "scholtes" (local). The strategy needs no
    input_bounds. Checked by python/tests/test_2167_relu_complementarity.py.

  • Multistart local mode for complementarity models (#2167, slice 2).
    discopt.mpec.solve_mpec_multistart(model, pairs, starts) and
    NNFormulation.solve_local(n_starts=...), which uses forward-pass warm starts from
    NNFormulation.local_starts. Each start runs a Scholtes continuation and then an
    active-set polish that leaves the point exactly complementary. A point becomes
    result.x only after accept_local_incumbent verifies it. The result is always
    local (local_optimal / local_infeasible, no bound), and result.multistart
    logs every start (a new SolveResult field).

  • Native complementarity lowering and branch (#2167, slice 3).
    solve_mpec(method="native") encodes each pair as f·g <= 0 over f, g >= 0.
    This is exact, has no binaries, and needs no finite bounds. With
    DISCOPT_COMPL_BRANCH=1 (default off) the spatial tree splits a violated pair
    into ub(f)=0 / ub(g)=0 before its other branching rules.

  • The GAMS link reads a discopt.opt option file. With optfile = 1, the link
    reads GAMS's usual solver option file and accepts three keys: tol and
    constr_viol_tol, forwarded to every POUNCE NLP the solve runs (as
    Model.solve(pounce_options=...)), and frontier_memory_mb, the open-frontier memory
    budget for that solve only. An unknown key, a bad value, a repeated key or a missing
    file ends the job as 9 Setup Failure with the offending line in the log, rather
    than solving at defaults the job did not ask for. Previously the link logged that
    optfile was ignored. See docs/gams_solver_link.md. Checked by
    python/tests/test_gams_option_file.py.

  • The browser page explains infeasibility. A new seventh example, an infeasible
    two-mill blending LP, calls compute_iis(). Any IISResult a script leaves in a
    top-level variable is now drawn below the output: a summary (member counts, model
    size, whether the IIS is proven minimal), a table of members with the variable
    elements each touches and a button that selects its declaring line in the editor, and
    a constraint–variable graph that also shows, dashed, the constraints outside the IIS
    that share its variables. The table holds everything the graph shows; membership is
    never shown by colour alone. Each run now gets a fresh namespace, so an earlier run's
    IIS is never redrawn. Data: crates/discopt-wasm/web/iis_view.py (served with the
    page, not in the wheel); drawing: web/iis_render.js. Checked by
    python/tests/test_wasm_iis_view.py, the Pyodide harness, node --test, and a new
    Chromium harness (crates/discopt-wasm/tests/iis_page.mjs, axe in both themes,
    320 px reflow) in the Browser page workflow. The example dropdown no longer scrolls
    the page sideways on a 320 px screen.

  • Exact lowering of box-constrained MCP relations (#2058). F(x) ⊥ z ∈ [l, u]
    (Model.mcp, mpec.box_mcp) used to be represented but refused at solve time.
    Every exact lowering (mpec.gdp, mpec.sos1) and Scholtes now reduce it to the
    existing NCP halves: a fixed box gives rows only; a one-sided box gives one
    half; a free variable gives F == 0; a two-sided box splits
    F == w⁺ - w⁻ with (w⁺, z - l) and (w⁻, u - z), where w± are bounded
    by the interval enclosure of F. A residual with a non-finite enclosure, an
    empty box, array bounds or declared residual bounds other than the box's own
    are refused with a ValueError, as is a box pinned at ±inf; a refused call
    (any relation of it, any element) leaves no rows behind and registers nothing.
    w± are enclosed over z restricted to the relation's own [l, u].
    Model.mcp(..., method="gdp"|"sos1") lowers on the spot.

Fixed

Correctness first. Every item below is a case where a solve could report
optimal (or infeasible) with gap_certified=True and a wrong objective or
bound; each has a regression test that fails before its fix.

  • Nested powers inside a product keep their sign (#2200). The canonicalizer
    folded (b^q)^e to b^(q*e) and (x*y)^e to x^e*y^e with no sign check, so
    x*(x**2)**0.5 became x**2 (true value -x**2 for x < 0) and
    1/(x**2)**0.5 became 1/x. Such a factor now folds as |b|, the exact identity
    wherever the expression is real. Found by the new relaxation soundness fuzzers.

  • The odd-power hull no longer uses the secant when the tangency is near 0
    (#2198, #2199).
    For t**p with odd p over a box whose lower end is a tiny
    negative number, the tangent search started at 1e-12 and missed a root near
    1e-16; the secant it fell back to lies above the graph. The trigger is
    ordinary: (1 - x)**3 with x in [0, 1] has the rounded enclosure
    [-2.2e-16, 1].

  • Sound sin/cos/tan enclosures after argument reduction (#2190, #2193).
    Reducing by the rounded 2*pi was not enclosed, so sin(1e15) came back as the
    point 0.850 (true 0.858). Endpoint values now come from the unreduced
    arguments, and extrema near a reduction boundary are counted conservatively. The
    same rounding was fixed at four other trig sites.

  • Exponents and Hessians that are nearly special are no longer treated as
    exactly special (#2191, #2192, #2195; #2194, #2197).
    np.isclose decided
    whether an exponent was 0, 1 or an integer, and |H| <= 1e-300 counted as a zero
    Hessian, so x**(1 - 2**-17) could be certified affine or a nonconvex model
    convex. Exact tests replace both, in the convexity layer and on the LP/QP routing
    path.

  • Like terms are collected exactly (#2090, #2097, #2098, #2099, #2100; #2094,
    #2106).
    (2**53*x + x) - 2**53*x is exactly x, but every float consumer read
    it as 0*x. A row whose coefficients cancel catastrophically is now rewritten
    from an exact Fraction collection, including array rows, sums that are exactly
    zero beside a large term, and verify_point called before solve. Collecting
    terms of a shared sub-expression no longer walks it as a tree (exponential time
    on deep sharing).

  • .nl complementarity rows use AMPL's flag semantics (#2056, #2057). The
    bound bits were swapped and the relation was taken against x instead of its
    bound.

  • Binary bounds are rounded after tightening (#2081, #2087), so a round-off of
    1.6e-13 can no longer invert a selector's box; LOA no longer stops on an
    unresolved re-proposal (#2082).

  • The default GDP hull path takes the Neumaier–Shcherbina safe bound on every
    ill-conditioned OBBT probe (#2088, in #2086)
    , which removes a false certificate on
    clay0303; spatial OBBT edges are safe bounds, and a box whose bounds cross by
    round-off is widened instead of panicking.

  • compute_iis no longer returns a feasible subsystem (#2093). Finite bounds
    of a partly free vector were applied in every probe but never reported; size-1
    variables also kept their shape on the POUNCE tape again.

  • Fewer sound certificates declined. The HiGHS MILP route accepts the
    fixed-integer LP's Neumaier–Shcherbina verdict (#2183, #2188) and certifies its
    round-off refusals on ReLU networks (#2187, #2189); the in-house Rust MILP engine
    certifies trained ReLU big-M MILPs that it used to leave undecided (#2163, #2165).

  • Deadlines. The per-node interval objective bound stops at the deadline
    (#2071, #2073); every step of a native GDP solve, including lowering, is charged
    to time_limit (#2079, #2080: stranded_gas overran 120 s by 97 s, now by 2 s);
    under deterministic=True, per-NLP wall caps are role-2 budgets, so the answer
    reproduces (#2120, #2124).

  • GDP robustness (#1917). LOA/RIC sub-NLPs keep a sparse Jacobian and Hessian
    and refuse an i32 KKT overflow instead of panicking (#2078); the hull splits an
    unboundable log(sum) operand instead of refusing the model (#2076); a raising
    disjunct-configuration constructor is logged at WARNING with its traceback, not
    DEBUG (#2138).

  • A failed pickle closes its children-first scope (#2180, #2181), which had
    left later deep expressions pickling recursively until RecursionError.

  • The HiGHS MILP route no longer certifies a feasible model infeasible (#2156).
    HiGHS's MIP answered kInfeasible on feasible models with continuous columns of width
    0 < xu - xl < 1e-6, and the route certified it, because each cross-check (the
    presolve-free solve, the other form, the coefficient-tightened form) ran the same MIP
    code. With every integer fixed at a feasible point, HiGHS still answered
    kInfeasible after zero LP iterations: domain propagation decided it. A HiGHS-only
    infeasible label on such a model is now reported as error, uncertified, with the
    reason. A Farkas proof of the root relaxation is still certified, and no optimal
    is affected. On the 30-network panel below, the unmerged relu_extended encoding
    had 8 false certified-infeasible results and now has none. The 89 correct
    certificates on the same panel are all kept. Checked by
    python/tests/test_2156_highs_sub_tolerance_infeasible.py, which includes a
    canary that fails once HiGHS stops mislabelling a shipped 13-row sub-model.

  • relu_extended and relu_partition certify trained ReLU networks (#2156).
    Networks with many weights near 1e-6 to 1e-8 gave relu_extended auxiliaries whose
    whole range was below HiGHS's feasibility tolerance. HiGHS then reported feasible
    models infeasible, with presolve on and off, or returned a wrong optimum. A partition
    whose range is at most NEGLIGIBLE_PARTITION_RTOL (1e-4) of its neuron's range is now
    folded into the neuron's widest partition. Any partition gives the same MILP, so the
    integer-feasible set is unchanged, and the LP loosens by at most that fraction per
    merged partition. On the issue's network relu_extended now certifies −6.37458671,
    agreeing with relu_bigm; before, it returned feasible with gap 0.69. On a
    30-network panel of 2-32-32-1 tiny-weight nets, relu_extended went from 0/30
    certified (24 wrong or no point, 8 of them infeasible) to 30/30 certified and equal
    to big-M; relu_partition with P = 4 went from 0/30 to 30/30. Checked by
    python/tests/test_2156_relu_negligible_partitions.py.

  • The in-house simplex certifies LPs with huge-but-finite bounds (#2125). A bounded,
    feasible multi-row LP with a finite variable bound in [1e10, 1e20) used to return
    SolveStatus.ERROR from lp_simplex.solve_lp. Measured on the issue's GDPlib
    batch_processing mbigm LPs at u >= 3e16: 7-8 of 40 agreed with HiGHS before, and
    40 of 40 now. On a seeded multi-row sweep it was 72 of 192, and is now 192 of 192.
    Three fixes, each held to the original LP's audit:

    • the row audit lets a row's own slack absorb its rounding;
    • a cold solve drops the huge sides and verifies the relaxation's answer;
    • an active huge bound is fixed and certified from duals.

    One case is still refused rather than certified: a vertex whose huge interior value
    sits in a binding row. DISCOPT_LP_HUGE_BOUND_RELAX=0 restores the previous engine
    (bit-identical on 257 LPs measured); an unrecognized value is an error.

  • The in-house MILP driver bounds nodes of translation-invariant masters
    (#2115).
    Its node bound (Neumaier-Shcherbina from the node dual) was -inf
    whenever an open column -- a free variable arrives split x+ - x- -- had a
    reduced cost zero only up to rounding. On MINLPLib m6's final OA master (42 of
    86 columns free) it abstained on 3194 of ~29k nodes, so without pyscipopt the
    #2069 confirmation could not close the master and m6 ended feasible at 60 s
    (bound 62.83, optimum 82.2569). A new last rung of the ladder
    (lp/simplex/project.rs) builds an enclosure of a nearby dual whose reduced
    costs on those columns are exactly zero and evaluates the bound rigorously over
    it. m6 now certifies in 14.8 s and m7 in 44 s with SCIP blocked; panel of 91
    instances cert-clean, certified 63 -> 64. Opt-out for A/B only:
    DISCOPT_NS_PROJECT=0.

  • Rounding residue of y no longer passes as a real sub-tol reduced cost
    (#2115 follow-up).
    The #1595 re-pricing judged d_j only against its own
    terms, so a single-entry open slack (d_j = -a y_i) always looked real however
    small y_i was; the simplex entered it, refused the resulting c^T d = 0 ray,
    and returned Numerical for an LP its dual had solved (13 LPs on m6's
    master, 6 on m7's). The noise test now also uses ||a_j||_1 ||y||_inf, and
    such columns go through the #1953 suspect verification. Panel cert-clean and
    outcome-neutral; shipped as a verdict fix. Opt-out:
    DISCOPT_SUBTOL_NOISE_GLOBAL=0.

  • A convex node's NLP objective is no longer imported as its lower bound
    (#2067).
    NLP-B&B (and the spatial loop's convex mode) used the objective of
    the node NLP's approximate minimiser as the node bound; it sits above the
    relaxation's optimum by the solver's residuals, and QPLIB_8153 certified a
    bound 1.57e-7 past a reference point feasible to 2.7e-15. Each convex node now
    imports a Neumaier-Shcherbina bound on its LP linearisation
    (discopt.solvers.convex_node_bound), valid at any point of the box; the NLP
    objective stays the incumbent value of an integral node, whose proved bound
    floors the tree bound (safe_fathom_floor in the tree stats; a
    point_values= argument on PyTreeManager.import_results). Opt-out for A/B
    only: DISCOPT_CONVEX_NODE_SAFE_BOUND=0.

  • Lowering-derived auxiliary bounds are re-derived at every solve (#2061
    review).
    The split w± of a box MCP, the SOS1 aux and the GDP operand lift
    of an NCP pair are bounded from an interval enclosure over the model's box at
    lowering time. Widening a variable afterwards (x.ub = 50 after declaring
    x <= 1) left that bound in place, and the stale big-M cut the optimum: a
    certified optimal -10 against a true -50. The NCP lifts had the same defect
    before #2058. Model.solve, solve_model and save now recompute every such
    bound (mpec.refresh_lowering_bounds; an unchanged model is left exactly as
    it was). A lowering read from a file carries no derivation, so widening a
    bound or moving a parameter it reads after load is refused at solve and save.
    An enclosure that reads discopt's default ±9.999e19 bounds now counts as
    unbounded rather than as a finite big-M.

  • Model.if_else's auxiliary box is re-derived at every solve and save
    (#2061 review).
    w = m.if_else(x >= 0.5, x, 2 * x) on x in [0, 1], then
    x.ub = 10, maximize(w) was certified optimal at 1 against a true 10:
    w's bounds were the branches' enclosure at declaration. Bounds the user sets
    on w are kept (the new derivation is intersected with them). A model read
    from a file has its if_else disjunctions recognised; a widening that the
    saved box no longer encloses is refused at solve and save.

  • A GDP-lowered complementarity whose side has no finite enclosure (typically a
    box relation whose z is declared free) is still refused at solve, but the
    error now names the relation and the side, and says to give z its own
    bounds; it used to stop at constraint '<unnamed>'.

Changed

  • The pounce-solver floor is now 0.16 (was 0.14 in v0.11.1; #2132 raised it to
    0.15 during this cycle)
    , for both the core dependency and the pounce extra.
    POUNCE 0.16.0 fixes a false infeasibility verdict at a point that satisfies the
    model (most visible under L-BFGS), makes declared complementarity much faster on
    large models (wide paired rows are lifted into a variable) and complementary to
    tol rather than sqrt(tol), and classifies two more convex infeasibility cases
    correctly. 0.15.0 added the declared-complementarity driver and capped the
    slack-row inertia perturbation. Neither has an in-memory solve report, so
    _pounce_report.py keeps its temporary-file route. The Pyodide wheel in
    crates/discopt-wasm/web/wheels/ is still 0.14.0; it is built in the POUNCE
    repository and is updated separately.

  • Flags graduated to default ON this cycle (the measurement behind each is in
    its PR and in docs/dev/flag-retirement-audit.md; =0 opts out):DISCOPT_ROUTE_ABANDON_CROSS_CHECK and DISCOPT_OA_SOC_OUTER
    (portfol_classical050_1 now certifies, #2059, #2064);
    DISCOPT_SUBNLP_REDUCED, DISCOPT_HEUR_FIXING_SCREEN,
    DISCOPT_ROOT_WARMSTART_FIRST, DISCOPT_GDP_LOA_PROPOSER,
    DISCOPT_GDP_LOA_PROPOSER_BOUND and DISCOPT_ROOT_PUMP_SKIP_WITH_INCUMBENT
    (#2143, #2166); DISCOPT_DUAL_PROOF_PROPAGATION and
    DISCOPT_HULL_EXACT_PERSPECTIVE (GDPlib cstr certifies under big-M, #2142,
    #2169); DISCOPT_HEUR_WALL_COST (#2176, #2175);
    DISCOPT_GDP_CONFIG_ROOT_SKI (#2182, #2184).

  • The root-pump skip requires a closed gap (#2170, #2175). It skipped both root
    feasibility pumps whenever any incumbent existed; it now requires that incumbent
    to meet the solve's own gap test.

  • DISCOPT_OBBT_NS_STRICT (#2077), a documented opt-out (default OFF):
    tighten OBBT/DBBT only to the Neumaier–Shcherbina safe bound.

  • Bound-neutral speedups. The nonlinear FBBT scan skips rows a rule
    structurally cannot match (#2159); curvature proofs that must abstain are skipped
    when the Hessian at a point of the box is provably indefinite (#2160); the
    multiple-big-M GDP LP relaxation is sparse and memoized (#2075).

  • Measured and not adopted, so absent from this release: per-LP caps on
    persistent OBBT probes (#2065, #2068), DISCOPT_HULL_PLAIN_EQUALITY (#2137),
    DISCOPT_SUBNLP_FBBT_BOX (#2141), DISCOPT_ROOT_FIXPOINT_EVEN_SPLIT (#2162),
    DISCOPT_NLP_LADDER_SCOPED (#2161, retired in #2177) and
    DISCOPT_KERNEL_PRESOLVE (#2168, #2171). Their measurements are in
    docs/dev/flag-retirement-audit.md.

  • The open branch-and-bound frontier has a memory budget, on by default (#2092).
    DISCOPT_FRONTIER_MEMORY_MB (default 2048 MiB; 0 = no budget) becomes an open-node
    cap for the native spatial kernel and the Python-tree loops. A search whose gap never
    closes keeps every frontier node live, and on 1-hour runs that reached 28–42 GiB. A
    solve with no max_nodes can therefore now end with node_limit once its frontier
    reaches the budget (never before 1,000 open nodes), with the incumbent and a valid
    bound; it stops, it never prunes. Raise the budget on a machine with more memory, or
    set 0 for the old unbounded behaviour. The same release cuts what each open node
    stores (measured: about 37% less frontier growth in the native kernel, 48% less per
    open node in the Python tree): sibling nodes share their parent's box, and in the
    Python tree also the parent solution and basis.

  • .nl complementarity rows with flag 3 (both bounds) or flag 0 (free
    variable) are now imported (#2058)
    as a box MCP and as body == 0
    respectively, instead of refused. Flags 1/2 are unchanged.

  • OA convexity certification uses a Taylor form for one-variable rows (#2062). A row whose
    curvature depends on a single variable is now tested piece by piece with a Taylor expansion
    of f'' with a Lagrange remainder (new _relax/convexity/interval_jet.py) before #2054's
    interval-Hessian bisection. The PFR rows (1-k)(e^t-1)/(e^{(1-k)t}-1) and
    (1-k) t e^t/(e^{(1-k)t}-1) now certify in ~50 pieces instead of 2048-8192, so they get OA
    cuts. On a 40-model reactor-choice panel under gdp_method="loa": certified 20 -> 25,
    0 lost, LOA iterations 93 -> 48. Default ON; DISCOPT_OA_CONVEXITY_TAYLOR=0 restores the
    previous behaviour.

Known issues

  • On macOS/arm64, MINLPLib nous1 no longer certifies within 150 s (#2202).
    With DISCOPT_DUAL_PROOF_PROPAGATION on (the new default) the tree stalls at a
    valid bound of 1.3457 (optimum 1.5671); with DISCOPT_DUAL_PROOF_PROPAGATION=0 it
    certifies in about 11 s. Linux is not affected (25.5 s with the flag on). No bound
    or answer is wrong. Bisected to #2169.
  • On macOS, importing cyipopt and then torch in one process aborts it
    (OMP: Error #15: two copies of libomp). This is an interaction between those two
    packages' bundled OpenMP runtimes, not discopt code, but it affects a process that
    uses nlp_solver="ipopt" and the torch reader together, in either import order.
    Run the two in separate processes until the runtimes are reconciled.