Simon Sapin,
\nI play Factorio the normal way: by writing matrix math code to plan the factory.
\nBut we’ll get to that.\nOr, TL;DR, go to my new online calculator tool.
\nFactorio pretty much founded the factory video game genre:\nyou play a character who harvests resources and combines them to craft increasingly complex items,\nwhich in turn enable more sophisticated crafting.\nSo far this sounds a lot like Minecraft and many other survival games,\nbut what sets factory games apart is the focus on automation:\nsoon enough, most of the crafting is done not “by hand” by the character\nbut by increasingly many machines,\nwith various forms of logistics like conveyor belts to move items between machines\nor wherever they need to go.\nSome factory game go further and remove the player character altogether.
\nAs “technologies” are unlocked in-game, Factorio offers many mechanisms to improve production. One of them is modules: crafting machines have a (limited) number of slots to accept different kinds of modules that affect their stats: speed modules make the machine run faster at the cost of more energy consumption, productivity modules increase yield from the same ingredients at the cost of speed and energy, etc.
\nReleased in 2024, the Space Age extension adds new game mechanics including Quality:\nevery item and recipe now come in five quality tiers:\n⚀ normal, ⚁ uncommon, ⚂ rare, ⚃ epic, and ⚄ legendary.\nDepending on the item, each tier improves stats such as making crafting machines faster\nor making productivity modules more productive.\nHigh-quality items can be crafted directly from ingredients of the same quality,\nbut the only way to increase quality is through the new quality modules.
\nModules affect the probability of any quality increase. For a given craft, each quality tier increase after the first is another 10% chance. We can build a table of the probabilities of output quality depending on input quality:
\nFor example, the maximum possible quality chance in a machine with four module slots is 24.8%:
\nSome players dislike the introduction of randomness\nto a game that was mostly deterministic, but\nwith enough repetitions probabilities become ratios.
\nThe probabilities are balanced so that even with multiple crafting steps (each a potential quality jumps), getting high-quality items unavoidably involves also crafting many unwanted low-quality ones.
\nTo avoid the factory grinding to a halt when storage eventually gets full, Space Age also introduces the recycler: a new machine that destroys any item and (usually) returns 25% of its ingredients. This enables players to design “upcycling” contraptions that craft and recycle in a loop with quality modules until items reach the desired quality, at the cost of consuming many more ingredients:
\nSome video games are partly “played” outside of the game itself.\nBlue Prince fully expects its players\nto keep extensive notes of everything they see,\nbut doesn’t provide an in-game notepad or similar tool.\nFactory games lend themselves\nto building large spreadsheets for resource accounting,\nbut a select few players decide that spreadsheets are not powerful enough for factory planning\nand spent countless hours programming dedicated tools\nthat reproduce much of the game’s math to accurately model a production chain.
\nThis is all optional in factory games, it’s perfectly viable to play it by ear and just build more when seeing something lacking.
\nBut I do like to plan in advance: how many machines of each kind do I need? How much yield can I expect? Where are the bottlenecks? The looping nature of quality upcycling makes this particularly challenging either to guess, or to calculate with existing tools.
\nLet’s imagine:
\nLet’s track the possible fates of one item:
\nA product of a given tier can come from ingredients of the same tier or lower. The total probability for this outcome is the sum of (independent) probabilites of different ways to get it. In turn, those are the product of the percentage chance of a specific quality jump times the probability of having the corresponding ingredient tier in the first place:
\n(The percent sign can be thought of as implicit division by 100, so that “percentage of” is the same as multiplication.)
\nHere the percentage coefficients look transposed\nacross the diagonal compared to the quality jump probability table from the wiki,\nbut that’s only because we’ve arranged product tiers vertically.\nInstead let’s group the probabilities of different tiers of the same item into row vectors:
\nNow our system of linear equations\ncan be written as a single equation where a vector\nis multiplied by\na transition matrix\nthat matches the wiki’s table:
\nAs an edge case, zero quality chance means no tier transformation.\nThe corresponding transition matrix is\nthe identity matrix:
\nThis may not seem like much progress, but now a multi-step process can be computed through successive matrix multiplication. For example mining iron ore with 7.5% quality chance, then smelting it into iron plates with 5% quality chance, then crafting pipes with 10% chance. With no productivity bonus, we get these probabilities of end-products:
\nWhile it is possible to use quality modules as much as possible and deal with\nEvery tier Everywhere All at Once,\nhere we’ll focus on smaller self-contained systems.
\nThe easiest but also least effective is to craft from normal-quality ingredients, with quality modules, and not recycle anything. This can be done before unlocking the recycler but is only viable for a small number of items, such as crafting a few hundred asteroid collectors to hope to get a dozen uncommon or rare ones for an early space ship.
\nThis is improved when the factory has another use for normal-quality items. For example if placing thousands of normal-quality solar panels on the ground, crafting them with quality modules gives a better yield of higher-quality ones for space ships before the output buffers fill up.
\nWith a single step and no loop, this is simplest to calculate: the expected product tier distribution is the first row of the transition matrix or of the probability table found on the wiki.
\nFor most items, the recycler reverses the main crafting recipe and returns 25% of the ingredients. But some items don’t have a crafting recipe (like ore) or it is considered irreversible (typically smelting and chemical processes). In that case the recycler produces either nothing or, 25% of the time, the same item. This process can improve quality if the recycler has quality modules. Repeating it in a loop, eventually all items will be either destroyed or improved until they reach any desired quality tier. Self-recycling items is arguably not the common case but let’s start here since the math is simpler.
\nLet’s consider one item injected into the system, in this case from mining, and call the 5-component row vector of probabilities of each quality tier.
\nAfter we transform that vector, the new probabilities may add up to less than one. The implicit remaining case is not having an item at all at a given place. For example, the recycler producing nothing 75% of the time can be represented by multiplying a vector of probabilities by .
\nFiltering based on quality can also be represented with matrix multiplication. In the case of extracting rare or above:
\nThe combined effect of one iteration through the loop is filtering to keep, then recycling with quality:
\nNow let’s consider the possible ways an item can be extracted:
\nAny given item will eventually be extracted or destroyed, but there is no upper bound on how many loops that can take. The combination of all possible outcomes is an infinite sum:
\nInfinite sums are rather inconvenient to calculate in finite time,\nalthough this one does converge to a finite value since the terms become exponentially smaller.\nWe could compute until the terms because small enough for an approximation,\nbut that would be unsatisfactory when an exact solution is possible.
\nThe key insight is that\nit doesn’t matter how many times a given item has already been through the loop,\nonly what quality tier it has now.\nOn a short time scale this will vary because of the random effect of quality modules\nbut with enough repetitons\nprobabilities become ratios.
\nSo instead of probablities for a single item\nlet’s consider the average rate of items over a long enough period of time\ngoing through a given part of the system,\nagain as a 5-component vector for quality tiers.\nThese vectors can be multiplied by the same transition matrices as before.\nIn the case of a “washing” pure recycling loop, the relevant vectors are:
\nWe treat and as a fixed parameters and other vectors as unknowns we want to resolve.
\nThe system converges to a dynamic equilibrium where the following equations hold for long-term averages:
\nWe can rearrange and substitute:
\nTranspose to get column vectors instead of row vectors and match the\nclassic convention:
\nIntroduce some new names:
\nNow we have equilibrium as a system of linear equations in the classic form,\nthat we can solve for \nusing Gaussian elimination.\nFrom we can easily compute ,\nthen (for the number of recyclers needed)\nand (for the overall yield of the system).
\nIf the example setup above was scaled to mine 100 ore per second, the parameters would be:
\nAnd the solution with Gaussian Elimination:
\nConverting from per second, the extracted rates are close to 90 per minute rare, 9 per minute epic, and 1 per minute legendary.
\nFor another example:
\nSolving the equation gives:
\nSo for items that recycle to themselves, “brute-force” washing consumes on average\n normal-quality inputs for every legendary output.\nThis matches the ratio that others have calculated.\nThe recycling capacity required is just shy of of the fresh input rate.
\nFor items where recycling does return ingredients,\nwe can chain crafting machines with recyclers to form a loop:
\nMost crafting recipes require multiple ingredients in various quantities, but here we’ll abstract over this and consider “the set of ingredients for one craft” as the base unit for our measurements. In this example, each machine crafting construction robots can consume 4 electronic circuits per second and 2 flying robot frames per second, but we’ll call that “2 ingredients per second”.
\nSo we’re measuring long-term avarage rates of ingredients and products, each in five quality tiers, but they only appear in separate parts of the system so we’ll stick with 5-components vectors and don’t need to move to 10-dimensional math. (Wink wink foreshadowing)
\nThe example setup has fresh normal-quality ingredients brought by robots into the blue requester chest,\nand extracts legendary products.\nIn the general case, we could imagine ingredients or products of any quality distribution\nbeing produced elsewhere and injected into the system.\nSimilarly, we could decide to extract products or ingredients (or both) of any quality tier.\n(Sometimes an ingredient may be more useful than a product to have in high quality,\nbut upcycling that specific product may have better yield than other methods.)
\nSo the 5-component row vectors we’ll consider are, for ingredients:
\nAnd for products:
\nWe treat and as fixed parameters, and other vectors as unknown we want to resolve.
\nAgain the transition matrices for filtering based on quality tier are complementary parts of the identity matrix. In this example:
\nWe account for a crafting which is 0% in this example but could be greater with some crafting machines or with productivity modules. The quality chance may also be different for crafting v.s. recycling (for example when crafting with productivity modules, or based on the machine’s number of modules slots).
\nFor short(er), let’s call:
\nThe system converges to equilibrium where:
\nWe can rearrange and substitute:
\nLet’s introduce a couple more names:
\nWe’ve again massaged our problem into the standard form with:
\nSolving for gives us , and plugging that into the original equilibrium equations gives everything else.
\nIn the example setup above, scaled for now to an arbitrary unit, the parameters are:
\nAnd the solution with Gaussian Elimination:
\nIn practice, the bottleneck of this system is the crafting speed of normal-quality products: 360 per minute. So let’s multiply everything by
\nIn conclusion, this system produces on average almost 2 legendary construction robots per minute, and consumes about 309 sets of ingredients (309 frames + 618 circuits) per minute.
\nFor a select few items in Space Age, the productivity bonus can be increased through repeatable research. The game enforces a hard cap of +300% bonus so that crafting then recycling returns at most the ingredients that we started with, never more.
\nProductivity research levels get exponentially expensive so let’s assume that we use also productivity modules to reach the cap, meaning we don’t have quality modules in crafting machines. And this time, let’s inject fresh products instead of ingredients.
\nOur model predicts:
\nPerhaps surprisingly, the rates for intermediate quality tiers are identical.
\nA maximal productivity bonus enables turning a normal quality product into a legendary one without any ressource loss, at the cost of many machines and modules to get significant throughput.
\nIn Space Age, each space platform is a mini-factory. Instead of mining ore from the ground they collect asteroid chunks and crush them to get resources. Those can be used for a space ship’s own fuel and ammunition, or to feed a production chain in space whose end-product is sent to a planet’s ground.
\nThree different types of chunks (metallic, carbonic, and oxide) yield different ressources and are more or less frequent in different regions of the solar system. Asteroid chunks can be “reprocessed” for a chance to get a different type (or nothing).
\nAssuming enough crushers with each recipe, we can represent this process mathematically as multiplying a row vector by a square 3×3 transition matrix:
\nReprocessing also accepts quality modules so it can be used in a loop much like “washing”. Crushing legendary chunks yields legendary versions of some base resources that can be used for crafting other legendary items.
\nThis time we’ll have conveyor belts transporting asteroid chunks of any of three types,\neach in any of five quality tiers, for a total of 15 possible items.\nWe’ll represent this with 15-component row vectors and 15×15 transition matrices.\nWe build up the latter as block matrices\nmade of nine 5×5 blocks:
\nAside from the higher dimension, the math is the same as for washing and we end up with a system of linear equations to solve for , with:
\nAsteroid crushers have two module slots, so the best possible quality chance for reprocessing is . Asteroid collectors don’t have any module slot, so freshly-collected chunks are always normal-quality. We build the 15-component vector from its 3 components for normal-quality rate of each asteroid type (metallic, carbonic, oxide). For example in Nauvis orbit:
\nLet’s say that we only extract legendary oxide chunks and reprocess everything else. Solving the equation gives two complementary 15-components row vectors and that we can rearrange into 3×5 tables
\nExample: in Nauvis orbit, extract legendary oxide chunks and reprocess everything else:
\n| To reprocess | |||||
|---|---|---|---|---|---|
| ⚀ | ⚁ | ⚂ | ⚃ | ⚄ | |
| Metallic | 1.31616 | 0.33791 | 0.13314 | 0.05286 | 0.0175 |
| Carbonic | 1.11409 | 0.33244 | 0.13245 | 0.05277 | 0.01748 |
| Oxide | 0.91202 | 0.32697 | 0.13175 | 0.05268 | 0 |
| Extracted | |||||
| ⚀ | ⚁ | ⚂ | ⚃ | ⚄ | |
| Metallic | 0 | 0 | 0 | 0 | 0 |
| Carbonic | 0 | 0 | 0 | 0 | 0 |
| Oxide | 0 | 0 | 0 | 0 | 0.01398 |
We observe:
\nThere are other ways to get quality items that don’t neatly fit in the categories above\n(honorable mention to “The LDS Shuffle”)\nand I’m sure folks will come up with more.\nBut if a loop makes it tricky to calculate their behavior we can use the same ideas:
\nDoing matrix math by hand is obviously tedious and error-prone, let’s have computers do it for us.
\nI started with Rust out of habit.\nnalgebra works out great for the matrix math we do here.\nIn includes multiple solvers for systems of linear equations,\nbut those pretty much require the scalar type for matrix and vector components\nto be a floating point number f32 or f64, whereas the base library is more generic.
In practice floating point would be perfectly adequate, but it is a fixed-precision approximation so every step of computation potentially introduces some error. Wouldn’t it be nice to get an exact result, just because we can? The matrix sizes and number of operations are fixed and relatively small, so we don’t need to optimize the code for speed.
\nEvery operation we use is ultimately addition, substraction, multiplication, or division.\nSo if all of our parameters are rational\nthe result will be too.\nnum_rational represents rationals extactly\nas a pair of (generic) integers.\nI could reach for some infinite-precision BigInt library if needed,\nbut the built-in i128 with\noverflow checks\nturns out to be sufficient for 15×15 martices.\n(i64 is sufficient for 5×5.)
At this point I had a functional Rust library doing all of the math above,\nbut editing source code to tweak parameters isn’t a nice user experience.\nI’d much prefer something like Factoriolab.\nAnd to be easy to use by other people it really should be on the web.
\nMy Rust code can be compiled to WebAssembly but then I would need to either:
\nBuild the entire GUI with Rust + wasm as well.
It’s possible but the tooling\nisn’t great yet
So I ended up rewriting the whole thing in TypeScript.\nBigInt\nis built-in,\nFactoriolab already has a good open-source\nrational library,\nand making a generic matrix library isn’t too hard.
As to building an interactive GUI in the browser, last time I did much of it jQuery was the hot new thing. I didn’t feel like learning React so I settled on:
\nAll together, factoqual.grebedoc.dev now provides\nan interactive GUI for planning Quality upcyclers.\nIts source code is published at\ncodeberg.org/SimonSapin/factoqual.
\n###
\nI was heavily inspired by Daniel Monteiro’s\nblog posts on quality math.\nOthers have done similar work,\nincluding Konage\nand Factorio wiki contributors.\nBut I believe the exact solution from solving equilibrium equation as shown here is new,\nas opposed to iterative approximation an infinite sum.
","headings":[{"level":2,"text":"Solving Factorio Quality","id":"solving-factorio-quality"},{"level":3,"text":"Intro to Factorio and Quality","id":"intro-to-factorio-and-quality"},{"level":3,"text":"Factory planning tools","id":"factory-planning-tools"},{"level":3,"text":"Matrix math","id":"matrix-math"},{"level":3,"text":"Quality strategies","id":"quality-strategies"},{"level":3,"text":"Making an interactive calculator tool","id":"making-an-interactive-calculator-tool"}]}}