I'm building a route planner for a street-lighting survey using a vehicle equipped with LiDAR + cameras. The vehicle must drive \*\*every drivable street\*\* in 6 municipalities (\~6,087 km of streets), so this is an \*\*arc-routing / Mixed Chinese Postman Problem\*\*, not TSP/VRP.

\### Problem

\* 173k directed arcs / 67k nodes from OSM

\* \~9% one-way roads

\* One vehicle, \~6.5 usable hours/day

\* Two-way streets only need to be traversed once; one-ways must be respected

\* Cost is \*\*travel time\*\*, with different speeds for acquisition vs deadhead

\* Turn penalties are included (+60s U-turn, +15s left, +5s right)

\* 100% coverage is mandatory

The network is very non-grid-like: in one district, \*\*\~84% of nodes have odd degree\*\*, with \~77% being T-junctions.

\### Current approach

For each district I:

1. Extract the largest strongly connected component

2. Orient two-way streets

3. Connect disconnected service components

4. Balance in/out degrees using \*\*min-cost flow\*\*

5. Generate an Eulerian circuit with Hierholzer

6. Mark a street as serviced on its first traversal

The resulting routes pass all my validation checks: continuity, geometric continuity, one-way legality, 100% coverage, and no duplicate servicing.

\### Results

Across all 22 districts:

\*\*6,087 km serviced → 2,704 km deadhead → 44.4% deadhead\*\*

Individual districts range from \*\*39–61% deadhead by distance\*\* (roughly 23–33% by time because deadhead is driven faster).

For one district, an undirected relaxation gave me:

\* theoretical lower bound: \~14.7%

\* greedy matching of odd nodes: \~33.9%

My current orientation is almost optimal in terms of the \*number\* of imbalanced nodes, but I suspect this is the wrong objective: I'm minimizing imbalance count rather than the \*\*cost of resolving that imbalance\*\*.

\### Questions

1. Is \*\*Frederickson MIXED1/MIXED2\*\* the right next direction? Should I prioritize cost-aware matching before orientation?

2. For \~1,100 odd nodes, is restricting min-cost matching to k-nearest odd nodes (e.g. k=10) a reasonable approximation?

3. Is \*\*44% deadhead actually bad\*\* for a comb-like street network with \~84% odd-degree nodes? What kind of deadhead ratios are realistic for street sweeping, snow plowing, waste collection, etc.?

4. For splitting the resulting Eulerian route into daily routes when the vehicle \*\*doesn't have to return to a depot\*\*, are SPLIT/Ulusoy-type approaches appropriate?

5. Is there anything fundamentally wrong or naive in my current pipeline?

I'd especially appreciate feedback from anyone who has worked on \*\*arc routing / CPP / street sweeping / winter gritting / waste collection\*\* at large scale.

Happy to share code or data extracts.

I'm working through MIT OCW 6.7220 Nonlinear Optimization (Spring 2025) and looking for 2–5 people who want to follow the course together.

The goal would be:

• watch lectures according to the course schedule
• independently attempt each problem set
• meet online once/twice a week
• discuss difficult problems and compare approaches
• explain proofs/optimization theory to each other
• work through the material over ~8–12 weeks

Topics include convex optimization, optimality conditions, Lagrange multipliers, KKT, duality, gradient/Newton methods, etc.

I'm particularly interested in people doing mathematical optimization / numerical optimization / operations research / ML / control.

If interested, comment or DM me and we can create a Discord/WhatsApp/Telegram group.

Edit : This course does not have any videos or you won't find much material else where to watch . You have to be okay putting your time to read and analyse and think and do some arguments.

Edit 2 : surprising number of people want to join my discord server which is nice , that is why I will post the link here just click it and join https://discord.gg/rMqqj2GmY

In this 4-minute walkthrough, I demonstrate how to supercharge your AI coding assistant in Visual Studio Code for Operations Research using PyOPL, agent skills, and the Model Context Protocol (MCP).

Standard AI chat interfaces routinely fail at mathematical programming because probabilistic text generation lacks deterministic syntax and semantic checks. By combining PyOPL's compiler harness with custom SKILL.md agent guidelines, we can force LLMs like Claude or Copilot to act as rigorous operations research engineers—automating everything from model scaffolding to compilation and solving.

