I haven't read the whole thing in detail (and fwiw, I don't think I will by this point), but I do want to respond to section about the combinatorics as well as the proof, since both the premises and the implications don't seem very solid to me, especially in light of the other replies in this thread.
It appears to be a step up from the Knapsack paper in terms of the specificity of a concrete mixing protocol (which again, I did not scrutinize, but see below), but a regression in terms of privacy (see other replies), which even in the Knapsack paper's approach raises some concerns:
Now, there are 100!/(10!)^10 ~= 10^92 ways to partition the inputs into a list of 10 sets of 10 inputs, but only a tiny fraction of these partitions will produce the precise output list.
In the equal amount case, the search space of possible interpretations with n = # inputs + # indistinguishable outputs is proportional to the nth Bell number, i.e. it's exponential in the size of the transaction, which is an inviting intuition. But this is an *upper* bound on the difficulty of deanonymization, given no additional information.
This quantitative framing is potentially misleading because:
1. attributing inputs/outputs (sub-transactions in the Knapsack paper's terminology) is arguably not a search problem, but an optimization problem, since approximate results are still partly useful to the adversary
2. there are many computational strategies, heuristics, etc that in practice can make this more efficient than brute force[1], so framing it that as a security parameter doesn't sit right with me
3. as individual sub-transactions are identified (for example using out of band information), the computational challenge also *drops* exponentially fast
Additionally (though is a broader criticism of CoinJoin based privacy and not specific to unequal amounts, and in particular refers to ZmnSCPxj's assertion of 0 linkability) I am very worried that perspectives that focus on linkability information revealed by a single coinjoin transaction in isolation. This problem was alluded in the document, to but I don't see that it was addressed. Naively the post/pre mix transaction graph would seem to present a computationally much harder problem when looking at the combinatorics through the same lens, but reality it can also be used to place many constraints on valid partitions/sub-transaction assignments for a single transaction with equal amounts. The trivial example is post mix linking of outputs, but there are many other ways to draw inferences or eliminate possible interpretations of a single transaction based on its wider context, which in turn may be used to attack other transactions.
Based on the example above, we can see that not only are there a huge number of partitions, but that even with a fast algorithm that could find matching partitions, it would produce around 10^20 possible valid configurations. With 10^20 possibilities, there is essentially no linkage.
This is a better framing, but still doesn't address my third bullet, since "Attacks always get better; they never get worse." In other words "essentially no linkage" due to multiple possible interpretation is still strictly more meaningful if you can add constraints out of band.
To be fair in equal amount CoinJoins this is also the case, but it's a much simpler model to consider in the context of other privacy leak vectors (e.g. transaction graph connectivity beyond a single coinjoin, wallet fingerprinting, temporal patterns, network privacy leaks, etc etc), since analyzing your level of exposure is *also* complicated by unequal amounts, in other words higher chance of privacy leaks due to misuse, or ignorance of some of the implications under intended use. Thinking through these implications is much easier when the information content in the amounts is minimized.
The Cash Fusion scheme actually extends this obfuscation even further. Not only can players bring many inputs, they can also have multiple outputs
And, quoting another section:
Unfortunately, the production of equal-amount coins is impractical for various reasons. Foremost, it has a "toxic waste"
I'm still cautiously optimistic about the potential of multiple inputs/outputs per user (c.f. 3-phase chaumian CoinJoin ideas we've previously discussed in the context of Wasabi, though I don't recall any public discussion I can link to, sorry list), but with the additional assumption of amounts with small popcounts/Hamming weights (e.g. only amounts that are 2^n sat in size, or based on 1-2-5 series, and for a rationale see Ethan's reply).
Unfortunately this trades off that "toxic waste" problem for a very large on chain footprint (e.g. if the popcount of the amount of a wallet is limited to 1, the number of inputs and change outputs required in the worst case is proportional to log of the payment amount) and significant UTXO bloat (several mixed outputs per magnitude for transaction size to scale as the popcount(payment amount) instead of the log(payment amount))
However, with OP_CHECKTEMPLATEVERIFY and Taproot, this overhead could potentially be mitigated (something more like TumbleBit's privacy model, but with an on chain footprint similar to multiparty payment channels as described in the OP_CTV BIP draft) since the safety guaranteed by CoinJoins' atomicity can be preserved without requiring atomicity of the mixing itself, which can extend over multiple transactions and long time intervals, while still providing the liquidity and finality and unilateral exit option of payment channels. By moving such low hamming weight amount outputs off chain, and allowing them to be mixed (with equal amounts), split and merged off chain. The simpler analysis of equal amount outputs could still be assumed which makes analysis easier and assumptions about adversary weaker, and furthermore this approach would better align the incentives for batching and privacy, which is why I think it's very promising.