Suboptimal way of doing power

[Starficz]

https://www.jdoodle.com/ia/1PXH EDIT: see below comments
See example here for optimal way to do power.

[Starficz]

Missed cases where the output splitter was needed for loopback, leading to issues. The fix is to use an earlier depot splitter, then split that again to reach required rate.
Here is the fixed code: https://www.jdoodle.com/ia/1Q0h

[Starficz]

Write up of days of work by @leander, @asteraaster, and me

From Leander:
i'll do my best to summarise the logic and math that went into the current design.

Many people have independently come up with the idea of 'rate-limiting' the battery consumption of a thermal bank/banks to avoid excess power wastage and generate closer to the actual consumption. The most intuitive concept which basically all of the implementations i have seen, including the one that spawned this thread use is some sort of binary/trinary splitter implementation that sums fractions of a fixed rate output (a depot unloader outputting items at 0.5/s) in order to approximate the desired power output. E.g 30W + 15W + 3.75W = 48.75W. The fractional rate outputs are achieved by splitting the base rate belt with splitters (2-way splitters halve the output rate, 3-way splitters divide by 3)

The main issue with this kind of design is that in order to achieve higher and higher levels of precision, more and more branches, or fractions, need to be summed together. However, adding more branches introduces the risk of energy leakage (explanation here: ⁠blueprints⁠Get 5% more bills for FREE (ft…). Energy leakage is at higher risk when there are 1) more branches/fractions being summed together, 2) limited control over the exact timings of when the batteries are consumed 3) there is a relatively small buffer size compared to the energy generation of one battery. All of these 3 conditions are present in traditional binary/trinary splitter PWM designs. This can be observed in DIGE as if you try to go for lower and lower energy wastage targets (higher precision), it will be unable to find a solution that isnt eventually killed by leakage. The maximum is usually 2 branches, which the math linked above explains why ^.
Therefore, you are mainly limited in precision by the number of individual branches you are adding together. For most systems, 2 branches will put you within about 5W, or 1-3% of exact power consumption.

The aim of the loopback design is to have a single "branch" or output, with a fixed, arbitrary period. By adjusting the period of this single output (time between battery outputs) rather than adding fractions together, you can adjust the average power output. Because you are using only a single branch, even with no excess generation to your consumption, the entire operating range will be guaranteed to be at most: [64k for lcw batts, 44k for hcv batts], which is entirely contained within the 100k energy buffer, and therefore there is no risk of leakage.

With the simple binary/trinary splitter, a single branch is restricted to the set of rates defined by (base rate) * 1/(2^n * 3^m), where n and m are integers.

for example, you can create a 1/18 rate belt by splitting in half, then in 3, then in 3 again.

You cannot, however, create 1/5 or any fraction 1/x where x is not of the form (2^n*3^m).

In order to adjust the period of the single branch to an arbitrary level of precision, you need to have control over the fraction 1/x to have any arbitrary denominator x, not just those constructible like above.
To achieve this, a loopback is used. An intuitive way of imagining how the loopback mechanism works is that it increases the effective belt rate.

For example, if you wanted a (1/5th * base rate) belt, you could achieve this by taking 1/8th of a belt which is outputting at a rate of 1.6 (8/5) times the base rate.

The math to get the loopback fraction, or ratio, requires the use of the geometric series formula to prove rigorously. However, it can be simplified by following this process:

to achieve 1/x:
round up x to the nearest power of 2, given as 2^p.
the loopback fraction will be (2^p - x)/2^p

example:
if you want the final rate to be 1/5, x = 5.

2^p = 8

loopback fraction will be (8-5)/8 = 3/8.
To achieve 1/5, you take the 1/8 output (3 2-way splitters), and loopback 3/8 (1/8 + 2/8)

This only proves that you can get arbitrary precision to rates which are 1/x * (base rate), where x is an integer. However, there are many power generation situations, or fractions, where the required power is not closely approximated by 1/x, for example 5/6.

The solution is simple. Rather than taking the last output, which will always be 1/2^n where n is the number of splitters, you can take an output from any of the n branches.