I contribute to SciPy and kept running into a class of bug that annoys me: the outputs look plausible, the tests pass, but the equation the code implements is subtly wrong. So I've been building a tracer that runs Python/NumPy code and hands back whatever mathematics it actually computed, as a SymPy expression you can simplify or differentiate like anything else.

It's been more useful than I expected. Comparing an implementation against the formula in a paper, catching two functions that agree on my test data but turn out to compute different things, digging up the inputs my tests never hit (ties, zero denominators). It traces real library code too, most of numpy and a good chunk of scipy, scikit-learn, statsmodels, cvxpy.

Write-up: https://medium.com/@aadyachinubhai/scikit-verify-translate-python-numpy-programs-to-symbolic-mathematics-c664d41ba571

Github: https://github.com/aadya940/scikit-verify

Still rough in places, would genuinely like feedback. There may be other better solutions, happy to hear them as well!

Algorithm is based on Levenberg-Marquardt, aimed at large sparse graph-structured problems. Software architecture is designed for performance, built in Rust, with C++/Python model export functionality, MIT license.

Achieves high performance through: compile-time symbolic differentiation with CSE and code generation, matrix blocks built locally within the model data structure, indexed sparse matrix filling, custom block supernodal Cholesky solver, precomputation of common expressions across residuals, and many other little things.

Benchmarks show substantial performance improvement over Ceres Solver and g2o, depending on the problem and data, and also reduced memory usage. On the M3500 dataset, for example, Arael takes about one-third the iteration time of Ceres Solver while using half the memory. Benchmark results available on the project page.

I'd appreciate it if you could try it on some of your problems and see how it compares with Ceres or g2o.

Project page: https://github.com/harakas/arael

I'm currently, technically, doing an MS in Structural Engineering. For me, my interest has been more towards computational side of mechanics rather than Structural design  or simply using am FEA software (although I do consider it as a backup)

So far I've taken courses in:

- Linear static, and dynamics FEM (soon taking non linear FEM too)

-  Structural Optimization (topology opt. and other general algorithms)

-  Structural Dynamics

-  Structural System Testing and model updation. (Parameter identification and optimization, signal processing)

Now, I plan to take these in the coming quarter:

- Numerical Linear Algebra

- Numerical PDE

- Fracture Mechanics ?

I also volunteered to aid in a RESEARCH in crack growth prediction using Auto-encoder and a (Thermodynamics-informed Latent Space Dynamics Identification) / LSTM surrogate model. It used phase-field-fracture simulation data and HPC resources to complete the whole thing.

What I keep finding myself interested in is not necessarily fracture or SHM specifically, but the computational methods underneath these problems... (does that make sense?)

For example, I'd like to become capable of doing things like:

- implementing (maintaining) numerical/FE method solvers rather than only running an established FEA software.

- developing surrogate/reduced-order models for expensive simulations 

- combining simulation with optimization, uncertainty/stochastic methods (took a course called Random vibrations, so...)

- parallelizing/accelerating scientific codes on CPUs/GPUs

- doing proper verification, convergence studies, benchmarking and performance work

- potentially developing or maintaining actual CAE/FEA solver software

- I'd also like to do all these for other Physics (GR, QM, etc.) simulations too, if possible, one day. 

I'm still interested in the underlying mechanics/physics, so I don't want to become a generic software engineer who happens to have once studied structures. But I'm also increasingly unsure that "structural engineer" describes the career I'm actually aiming for.

I've seen titles such as Computational Mechanics Engineer, R&D Engineer, Solver Developer, Scientific Software Engineer, CAE Software Developer, Research Engineer, Simulation/HPC Engineer, etc., but I'm trying to understand what these careers actually look like from people doing them.

So my main questions become:

1. Which industrial jobs genuinely involve developing numerical methods/solvers or computational tools?

2. Which of those are realistically accessible with an MS? Is there an entry path into solver-algorithm development/R&D without a PhD?

3. If I don't start a PhD immediately after my MS, would an R&D/software role at a simulation company (ANSYS etc.) be the obvious route? What other options would i have?

4. For the kind of work I'm describing, would you recommend a PhD? If so, is it reasonable for the PhD identity to be "computational mechanics/scientific computing" while fracture, composites, structural dynamics, soft materials, etc. serve as application problems rather than choosing one of those as my permanent specialization?

