Imagine you had a collection of systems each with their own constraints and objective functions to optimise (likely similar in form to each other), these then collectively aggregated into a 'super-system' which in turn had it's own constraints and objective function with similar parameters/IO, but different (and potentially conflicting) goals.
This, combined with other examples of the same now form another layer of a super-super-system, and so on...
A kind of layered recursive optimisation problem where each unit/layer wants to optimise itself, yet the greater whole above it and down each branch would also be optimised in parallel.
Does this make sense?
If so, what are the strategies and methods to solve such problems? Especially in the case of the system size causing complexity issues in an actual implementation.
I read about proximal algorithms and Douglas-Rachford Splitting, but they went over my head for the time being.
Any help appreciated.
What you are talking about is essentially decomposition, but in reverse. Decomposition works by taking a large, complex problem and breaking it down into smaller, more easily solved subproblems. You're talking about building a large model out of many small ones, but the idea is identical.
If your problem is nicely separable, then the main problem is just the sum of its parts. If the problem is inherently non-parallellizable but intractable without decomposition, then you have some headaches to sort out, the specifics of which depends on the problem.
A good example is decoding of LDPC codes (which are basically the standard codes used for almost all digital communication nowadays), which uses an algorithm based on message-passing between the variable 'nodes' to break up a large, complicated problem into easy subproblems.
This turns an NP-complete problem into something solvable in linear time. But there are plenty of caveats, because the problem is inherently not parallellizable, which causes convergence issues that have been a huge area of research for the last 20 or so years.
If your problem is a linear program, then you can use for example Dantzig-Wolfe decomposition which breaks the problem up into a bunch of subproblems, the solutions of which are combined by a master problem in each iteration.