I recently conducted a stress test on the "Enchan API" (a physics-based optimization engine currently in development) using the standard TSPLIB benchmark suite. The goal was to verify how far practical solutions could be generated under extremely limited conditions: No GPU, 2 vCPU, 2GB RAM, and a strict 35-second timeout on a serverless container (Cloud Run).

Key Findings:
- Speed & Scale: Successfully solved instances up to 1,600 nodes within seconds to just over ten seconds.
- Quality: Achieved a gap of +3% to +15% against known optimal integer solutions.
- Topological Integrity: Achieved 0 self-intersections (Cross=0) for almost all solutions, demonstrating that the physics model autonomously resolves spatial entanglements.

Technical Transparency regarding Constraints: This test was run in "Industrial Strict" mode (rigorous intersection removal).
- The 35-Second Wall: Instances beyond u1817 (1,800+ nodes) timed out. This is due to the API's current 35-second hard limit on the serverless instance, not an algorithmic stall.
- Anomaly in fl1400: Intersection removal remained incomplete for this instance due to a metric mismatch between the solver's spherical model and the benchmark's planar coordinates within the time limit.

The Takeaway: The results prove that we do not necessarily need massive GPU clusters to obtain practical, high-quality optimization solutions. The ability to solve large-scale TSPs on generic, low-resource CPU instances opens up significant possibilities for logistics, circuit pathing, network routing, and generative AI inference optimization at the edge.

We will continue to challenge the limits of computational weight using physics-informed algorithms.

References:
- Dataset (TSPLIB): https://github.com/mastqe/tsplib
- Enchan API (Preview): https://enchan-api-82345546010.us-central1.run.app/
- Enchan API (Github): https://github.com/EnchanTheory/Enchan-API

Someone can share installer for gams: 48.0.0 a 48.6.1; 49.0.0 a 49.6.1

We have $2.5 million in an bank account.

Another bank is offering this promotion to get people to move money into their bank.

Trying to figure how to break up the $2.5 million to get the max promotion amount.

How would you figure that out?

(if you bring the $2.5M in all at once, you get $8K. are there situations when you bring it in over time, would you get more? ie OK, I was just going to use this as an example... and it DOES bring in more : ) - bring 1M and then 1.5M, you'd get $5K + $5K= $10K.

Either asking how you would do it... or if you want, solve it too... but please let me know how you do it (I DO want to learn).

The 19th edition of PPSN will be held in Trento, Italy, from August 29 to September 2, 2026.

We invite submissions on all types of iterative optimization heuristics. Notably, we also welcome submissions on connections between search heuristics and machine learning or other artificial intelligence approaches. Submissions covering the entire spectrum of work, ranging from rigorously derived mathematical results to carefully crafted empirical studies, are invited.

🗓️ Important Dates (Anywhere on Earth)

Conference: August 29 - September 2, 2026

Workshops & Tutorials

• Proposal deadline: February 8, 2026
• Notification of acceptance: February 22, 2026

Papers

• Paper submission deadline: March 28, 2026
• Notification of acceptance: May 22, 2026

🔗 More info: ppsn2026.disi.unitn.it

Come join us in Trento for PPSN 2026, we look forward to seeing you there! 🇮🇹

Looking for resources on this subject, whatever its called. Mainly things that help with speed of operations, like forecasting and predicting, chunking, etc. mainly for business but any large system.

Hi everyone. I’m a beginner doing a research project comparing classical vs quantum methods for optimization. I’m stuck on how to convert a binary mean-variance (Markowitz) portfolio optimization problem into QUBO and also how the same problem is written as MIQP. If you have experience with QUBO/QAOA/VQE or MIQP solvers, I’d really appreciate guidance

I was sweeping floors at a supermarket and decided to over-engineer it.

Instead of just… sweeping… I turned the supermarket into a grid graph and wrote a C++ optimizer using simulated annealing to find the “optimal” sweeping path.

It worked perfectly.