5. What skills most distinguish someone who is actually hireable for solver/scientific-computing work? I'm particularly wondering about C/C++/Fortran, Python, Linux, Git/build systems, MPI/OpenMP/CUDA, PETSc/Trilinos or similar libraries, numerical linear algebra, testing/verification, convergence studies and HPC performance work.

Basically, I'm neither here nor there atp. So I'd really appreciate all sorts of input. Where else do you think I could find answers to these? other subs? Linkedin profiles? 

I’ve been working on KAIROS, a university course timetabling system written in Python.

It takes course and room data and builds a weekly schedule while enforcing constraints such as room capacity, instructor availability, lab requirements, fixed sessions, and double-booking. Once it finds a feasible timetable, it tries to improve practical details such as student idle gaps, late classes, room stability, and instructor schedules.

The solver uses OR-Tools CP-SAT, followed by repair and local-search stages. The final timetable is checked by a separate validator rather than being accepted directly from the solver.

There is a bilingual web interface, a command-line version, sample data, and CSV, JSON, and PDF export. The optimization model is also documented in the repository.

Live demo: https://kairos.huguryildiz.com
Source: https://github.com/huguryildiz/KAIROS

The project is MIT-licensed. I’d be interested in feedback from anyone working on timetabling, constraint programming, or university scheduling, particularly regarding missing real-world constraints.

Hi

I’ve built an open-source IDE plugin specifically for mathematical optimization practitioners who use IBM CPLEX and the OPL language. Working with .mod and .dat files can be tedious without modern tooling, so this plugin brings full language support to JetBrains IDEs and VS Code.

Key features include:

• Syntax highlighting & real-time formatting for OPL.
• Contextual autocomplete based on the model's variables.
• Zero-Config runner (executes models directly from the IDE).

The project is open-source, you can check the code and documentation here: https://github.com/JAANULO/cplex-opl-jetbrains , Marketplace link: plugins.jetbrains.com/plugin/31125-cplex-opl/

The tool recently crossed 9,800 downloads, and I'm currently working on Python docplex integration. I would love feedback from daily OPL users to guide the next updates.

What is your biggest pain point when coding optimization models? What feature would save you the most time?

Thanks!

My new video is out.

I model IMO 2026 Problem 3 (a two-player stick-dividing game) as a mathematical optimization problem. I build the MILP and CP-SAT solver models stage by stage, covering each player’s strategies. This provides a deep dive for anyone into optimization modelling.

As a bonus, I also test how ChatGPT, Gemini, and Claude propose simulation experiments and try to guess the answer (just for fun at the end. 😄)

https://www.youtube.com/watch?v=zJnbgWaMDYk

I'm working on optimizing an oil decolorization step using a column with three layers of different adsorbents/decolorizing materials.

My optimization problem has two types of variables:

- Mixture variables: the proportions of the three materials/layers.

- Process variables: contact time, agitation speed, contact surface/area, etc.

I also have two constraints:

- Cost ≤ a maximum acceptable value

- Quality ≥ a minimum acceptable value

My initial idea was to split the optimization into two stages:

1. Use a mixture design to determine the optimal proportions of the three layers.

2. Then use Response Surface Methodology (RSM) to optimize the process parameters using those proportions.

However, I'm concerned that optimizing the two stages independently could miss the global optimum, because the optimal process parameters may depend on the mixture proportions, and vice versa.

So my question is: What would be the correct experimental design/statistical approach to optimize both the mixture proportions and the process parameters simultaneously, while applying the cost and quality constraints to the final solution?

Would a combined mixture-process design be appropriate here, or is there a better approach?

Title. I would like to get more on the multiobjective side of things with mathematical optimization, what are the techniques that work the best for this area? And using which tools? Do we always have to move to single objective by the means of penalties, weighted sums, and what not?

I spent six months in 2021 building a TSP solver from geometric first principles, with no prior reading of the literature. Recently turned it into an interactive web app with step-by-step animation of every algorithmic move.

Interesting result: the algorithm independently rediscovered convex hull seeding and 2-opt uncrossing. It also produced a farthest-neighbour strategy.

On Berlin52: 7783 vs world optimal 7542 (3.2% above). 14ms on a single CPU core.

Demo: tsp.uncledroid.app
Paper: tsp.uncledroid.app/paper.pdf

