AI summaryⓘ
The authors studied a special way of trusting different parts in a distributed system called asymmetric trust, where each part can have its own ideas about who might fail. They found that while this flexible trust allows handling more failure cases, it doesn't help in solving complex tasks like consensus better than traditional symmetric trust, where everyone agrees on trust the same way. They showed that any complex problem solvable under asymmetric trust can also be solved by a properly designed symmetric trust system. However, asymmetric trust offers advantages only for simpler tasks that need less coordination. Their work clarifies exactly when asymmetric trust matters and when it does not.
asymmetric trustsymmetric quorum systemsdistributed tasksByzantine failuresconsensusreliable broadcastquorum systemdepth hierarchyfailure scenariosdistributed computing
Authors
Ignacio Amores-Sesar, Christian Cachin, Simon Holmgaard Kamp, Juan Villacis
Abstract
Asymmetric trust generalizes classical symmetric quorum systems by allowing each process to specify its own failure assumptions. While this flexibility enables tolerance of strictly more failure scenarios, it is not known if, in these cases, it is actually possible to solve distributed tasks, and if so, which. We answer this question using the depth hierarchy for asymmetric trust (Amores-Sesar et al., OPODIS~'25), which characterizes how much a process must rely on others to solve a task. We prove that asymmetric trust does not increase the solvability of tasks requiring depth two or more, such as reliable broadcast or consensus. Specifically, for any Byzantine asymmetric quorum system, every failure scenario that permits solving a task requiring depth at least two can also be tolerated by a suitably constructed Byzantine symmetric quorum system. We show this via a compiler that transforms asymmetric quorum systems into symmetric ones. The additional failure patterns tolerated exclusively by asymmetric trust correspond to scenarios in which only simpler tasks requiring depth one or less (such as consistent broadcast) can be solved. We further prove that this result is tight in the depth hierarchy, meaning that there exist no compilers that produce symmetric quorum systems that are valid also in failure scenarios where correct processes have depths one or less. Our results clarify the precise power of asymmetric trust. While it strictly enlarges the set of tolerable failure patterns, it does not provide additional strength for solving tasks requiring depth two or higher.