[Paper Review] Resolving multi-proxy transitive vote delegation

Jonas Degrave|arXiv (Cornell University)|Dec 11, 2014

Access Control and Trust3 citations

TL;DR

This paper proposes a multi-proxy transitive vote delegation system in liquid democracy, where each voter can distribute their vote among multiple trusted proxies, ensuring transitive delegation while maintaining fairness through equal vote distribution. The method uses a system of linear equations and matrix inversion to compute final vote weights, proving correctness via non-formal analysis and demonstrating applicability to sparse networks.

ABSTRACT

Solving a delegation graph for transitive votes is already a non-trivial task for many programmers. When extending the current main paradigm, where each voter can only appoint a single transitive delegation, to a system where each vote can be separated over multiple delegations, solving the delegation graph becomes even harder. This article presents a solution of an example graph, and a non-formal proof of why this algorithm works.

Motivation & Objective

• To address the limitations of single-proxy delegation in liquid democracy, where votes may be lost if a delegate abstains.
• To design a system allowing each voter to split their vote among multiple trusted proxies, ensuring transitive delegation.
• To provide a mathematically sound and computationally feasible method for calculating final vote weights in complex delegation networks.
• To enable detailed feedback on vote origin and distribution, supporting transparency and accountability in liquid voting systems.

Proposed method

• Formulates the delegation problem as a system of linear equations, where each voter's total support equals their own vote plus shares from their delegates.
• Constructs a matrix representation of the delegation graph, using adjacency matrix A and identity matrix I to model vote propagation.
• Applies the Neumann series to compute the total vote weight as (I - A)^(-1) * J, where J is the initial vote vector.
• Uses matrix inversion (I - A)^(-1) to compute final vote weights, with B = I - A ensuring invertibility and bijectivity.
• Employs sparse matrix techniques to optimize performance and memory usage for large-scale networks.
• Validates the method through a concrete 25-node example, showing consistent results across both linear system and Neumann series approaches.

Experimental results

Research questions

• RQ1 How can vote delegation be extended from single-proxy to multi-proxy systems while preserving transitivity and fairness?
• RQ2 What mathematical framework can accurately compute final vote weights in a multi-proxy transitive delegation graph?
• RQ3 Why does the matrix inverse (I - A)^(-1) correctly represent the total influence of each voter in the network?
• RQ4 How can the system provide meaningful feedback on vote origin and distribution to individual voters?
• RQ5 What are the computational and scalability implications of applying this method to large, sparse delegation networks?

Key findings

• The system correctly computes final vote weights using matrix inversion, with (I - A)^(-1) providing the total influence of each voter.
• The method ensures that votes are fairly distributed among all active delegates, with each delegate receiving a proportional share of the votes they receive.
• The matrix B = I - A is always invertible in this context, guaranteeing a unique solution for any valid delegation graph.
• The solution allows for detailed feedback on vote contributions, with each element of B^(-1) indicating the contribution of a delegate to a voter’s final weight.
• The approach remains computationally feasible even for large networks due to sparsity, with performance optimized using sparse matrix algorithms.
• The method can be extended to support weighted delegation or decayed influence based on delegation depth.