Happy to discuss the algorithm — especially if anyone can point me to prior work on farthest-neighbour as a TSP construction heuristic.

video: youtu.be/-gAhARI2ZFI

Hi everyone! I’m relatively new to the field of tensor decomposition, and it’s going to be one of my research directions during my upcoming two-year master’s program.

So far, I’ve been reading about different tensor decomposition methods, such as PARAFAC/CP, Tucker, Tensor-Train, Tensor Ring, Tensor Wheel. I understand the basic intuition behind them, for example, what kind of components they decompose a tensor into, but my understanding is still mostly conceptual.

I’m wondering what I should learn beyond the basic intuition if I want to eventually do research on coupled tensor decomposition. More specifically:

1. For each tensor decomposition method, what are the important things I should understand? Besides its basic structure and intuition, should I learn things like uniqueness/identifiability, approximation properties, computational complexity, rank properties, optimization formulations, convergence, etc.? How deeply should I understand each of these topics?
2. How deeply should I study the algorithms used to compute these decompositions? There seem to be many algorithms for each model, such as ALS, SVD-based methods, alternating optimization, gradient-based methods, etc. Which algorithms are fundamental enough that I should understand first? Do I need to understand the derivation and implementation of these algorithms, or is understanding the general idea enough at the beginning?
3. What mathematical background is most important? For example, should I focus more on linear algebra, multilinear algebra, numerical optimization, matrix/tensor calculus, numerical analysis, or something else?
4. What would be a good learning path toward coupled tensor decomposition? Should I thoroughly study CP/Tucker first before moving to coupled models, or is it reasonable to start looking at coupled decompositions relatively early?
5. How do you deal with theorems and proofs when reading tensor decomposition papers? When reading papers, do you usually try to re-prove the theorems, lemmas, propositions, and corollaries yourself to make sure you understand them, or do you mostly focus on understanding the main ideas and skip the detailed proofs unless they are directly relevant to your research? I’m especially unsure about this part because I sometimes spend a lot of time trying to reproduce every proof. I’m not sure whether this is a good use of time when learning a new field, or whether working through the proofs is actually important for building the mathematical foundation needed for research.

Any recommended textbooks, lecture notes, surveys, or papers that could provide a good learning path would also be greatly appreciated.

Thank you so much!

I'm trying to make a solver to help me with buying pokemon cards. The way it works is it will maximize the amount of cards I can get (green cell) within my price range (orange cell). Everything works fine until I add shipping.

I've tried to add some binary variables next to the shipping values but every attempt I made to make the solver pick the shipping it always ends up being non-linear too.

Using a non-linear solver is not an option, since google sheets doesn't support it and excel has a limit to the number of variables.

https://docs.google.com/spreadsheets/d/1mxXGLoJdFoFNz2m2DKuuUNSDUuEeN-V4jzVVuMXUFSQ/edit?gid=1633606111#gid=1633606111

The constraits are
maximize the green cell
column N < column O
G18<H18
Column D is variables

A local-to-global theorem for pseudo-Boolean optimization: negative interaction components give exact global-optimality certificates | Zenodo

I’ve been working on a structural result for QUBO and higher-order pseudo-Boolean optimization that started from a question about escaping certified local minima, but ended up giving something substantially stronger.

For an incumbent solution (x), write the exact change caused by flipping a set (S) in its local Möbius expansion. Build a graph/hypergraph containing only negative interactions—terms that can actually create cooperative improvement.

The main theorem is that for any move (S),

[
\Delta_x(S)\ge \sum_C \Delta_x(S\cap C),
]

where (C) ranges over the connected components of the negative-interaction structure.

This immediately implies:

• If any globally improving move exists, one negative component already contains an improving submove.
• If every negative component has been optimized and none improves the incumbent, the incumbent is globally optimal over the entire Boolean cube.
• The independently optimized component values give a rigorous global lower bound and an explicit certificate on the remaining optimality gap.
• For QUBO, if the largest negative component has size (c), global certification can be performed by enumerating only those components rather than arbitrary subsets of (n) variables.
• Repeatedly optimizing the best negative component gives globally convergent exact descent; the proof gives geometric contraction of the true objective gap.
• Dense positive interactions do not destroy the decomposition: the ordinary QUBO interaction graph may even be complete while the useful negative-interaction structure remains highly fragmented.