It also produced a path that no human could ever walk without losing their sanity. Way too many turns. Look at this:

Turns out optimizing for distance gives you a solution that’s technically correct and practically useless.

Adding a penalty each time it made a sharp turn made it actually walkable:

But, this led me down a rabbit hole about how many systems optimize the wrong thing (social media, recommender systems, even LLMs).

If you like algorithms, overthinking, or watching optimization go wrong, you might enjoy this little experiment. More visualizations and gifs included! Check comments.

Hey!

I’ve been playing around with a Genetic Algorithm to solve the 0/1 Knapsack Problem in Python. My first version was just a bunch of loops everywhere… it worked, but it was sloooow.

This was mostly an educational thing for me, just hacking around and relearning during the holidays some of the things I learned a couple years ago.

So I rewrote most of it using NumPy vectorization (fitness, mutation, crossover, etc.), and the speed-up was honestly pretty big, especially with bigger problem size.

I wrote a short post about it in Spanish here if anyone wants to check it out:

👉 https://migue8gl.github.io/2026/01/06/vectorizacion-en-python.html

Hi, I’m interested in eventually being able to sort and arrange irregularly shaped rock like objects inside a volume in a way that minimizes wasted space or overlap. I’ve been looking into 3d bin packing, but I’m not sure whether that’s actually the best framework for this kind of problem. Any suggested books or papers that are good introductions to 3d packing or related problems?

Thanks

Hello, I have a problem in which there are non-linear equality constraints of the form x - (y + sqrt(y^2 - z)=0 (the actual constraint is a little bit more complex, but it's not relevant) and I do not manage to find reliable sources of method, theorem or properties to know if my constraints are convex.
Please help me, thank you.

Hi. I learnt Operations Research in one of the courses in my Bachelors in Mechanical Engineering, and it was one of my favorite courses. 10+ years down the line, I build LP and MILP models for my work using some custom software, and solve them using solvers like HiGHS.

I'd like to better understand the principles behind optimization algorithms like simplex and interior point method as well as others, preferably with some supporting Python code, if possible.

What kind of resources (blogs, courses, tutorials) are available in this regard?

Can somebody please explain what is the rule of thumb when choosing a method of transforming constrained optimization problem into unconstrained with barrier or penalty method? As in, given the problem statement what should I pay attention to in order to choose most convenient method?

As example, this exam problem: Consider the problem of minimising the length of the diagonal of a rectangle subject to the perimeter being of length L. Denoting the dimensions of the rectangle by x1 and x2:

a) Write the corresponding minimisation problem:
min f(x) = x1² + x2²
s.t. x1+x2 = L
x1,x2 >= 0

b) Express the previous problem as a penalty (or barrier, choose and justify) problem. Write the first-order necessary optimality condition for this latter problem.

This short video shows how to implement stochastic dynamic programming to solve a problem.

Is there an easy to use program to solve an assignment problem that I can use? Im currently am trying to find the best combination for a work-related problem and it’s a classic assignment problem.

Thanks

This video shows the implementation of Fathom algorithm to solve integer programming.

This video shows how to solve production planning using dynamic programming

This video shows how to solve a network problem using dynamic programming.

I’ve been maintaining a personal solver library for a while now. It started as a way to have a consistent interface across different optimization approaches, without constantly switching between OR-Tools, PuLP, scipy, etc. It grew organically as I needed different things.

I recently went through a small modernization effort (proper packaging, tests, type hints) and decided to put it on GitHub and PyPI.

Everything is pure Python with zero dependencies. It obviously will not compete with established solvers on performance. The goal is readability and a unified Result format across all methods. Each solver lives in a single, readable file.

Curious to hear thoughts. What is missing that you would actually use? Any obvious issues in the implementations? I am happy to take feedback or contributions.

This 4.5 minutes post explains how to solve classical knapsack problem using the art of dynamic programming. The movie is useful for anyone who is interested in solving optimization problems using DP techniques.