Here's an example.

consider the case where there are 3 splitters, with 1/8th loopback, and 1/8th going to the thermal bank. This means that the system is generating 1/7 * (base rate) power.
Image
However, by moving the thermal bank up the chain by 1, it doubles the power output, generating 2/7 * (base rate) power.
Image
Moving it up by 1 again generates 4/7 * (base rate) power.
Every time you move the thermal bank up the chain by 1, it doubles the power.

Therefore, you can produce any fraction that is 2^n / x, where 2^n/x < 1, in a single fractional rate output, meaning you can produce any item output rate where (desired rate) = (base rate) * 2^n/x, n and x are integers.

It should be easy to convince yourself that any fraction between 0 and 1 can be approximated to the form 2^n/x with an arbitrary level of precision, and therefore it is possible to create an arbitrary level of precision on the power generation of the system, without the leakage drawback since there is only a single "phase"/"branch"/"output". Therefore, it is possible to create systems which generate power stably within 0.0001% or better without risk of leakage.

Footnotes:

• Precision scales at a rate of 1/2^n, where n is the number of 2-way splitters. This is the same convergence rate per splitter as the original pure binary/trinary splitter design(s).
• Example of generating an approximation of a fraction in the form of 2^n/x with arbitrary precision can be found here ⁠blueprints⁠Get 5% more bills for FREE (ft…
• the approximation must always be rounded up (denominator rounded down), to ensure that the system stays in equal or positive power generation
• because the belt rate coming from a depot is already capped at 0.5/s, the "base rate" is actually taken from a belt that has already been halved; i.e 0.25/s. This allows extra capacity for the loopback to add on to the 0.25/s without hitting the belt throughput limit.

From Me:
Additonal note for the above write up.
A collision happens when the loopback itself requires the chosen output 2^n
This results in us requiring 2x 2^n outputs, which can be made by going to the nearest larger depot output, then splitting that back down to the required output.
for example:

Target: 540W 
Using Battery: 44000J

Diagram for:   Splitter: 1/128   Output:4   Loopback:47   Actual: 543.2099W   Waste: +3.2099W
Main Splitters:   7
Thermal Bank:     4
Loopback Indices: [1, 3, 4, 5, 6]
Depot Indices:    [0, 2, 6]
                   
[Loopback]        +-----------+-----------+-----+-----+-----+
                  ↓           ↑           ↑     ↑     ↑     ↑
[Output] → [S] → [M] → [S] → [S] → [S] → [S] → [S] → [S] → [S]
            ↓           ↓           |                       ↓
[Depot] ←---+-----------+--------+--|-----+-----------------+
                                 ↑  ↓     ↑            
                                 +-[S] → [S] → [B]    

We need to loopback 47, which is 32 + 8 + 4 + 2 + 1. We also need to output 4.
so we go to the nearest depot output (16) then split it twice, and use that as the output.

There is guaranteed to be at least 1 larger Depot output, as optimal loopbacks will be less then half the total base splitter ratio (ie: for 128, Loopback < 64)
This means the first Splitter will always be be going to the depot.

[djkcyl]

Thanks @Starficz for the detailed write-up and for sharing the analysis from @leander and the team!

I have reviewed the proposal regarding the loopback mechanism and the math behind avoiding energy leakage. It looks like a solid optimization. I will add this to the research plan to investigate how to best integrate this logic into the project.

[Well2333]

Hi, I'm the technical lead for this project, specifically responsible for the core logic calculations and simulation components.

First off, kudos to you for the rigorous breakdown. Your analysis of the "energy leakage" constraints in traditional binary/trinary splitter designs is spot on, and the mathematical derivation for using loopbacks to achieve arbitrary $1/x$ precision is theoretically sound.

Regarding the implementation of that Loopback mechanism: We actually explored this concept extensively in the early stages. You are correct that while our current binary/ternary splitter approach is limited to ratios of $1/(2^n \cdot 3^m)$ (which we approximate via parallel paths), a loopback system could theoretically achieve perfect $1/n$ or $m/n$ ratios. However, we deliberately chose not to implement it for two primary reasons:

1. Discrete Game Logic vs. Continuous Math:
   The game world operates on discrete ticks, whereas the loopback math assumes a continuous flow. Pushing this mechanism to its limit essentially turns the design into a binary (or decimal) encoder. I have actually published a detailed critique of such schemes and their practical issues on Bilibili here: (https://www.bilibili.com/opus/1165579554927935488). (You may need a translation tool to view it).

2. Simulation Complexity and System Reliability:
   Following up on the first point, this is a matter of safety. A pure binary/ternary splitter setup is deterministic and very easy to simulate mathematically. Introducing loopbacks, however, introduces complex phase alignment issues. To guarantee that no power outages occur within any arbitrary cycle, we would need a much more sophisticated simulation model than what is currently feasible. Until we can mathematically guarantee the stability of such a system through simulation, we consider the risk of failure too high to adopt.

That being said, we are actively discussing with other creators in the Chinese community on how we might introduce a loopback mechanism without drastically increasing computational overhead (UPS impact), or how to develop scripts capable of simulating these complex phases. If you're interested in this development, please feel free to follow our project updates.

---

嗨，我是这个项目的技术负责人，主要负责核心算法的设计与模拟部分的编写。

首先，非常赞赏您的详细总结。你对于传统二分/三分分流器在追求高精度时面临的“能量泄漏”风险的分析非常到位，且关于利用回流机制实现任意精度 $1/x$ 的数学推导逻辑严密，这确实是理论上的最优解。

不过，我们在项目初期其实就针对 Loopback 机制进行过深入探讨。虽然目前的二/三分流方案只能组合出 $1/(2^n \cdot 3^m)$ 的形式（通过多路并联可以提高精度，但无法完美拟合），而引入 Loopback 理论上确实能实现真正的 $1/n$ 甚至 $m/n$ 输出，但我们最终出于工程稳定性的考虑放弃了该方案，原因主要有两点：

1. 游戏刻（Ticks）的离散性与数学连续性的冲突。
   游戏世界是基于离散时间的，而 Loopback 的数学推导往往基于连续时间。这种机制在极致状态下会演变成类似二进制（或十进制）编码器的方案。针对这类方案在实际游戏环境中的弊端，我之前在 Bilibili 发布过详细的批判与分析视频（ https://www.bilibili.com/opus/1165579554927935488 ），你可以配合翻译工具查看。

2. 基于第一点的模拟难度与系统可靠性问题。
   单纯的二/三分流器是线性的，极易进行确定性的模拟计算。然而，一旦引入 Loopback，就会带来复杂的相位对齐（Phase alignment）问题。这意味着我们需要一个极其精密且复杂的模拟模型，才能确保系统在任意循环周期内绝对不会发生停电事故。在无法通过模拟完全验证其可靠性之前，我们认为这套方案存在安全隐患。

不过，我们目前正与中文社区的其他作者紧密合作，探讨如何在不显著增加计算复杂度（Lag/UPS impact）的前提下适当引入回流机制，或者开发能够处理复杂相位问题的模拟脚本。如果你对此感兴趣，欢迎持续关注我们的项目动态。

[Starficz]

Thinking about it more, we do think our 2^n/m solution for any general fraction is flawed. However, I can prove that 1/x loopback designs always have constant periods:

To reach 1/x, we construct the higher power of 2, then loopback the remainder. So 1/x = 1/(2^n-l), where l = loopback lanes.

This means the behavior of the system is perfectly cyclical, with a period of 2^n. (matching a generic binary splitter with 1 output)
The inputs to the 2^n, are: l from the previous loopback + 2^n-l from the depot.
The outputs to the 2^n are: l to the next loopback + 2^n-l-1 to the depot + 1 to the thermal bank.

Crucially, no matter how the inputs, or the outputs are distributed in the cycle because we only have 1 output to the thermal bank, between each battery that outputs to the bank, we will always have: l loopback inputs + 2^n-l from the depot.

This means that in the total time of (2^n-l) * 4s (1/2 belt rate from initial split), we will always have 2^n inputs (2^n-l from depot, l from loopback), sending 2^n-l-1 back to the depot, l to the next loopback and 1 to the bank.

Thus the output rate will always be a consistant 1/(2^n-l) = 1/x for any x.

Im fairly confident that this is correct, which means that at the very least you can do simulation on 2 branches of 1/x instead of 1/(2^n)x(3^m)

[Well2333]

Yes, your conclusion that the output rate remains a constant 1/(2^n - l) = 1/x appears to be correct.

In fact, this concept has already been proposed within the Chinese community (Reference: <Concepts on Prime Splitters in Arknights: Endfield - Bilibili>). However, the original author did not explicitly demonstrate the uniformity of the output at the time. I have only recently started investigating the output characteristics myself as I began researching these components involving loopbacks.

The good news is that I am currently developing automated calculations for these loopback components. Instead of viewing them as scattered, discrete parts, I am treating the entire setup as a single "Integrated Circuit" (IC). This allows us to safely use these components in actual workflows by pre-verifying just two conditions:

1. Reliability Verification: Ensure that any loopback does not affect the output frequency of at least one valid output port.
2. Operational Limits: Calculate the maximum input speed that does not cause phase drift (jamming/blocking).

Barring any surprises, you should see this feature go live within a few days.

At the same time, I am also attempting a full-scale simulation. However, this is essentially equivalent to designing a production line system for an automation game from scratch, and it requires perfect alignment with specific in-game mechanics. The development difficulty is quite high, so there likely won't be substantial progress on this specific front in the short term.

---

是的，你关于输出速率将始终保持恒定的 1/(2^n - l) = 1/x 的结论应该是正确的。

其实这个思路早已在中文社区内提出（参考 <关于《明日方舟：终末地》质数分流器的构想 - 哔哩哔哩>），不过当时作者并未明确论证过输出均匀性的问题。我也是在最近几日着手研究这类涉及回流的元件时，才开始深入研究其输出特点。

好消息是，我目前正在开发针对这类回流元件的自动化计算功能。比起将其视为一个个分散的零件，我目前将其视为一个整体的“集成电路” (Integrated Circuit)，这样我们只需要事先确保两点即可在实际流程中有条件地安全使用这些元件：

1. 可靠性验证：确认任意回流不能影响至少一个有效输出口的输出频率（一次性验证这个元件是否可靠）。
2. 使用限制：计算不造成相位差（也就是阻塞）的最高输入速度。

如果不出意外，你应该在几天内就可以看到这个功能上线了。

同时，我也在尝试进行全仿真模拟。不过这相当于从零开始设计一套自动化游戏的生产线系统，而且还需要契合游戏内的各种具体表现，开发难度很高，因此这部分在短时间内可能不会有什么实质性进展。

[LeanderUoa]

I've done some thinking about the discussions here and I've attempted to use a theory-first approach to prove stability of designs which use the merged output of a binary encoder as an input into a single chain of splitters. The behaviour of the loopback designs, as stated earlier, when pushed to their limit, behave in such a way after enough time has passed.

The proof goes as follows:

Recall how the issue with power leakage was defined. Each branch of a binary encoder output adds (in the worst case) [64kJ for LCW batteries, 44kJ for HCV batts] to the amplitude of the operating range of the energy level of the system. If the operating range of the system is greater than 100kJ, then there may or may not be a risk of leakage. If you can guarantee that the operating range is < 100kJ, then you can guarantee there is no leakage in the system, regardless of phase alignment and battery consumption timings.

Consider the case where you have a constant rate of 1/x batteries entering a thermal bank, the system is performing at steady state (power generation = consumption), and you inject a single extra battery into the input line. This increases the energy level of the system by [64kJ for LCW batteries, 44kJ for HCV batts].
Now consider the case where you have a constant rate of 1/x batteries instead going into a single splitter, where half of the 1/x is directed into a thermal bank, and the other half is discarded. Assume the system is using exactly equal to the power generation associated with a rate of 1/2x. If you were to inject a single battery into the normal operation of this system, you are effectively moving the queue of the 1/x rate battery up by 1 unit. This has the effect of increasing the energy level by half of a battery [32kJ for LCW batteries, 22k for HCV].

When you perform a split on the output of a summed binary encoder, you are in effect creating a situation where every other battery is consumed (each produce 64kJ/44kJ), rather than every battery, and therefore you are halving the 'energy spike' effect of an individual battery entering the system.

Therefore, you can calculate the worst case operating range, just like in the original binary decoder case. In the worst case, there exists a point in the period of the whole system where each branch injects their battery at the exact same time (perfect superposition of all branches), creating an energy spike equal to (number of branches) * energy generated per branch. As long as this energy spike is not greater than 100kJ, then the system will be guaranteed to be safe.

Let n = the number of splits after the binary decoder to the thermal bank, and b = the number of branches summed to create the input belt.

Assertion: given the above, it is impossible to have leakage in a system where:

100kJ < b * [64kJ (LCW) or 44kJ (HCV)] / 2^n

Note: It is assumed that batteries generate their entire energy output instantaneously, adding 64k/44k to the buffer immediately. In fact, reality is more forgiving than this assumption states because true superposition is impossible in reality as only a single battery can be consumed at a time, and the worst case energy spike is flattened slightly by the fact that batteries release power over a time period. If the above is true given this assumption, you can say that it is also true for the real behaviour of thermal banks/batteries.

Let's examine the assumption that injecting a single battery into a 1/2^n system will behave as an injection of [64kJ/44kJ] / 2^n, and that injecting p batteries will behave in the worst case as a 'power spike' of p * [64kJ/44kJ] / 2^n. This may be the case in a theoretical situation, but in a real implementation where batteries come in discrete units it is possible to manufacture conditions where injecting p batteries into a system with a given state will create an energy spike greater than p * [64kJ/44kJ] / 2^n.

Consider the case where n = 3 (3 splits, 1/8 output)
Also consider the state of the splitters to be the worst case, that being that the 1st item entering will be directed to the thermal bank, the 9th item, the 17th item, etc. These conditions ensure that the 'power spike' is as large as possible.

If you inject 9 items into the system at that moment, 2 will enter the thermal bank. However, the previously asserted formula states that the maximum 'power spike' will be [9 * (battery energy) / 2^n = 9 * [64k or 44k] / 8].

Therefore, the real worst case 'power spike' is actually b' * [64k (LCW) or 44k (HCV)] / 2^n, where b' is equal to b rounded up to the nearest power of 2. In this case, b' is 16, and therefore the worst case power spike with 9 branches is 16/8 * (battery energy).
(b'/2^n) represents the true worst case number of batteries that can exit the decoder safely in a power spike event.

Finally, we can assert:

It is impossible to have leakage in a system where:

100kJ < b' * [64kJ (LCW) or 44kJ (HCV)] / 2^n,
where b is the number of branches from the encoder,
b' is b rounded up to the nearest power of 2,
n is the number of splits after the summed inputs of the encoder.

This assertion is built on the lemmas:

• the energy level is always at its minimum state right before the 'worst case' power spike, which is easy to prove as for this superposition to have happened, it has to be the maximum amount of time elapsed since every branch last outputted.
• The maximum energy level of the system is always the instant after the 'worst case' power spike (if such a condition exists), which is also easy to prove as any other potential instant besides the instant of maximum superposition there will be some delay since any given branch has outputted a battery, and therefore the energy level must be lower.
• The worst case operating range is the difference between the maximum energy level (the state immediately after the worst case power spike) and the minimum energy level (the state immediately preceding the worst case power spike). Therefore, the worst case operating range is equal to the magnitude of the worst case power spike given a maximum superposition event exists in the period of the system.

---

Notes about implementation:

It is possible to achieve higher levels of precision using this approach for basically all power generation targets than the current stable methods, as it allows for equal to or more branches in the binary encoder stage for all cases.

In order to maximise precision, the output rate from the binary encoder should be as large as possible to allow for as many splits as possible after merging, which in practise means a rate of between 0.5-0.99 times base rate, or 0.25-0.499 items/s.

The maximum possible final output rate required would be 1 per 40s, or 0.025 items/s (generating 1600W/1100W).

Therefore, in the worst case, a design will have a maximum splitting ratio of 0.025/0.25, or 1/10. If restricting to binary splitting only, then the worst case splitting rate is 1/8, n=3.
b' = 100kJ * 8 /64kJ
b' = 12.5 branches.
b = 8 branches (maximum allowed before b' > 12.5)

The worst case power target can have a minimum of 8 branches in the binary encoder in the worst case, which is much higher precision than the 1-2 branches of current designs. Power targets which are on the smaller side (1-300W) may have 16 or more branches in the binary encoder. If you introduce trinary splitting, then 9 branches/12 branches/etc are possible.

[LeanderUoa]

here's an example of an implementation of the above. In this case, because the splitting ratio is 1/16, the encoder could be expanded to have up to 16 branches if using LCW batteries, 32 branches if using HC batteries (only 3 branches used in the example).

[Well2333]

@LeanderUoa
This is a fantastic concept. Regarding the construction of an arbitrary positive rational number encoder, there is already relevant research within the community (refer to "[Arknights: Endfield] Arbitrary Positive Rational Number Splitter - Bilibili"). However, the primary bottleneck remains the algorithm.

To facilitate discussion, let's momentarily ignore the issue of item recycling and focus solely on the splitting behavior. Let's also establish a unified terminology: we will refer to binary splitters, ternary splitters, and the arbitrary multi-block prime splitters mentioned in the referenced article as "Components." A Component could be a standalone splitter or a complex multi-block structure, but its core function remains the same: for every p items input (where p is any positive prime number), it outputs 1 item.

To ensure absolute safety, we need to verify the battery data across a complete operating cycle of the system. Verification itself isn't overly complex. We can apply reverse prime factorization—following the logic used to build the rational number splitter—to identify exactly which Components are utilized. From there, by analyzing their series-parallel relationships, we can determine the Least Common Multiple (LCM) to define the cycle period and the output behavior within that period. Finally, we can run a simulation based on the output timestamps.

The question, however, is: how do we actually construct this system?

1. If we attempt base encoding using an arbitrary rational number splitter (the encoder you mentioned), we first use prime factorization to determine the required Components and their arrangement. But what if these Components are too complex? For example, a 1/13 splitter Component might require a 1/7 splitter and a 1/2 splitter. Conversely, there inevitably exists a more complex 1/p splitter that requires a 1/13 splitter to function. If a user's input value necessitates such a complex selection of splitters, we hit a dead end.

2. To address the spatial constraints mentioned in point 1, we could try rounding up the user's target power to create redundancy. But this introduces a new problem: we need an efficient algorithm to find a solution that meets the requirements while optimizing for size. This requires balancing several variables: wasted power, number of input branches, physical footprint, minimum energy levels, etc.

3. On top of this, we must also consider scenarios where the user attempts to generate power using two or even more types of fuel simultaneously.

I believe that the theoretical foundation for arbitrary value splitters based on pure splitter schemes is now complete. However, we still lack a solid implementation. The root cause is the absence of a viable algorithm to translate these theories into practice. This is the problem I've been trying to tackle recently. Regrettably, my mathematical background is limited to calculus, and I am completely unfamiliar with Discrete Mathematics, which is more relevant to this problem. I am eagerly waiting for a "savior" to step in and provide an effective design solution. 😭

---

很好的创意，关于任意正有理数编码器如何构建目前在社区中已有相关的研究，可以参考 《明日方舟：终末地》任意正有理数分流器 - 哔哩哔哩，但目前的首要问题依旧是算法。

为了方便讨论，我们先忽略回收问题，仅讨论分流行为。同时我们对二分分流器、三分分流器及上述文章中介绍的任意多方块结构的质数分流器统一命名为“元件”，元件可能是一个单独的分流器，也可能是一个复杂的多方块结构，但其核心职责是——输入p（p为任意正质数）个物品时输出1个物品。

为了保证绝对的安全，我们需要验证整个系统完整运行一个周期的电池信息，而且如果只是验证这件事并不算复杂，我们可以通过上文中构建任意正有理数分流器的思路进行反向质因数分解，查看它究竟使用了什么元件，这时候我们再通过其串-并联关系可以求出其最终的最小公倍数为周期，以及在这个周期中的输出行为，这时候根据其输出的时间戳进行仿真模拟即可。

但问题是，我们如何构建这套系统呢？

1. 如果我们尝试通过一个任意有理数分流器（也就是您提到的编码器）来进行基底的编码，首先是通过质因数分解我们可以知道我们需要什么元件，然后需要以什么形式进行排列，但如果这些元件过于复杂呢？例如一个1/13分流器元件需要一个1/7分流器和1个1/2分流器，而也必定存在一个需要 1/13 去拼凑的更复杂的 1/p 分流器，如果用户的输入数值正好卡在了这样复杂的分流器选择上，我们就无能为力了。

2. 为了解决第一条中提到的体积困境，我们可以尝试向上增加用户的目标功率用作冗余，但这又会带来一个问题，我们需要一个高效的算法来找到符合要求的同时还要兼顾体积的解法，而这一点需要考虑以下变量：浪费的功率值、输入路数、占地面积、能量最低值等。

3. 在此之上，我们还需要考虑如果用户尝试使用两种甚至更多种燃料进行发电呢？

我认为目前来说，基于纯分流器方案的任意值分流器的理论基础已经完善了，但到现在也没有一个很好的实现，其根本在于我们缺乏一个具有可行性的算法来将这些理论落到实地，这也是我最近一直在攻克的问题。不过很遗憾的是，我个人的数学水平也是只停留在微积分水平，对于离散数学等更加贴合需求的知识一窍不通，现在我十分期待有个“救世主”来提供一个行之有效的设计方案😭

[LeanderUoa]

To create an arbitrary output rate, simply:

1. figure out your desired item output rate x (in the example given above the output rate is 0.0215 items/s), taken from the desired wattage
2. repeatedly double the output rate until it is between 0.25 and 0.4999 items/s, given as x'. In this example, x' is 0.344 items/s. The number of times doubled is 4- the ratio is 1:16.
3. create a binary encoder that approximates x'. The binary encoder/Component can safely have up to 16 branches (if using LCW batt, 32 branches if HC batt) in the example above.

[LeanderUoa]

Space concerns should mostly be nonexistent, because even when you restrict yourself to only using binary splitters, you can construct a system where you have control over 1W increments with only an 8-bit encoder and a 1/8-1/64 splitter chain

[LeanderUoa]

in response to your point 1, i'm not suggesting we use an arbitrary rational number splitter. I'm suggesting the use of a simple binary encoder similar to the "12-bit high precision solution". By applying a proper splitting ratio to the output of the encoder, you can guarantee there are no leakage/superposition related issues.

The solution described works like this:

If the goal is to get 211/4096, rather than sum 128/4096 + 64/4096 + 16/4096 + 2/4096 + 1/4096, which may have leakage issues, instead do:

(2048/4096 + 1024/4096 + 256/4096 + 32/4096 + 16/4096)

Then, send the output of that through a 1/16 ratio splitter chain, achieving 211/4096. By doing this, you prevent the leakage issues while creating the same power output. The proof for why it is impossible to have leakage issues using this system is in the original reply.

[Well2333]

Actually, your encoder is not what one would strictly call a "binary" encoder, but rather a rational number splitter. For instance, the encoder shown in your previous image is effectively an 11/16 splitter. This might just be a difference in terminology, but I hope you recognize the fundamental commonality between them.

However, what if my target value is $1/p$, where $p$ is a large, indecomposable prime number? For example, if I require a rate of 1/997. Following your proposed scheme, we first need to obtain a value $0.25 &lt; x' &lt; 0.5$. By calculation:
$2^1 \cdot 3^5 = 2 \times 243 = 486$
$2^2 \cdot 3^4 = 4 \times 81 = 324$

In this scenario, we would need to construct (piece together) a splitter for 486/997 or 324/997. This brings us back to the first issue I raised earlier: if we attempt to use this algorithm, we may end up with extremely complex prime splitter designs for certain numbers. Among the 168 prime numbers under 1000, only 19 can be constructed using the form $2^m \cdot 3^n - 1$ (and this count includes 2 and 3). Even if we include cases like $2 \cdot p$ or $3 \cdot p$ which allow for minimal decomposition, I believe there is a significant probability that we will encounter scenarios requiring a highly complex encoder at the front end.

---

实际上，你的编码器并不是所谓的“二进制”编码器，而是一个有理数分流器，例如你之前图片的编码器是 11/16 分流器，可能这只是称呼上的区别，不过我希望你认可他们之间的共同性。

但如果我的需求值是 1/p，而 p 是一个无法被拆解的大质数呢？例如我的需求值是 1/997，通过提出的方案，首先我们要取得一个值 0.25 < x' < 0.5，通过计算可得：
$2^1 \cdot 3^5 = 2 \times 243 = 486$
$2^2 \cdot 3^4 = 4 \times 81 = 324$

那么这时候我们需要拼凑 486/997 或 324/997，而这就是我上文第一条提出的问题。如果我们尝试使用这种算法，在遇到特定数时可能会产生极为复杂的质数分流器设计。在 1000 以内包含 168 个质数，能够通过 $2^m \cdot 3^n - 1$ 拼凑出来的仅有 19 个（其中还包含了 2 和 3）。同时我们再算上 $2 \cdot p$ 或 $3 \cdot p$ 这类只能进行很少次拆解的情况，我认为遇到前端是非常复杂的编码器的概率并不低。

[Well2333]

However, the approach you shared is also well worth considering. Previously, I had only attempted to utilize the prime splitter as a simple 1/p unit; I hadn't thought of using its side output to piece together an x/p ratio. Finding a value that fits x/($2^m \cdot 3^n - 1$) by rounding up the target, and then carrying out the full process, appears to be a feasible solution.

Also, I wonder if you noticed that since the entire circuit operates as a series output, we can apply the commutative property of multiplication to move the downstream binary/ternary splitters to the input stage. The final output remains the same, but this arrangement effectively prevents input jamming caused by backflow.

---

不过，你提供的思路也十分值得参考，我在此之前仅尝试将将质数分流器作为 1/p 进行使用，但未想到利用其侧向输出端来拼凑一个 x/p，通过对目标的向上取值找到一个符合 x/(2^m*3^n - 1) 的取值然后进行整个流程看起来是一个可行的解决方案。

同时，不知道你有没有注意到，由于整个线路为串联输出，也就是说我们可以利用乘法交换律将后置的2-3分器放到输入口处，这样最终的输出和后置是一样的，同时这个也能够避免因为回流造成的输入堵塞问题。

[LeanderUoa]

It's not necessary to go all the way to 0.25 < x' < 0.5. Using 0.25 < x' < 0.5 was only to show the limit of how precise you are allowed to go without leakage becoming an issue. If you want the encoder to be less complex, you can simply use a lower value for x', and your maximum precision will be lower as a result. For example, using 1/997 as the target, this can be achieved by:

A)
(1/2^7 + 1/2^13 + 1/2^14 + 1/2^15)
then feed it into a 1/8 splitter chain

this is equivalent to:

B)
(1/2 + 1/2^7 + 1/2^8 + 1/2^9)
fed into a 1/512 splitter chain.

The main difference is that A) can only have a maximum of 8 branches before leakage becomes an issue, whereas B) can have up to 512 branches. It is not necessary to use all of the branches.