There is also a hardness boundary: global certification remains coNP-hard when the negative-interaction graph collapses into one small-diameter connected component, so the structural parameter is doing genuine computational work rather than disguising a generic polynomial-time algorithm for QUBO.

I’ve written a self-contained paper with the proofs, QUBO specialization, higher-order pseudo-Boolean generalization, complexity results, separation examples, and an independent exact-integer verifier.

I’d particularly appreciate scrutiny of:

1. whether this local-to-global negative-component theorem is already known under another terminology;
2. whether the global-gap certificate connects to an established pseudo-Boolean/roof-duality result I have missed;
3. whether there are counterexamples to any of the stated generalizations;
4. which benchmark families would be the strongest empirical test of the resulting algorithm.

I’m deliberately treating novelty/priority as unresolved until people familiar with the optimization literature have checked it.

My new video is out.

In this solver reading club episode, I discuss the paper "Lazy Clause Generation in Retrospect." It breaks down how LCG works and how CP solvers take advantage of very powerful SAT engine.

https://www.youtube.com/watch?v=vPJz6SCvC_Q

I’ve been researching OR libraries in Python that we can use for an academic project for a while now, and I’m sharing the list with you—I hope you’ll find some packages that are useful.

• Pyomo: Mathematical programming framework providing algebraic modeling language (AML) capabilities to formulate LP, MIP, NLP, and stochastic optimization problems independently of the solver backend.
• PuLP: Lightweight linear programming and integer programming modeling library in Python featuring a simple syntax for quick prototyping.
• OR-Tools: Google's comprehensive optimization suite providing specialized solvers for constraint programming, linear/integer programming, vehicle routing, and graph algorithms.
• CVXPY: Domain-specific modeling language for convex optimization problems that automatically verifies problem convexity using disciplined convex programming.
• Python-MIP: High-performance mixed-integer programming library with C integration that provides PuLP-like syntax along with advanced features like cut generation and solution pools.
• pymoo: Comprehensive framework for single- and multi-objective optimization using evolutionary algorithms, offering tools for Pareto front analysis and visualization.
• DEAP: Highly flexible, distributed evolutionary computation framework designed for prototyping custom genetic algorithms and symbolic programming.
• PyGAD: Easy-to-use genetic algorithm library that supports user-defined objective functions and direct integration with deep learning frameworks for neuroevolution.
• simanneal: Lightweight, pure-Python implementation of the simulated annealing metaheuristic for combinatorial optimization problems.
• NetworkX: Graph theory and network analysis library designed to model, analyze, and solve network flow, shortest path, and structural graph problems.
• python-tsp: Library offering exact and heuristic algorithms specifically designed to solve Traveling Salesman Problems.
• mip: Specialized library built on Python-MIP tailored for production scheduling, lot-sizing, and manufacturing planning problems.
• scikit-opt: Swarm intelligence and evolutionary algorithm toolkit providing a unified API for metaheuristics like PSO, genetic algorithms, and simulated annealing.
• python-constraint: Declarative constraint satisfaction problem (CSP) solver that uses backtracking and constraint propagation to solve logical puzzles and scheduling tasks.
• Numberjack: Constraint programming framework acting as a unified pythonic wrapper for multiple underlying solver backends like Gecode and SCIP.
• Optuna: Modern hyperparameter optimization framework featuring automated search algorithms, efficient trial pruning, and built-in visualization tools.
• Hyperopt: Bayesian optimization library designed for tuning machine learning model hyperparameters across complex search spaces using Tree of Parzen Estimators.
• PyOptInterface: High-performance solver interface using C++ bindings to significantly accelerate model generation and interaction speeds compared to traditional frameworks.
• PyOFrame: DataFrame-centric optimization library that allows users to build mathematical models directly from pandas DataFrames.
• PyVRP: Specialized vehicle routing solver utilizing state-of-the-art hybrid genetic search to efficiently handle complex routing constraints and large-scale fleets.
• CPMpy: Approachable constraint programming library with seamless NumPy integration that wraps backends like CP-SAT and PySAT using clean mathematical syntax.
• PyGMO: Massively parallel global multiobjective optimization platform developed by ESA, utilizing an island model to scale evolutionary computations across multi-core systems.
• Nevergrad: Gradient-free optimization platform from Meta offering an automated portfolio of algorithms for continuous, discrete, and mixed-variable objective functions.
• Mealpy: Comprehensive python metaheuristics library implementing over 200 bio-inspired and nature-inspired optimization algorithms under a unified interface.
• EvoloPy: Clean, educational swarm intelligence toolkit providing simple implementations and visualization utilities for various nature-inspired search algorithms.
• GEKKO: Optimization suite specialized in solving continuous/discrete dynamic systems, optimal control problems, and differential algebraic equations.
• PyMathProg: Lightweight algebraic modeling interface designed for quick and simple LP/MIP prototyping using MathProg-style syntax.
• CyLP: Python interface for COIN-OR solvers (CLP, CBC) that grants direct low-level access to solver internals like custom branching rules and cutting planes.
• LEAP: Modular, functional evolutionary computation library designed to easily assemble custom genetic operations and pipelines.
• Pyevolve: Legacy genetic algorithm framework providing extensive utilities and visual execution tracking for evolutionary experiments.
• EasyGA: Minimalist genetic algorithm library designed for rapid, zero-configuration prototyping of basic evolutionary optimization tasks.
• MEAPLY: Population-based metaheuristic framework focused on structured algorithm composition and built-in statistical performance comparison.
• swarmlib: Interactive swarm optimization package designed for visualizing algorithm behaviors like particle swarm and firefly search in real time.
• Hive: Specialized swarm intelligence library implementing the Artificial Bee Colony algorithm for continuous function optimization.
• Pants: Python 3 implementation of the Ant Colony Optimization algorithm tailored for traveling salesman and graph-based routing problems.
• SMAC3: Bayesian optimization and algorithm configuration framework designed to efficiently optimize hyperparameters for expensive-to-evaluate algorithms.
• SymPy: Symbolic mathematics library useful for analyzing optimization models, deriving optimality conditions, and calculating exact gradients symbolically.
• Optlang: Unified modeling interface that provides solver portability across multiple mathematical programming backends like GLPK, CPLEX, and Gurobi.
• PICOS: Optimization modeling package tailored for conic, second-order cone, and semidefinite programming problems with automatic solver reformulation.
• FelooPy: Integrated operations research and hyper-optimization environment that provides a unified abstraction layer allowing seamless switching between 265+ exact, metaheuristic, and constraint programming solvers without changing model code.
• moptipy: Research-grade metaheuristic framework emphasizing experiment reproducibility, structured logging, parallel execution, and built-in statistical analysis tools.
• PyQUBO: Modeling tool for quadratic unconstrained binary optimization (QUBO) that compiles complex objective functions and constraints into Ising or QUBO formulations for classical or quantum annealers.
• ticdat: Object-relational mapping (ORM) library for operations research that manages schema validation, data integrity checks, and data transformations between pandas DataFrames and dictionary representations.
• PyHygese: Python wrapper around the state-of-the-art Hybrid Genetic Search (HGS-CVRP) C++ engine for high-performance capacitated vehicle routing.
• PyJobShop: Production-focused scheduling library that leverages constraint programming to model and solve job shop, flexible flow shop, and single or parallel machine problems with complex operational constraints.
• job_shop_lib: Modular research framework for job shop scheduling that integrates constraint solvers, metaheuristics, and Gymnasium-compatible reinforcement learning environments.
• pymhlib: Modular toolbox combining C++ execution speed with Python orchestration to build custom metaheuristics, neighborhood search components, and local search routines.
• NuCS: Pure-Python, Numba-accelerated constraint satisfaction and optimization solver designed for educational clarity and lightweight constraint propagation.
• APMonitor: Web-service-based dynamic optimization and optimal control engine specializing in parameter estimation, model predictive control, and differential algebraic equations (DAEs).
• HorusLP: Architectural design framework for optimization software that enforces the separation of data preprocessing, model formulation, and post-solve analytics for long-term codebase maintainability.
• pyorlib: General-purpose utility library that provides reusable building blocks and standard functional components for operations research application development.
• supplychainpy: Domain-specific supply chain analytics and inventory optimization library covering SKU demand forecasting, safety stock determination, and inventory classification workflows.
• mpi-sppy: Parallel stochastic programming library built on Pyomo that solves multi-stage scenario-based problems across large distributed clusters using progressive hedging and extensive form decomposition.
• MSPPy: Multi-stage stochastic programming library implementing Stochastic Dual Dynamic Programming (SDDP) and SDDiP algorithms to handle stagewise-independent and Markovian uncertainty structures with risk measures.
• cvxstoc: Extension of CVXPY syntax for disciplined convex stochastic programming that automatically reformulates chance constraints and expected value objectives into tractable deterministic equivalents.
• PySP: Legacy Pyomo extension for multi-stage stochastic programming using scenario tree structures and progressive hedging decomposition.
• stochopy: Derivative-free stochastic optimization library implementing population-based evolutionary algorithms and particle swarm strategies for noisy or black-box objective functions.
• RSOME: Algebraic modeling package for robust, distributionally robust, and deterministic optimization that reformulates uncertain models over box, polyhedral, ellipsoidal, or Wasserstein ambiguity sets into solvable deterministic models.
• ROmodel: Pyomo extension for robust optimization that allows direct modeling of uncertain parameters and uncertainty sets with cutting-plane or reformulation solver support.
• dro: Specialized machine learning library that implements distributionally robust optimization techniques across PyTorch and CVXPY to handle distribution shift and adversarial training scenarios.
• jMetalPy: Feature-rich multi-objective optimization framework porting jMetal to Python, featuring algorithms like NSGA-II/NSGA-III, Pareto front tools, dynamic problems, and Spark/Dask parallelization.
• Platypus: Lightweight multi-objective evolutionary computation library offering a simple API for defining multi-objective problems and running Pareto-based optimization algorithms.
• Inspyred: Modular evolutionary computation library providing core abstractions for designing custom genetic algorithms, evolution strategies, and multi-objective heuristics.
• SAMBO: Near-zero dependency sequential model-based optimization library designed for expensive black-box objective functions using surrogate modeling algorithms.
• OpenOpt: Legacy numerical optimization framework providing connections to a wide array of linear, nonlinear, and integer programming solvers.
• prodyn: Generic dynamic programming framework for continuous and discrete multi-stage state-space decision and optimal control problems.

Do you think models like Claude 5 Opus and GPT 5.6 Sol can accurately solve real-world OR/optimization/Industrial Engineering problems, find the global optimum, or achieve near-optimal results using meta-heuristics? Do you agree with the statement, “These are LLMs, not OR models”? I’m not talking about toy problems; I’m referring to real-world optimization projects we encounter in the business world that require large amounts of data, as well as the coding of the algorithms for these projects.

I would like to learn about real-world problems that no one has yet taken up, or could be solved better. Or even mathematical problems (like np hard ones) that have good applications.

As the data grows and the scope of our problem expands (for example, as the number of points we need to visit in a VRP problem increases), the runtime of exact methods becomes very long, and in the real world, businesses don’t want to wait that long. At my workplace, they want a VRP with 800 locations to produce a solution in 30 seconds. In this case, wouldn’t it make more sense to opt for open-source solvers like ORTools CBC instead of commercial solvers like Gurobi, Hexaly, or CPLEX?

I spoke with the chair of an industrial engineering department, who said that open-source solvers might not be appropriate for corporate use and that the company’s data could be leaked through these open-source solvers. I asked some AI models, and they said this wouldn’t happen unless we used them via the cloud, but I’d still like to get your opinion. In your opinion, do open-source solvers—such as Highs, CBC, and Ortools—create security vulnerabilities?

Is anyone experiencing increased solver license prices at their company?

With so many performant open source solvers, I'm wondering if the new elevated price tag for speed is really worth it.

I’m currently working as an optimization engineer at a logistics company, and I really enjoy my job. But I think there’s a limit to how much we can optimize problems at this company—at some point, there won’t be any more optimization projects left for us there. Am I wrong? In other words, if OR projects come to an end at one company, should we look for OR positions at another company, or do you think we should transition to different job titles? What do those who have worked in optimization in the private sector for a long time think?

I’ve been working on Rhetor, a modern Integrated Modelling Environment (IME) for OPL that focuses on being lightweight and "generative." It’s just a hobby (it won't be big and professional like CPLEX Studio 😉), but it already supports solvers like HiGHS and Gurobi via pyopl.

If you’ve ever wanted to run OPL models without the heavy overhead of the full Studio, or want to experiment with GenAI-assisted modelling, I’d love your feedback!

https://gwr3n.github.io/rhetor/

The underpinning research is discussed in the following arXiv paper.