Revision History for: Practical Quantum Electronic Voting
- 2025-06-24 at 21:50 by JuliaM
implements Quantum Electronic Voting
Introduction
This protocol[1] achieves the functionality of Quantum Electronic Voting. In this protocol, an untrusted multipartite entanglement source can be used to carry out an election without any election authorities.
Outline
- In the first phase of the protocol, each agent is assigned a unique secret random index
- Next, we perform multiple rounds of voting, one for each agent. In each round, the following steps are carried out:
- The agent with the same index as the round number is designated the voter for that round
- The source distributes one qubit of a GHZ state to each agent. The voting agent randomly chooses to either verify the GHZ state or vote with a certain probability. This step, including state distribution, is repeated until the voter chooses to vote. Once voting is chosen, the voter anonymously transmits their vote to all agents.
- Finally, all the votes are tallied. All agents have the votes for each round and can thus verify the final tally.
Assumptions
- The protocol assumes the existence of an authentication channel.
- The protocol assumes the ability to share multi-party entangled quantum states. But the source doesn’t need to be trusted
Requirements
Network Stage: Entanglement generation
The protocol requires:
- Classical communication between the voting agents
- A multipartite entanglement source, assigned to each agent by a quantum channel. The source need not be trusted.
- Voting agents must be able to generate random numbers
Notation
- $N$: Number of agents
- $V = \\\{v_k\\\}_{k \\\in [N]}$: The votes
- $S$: Security parameter
- $\\\epsilon$: Distance from the perfect GHZ state
- $\\\delta$: Threshold for verification
- $\\\eta$: Probability of failure of verification
- $B$: Bulletin board — $N \\\times N$ binary matrix. Each row corresponds to one round of voting, and each column contains the output of a single voter across all rounds
- $E$: Vote vector — The list of votes across $N$ rounds. Each element is computed as the parity of a row from $B$
- $T$: Final tally
Properties
- $(\\\sigma_{H}, \\\sigma_{D}, \\\gamma)$-Correctness:} This notion of approximate correctness includes two properties:
- $\\\sigma_{H}$-Completeness: If all agents are honest, the election is accepted with probability more than $\\\sigma_{H}$ – $\\\Pr[\\\text{election accepted}] \\\geq \\\sigma_{H}$
- $(\\\sigma_{D}, \\\gamma)$-Soundness: the probability that the election result is accepted, given that the set of the votes $E$ computed from the bulletin board $B$ resulting from the election is more than $\\\gamma$ away from the real votes $V$, is smaller than $\\\sigma_{D}$ –
$$\\\Pr\\\left[\\\text{election accepted} \\\;\\\middle|\\\; \\\frac{1}{N} \\\|V – E\\\|_1 \\\geq \\\gamma \\\right] \\\leq \\\sigma_{D}$$
- This particular protocol is $\\\left([1 – \\\epsilon(1 – S)]^{N},\\\; S^{N(1 + \\\lambda)[\\\epsilon(1 – \\\eta) + \\\eta]},\\\; (1 + \\\lambda)[\\\epsilon(1 – \\\eta) + \\\eta]\\\right)\\\text{-correct}$
for a small constant $\\\lambda > 0$ - $\\\zeta$-Privacy: The privacy of the election scheme implies that for any voter $k$, the probability that any subset of malicious parties $D$ that deviates from the honest protocol can guess the vote $v_{k}$ of the voter is at most $\\\zeta$ more than in the case they just have access to the bulletin board and to their own votes –
$$\\\forall k,\\\quad \\\Pr[v_{k} \\\mid D] – \\\Pr[v_{k} \\\mid B, v_{j} \\\in V_{D}] \\\leq \\\zeta $$ - This particular protocol is $\\\zeta$-private with $\\\zeta = (1 – \\\eta)^N \\\epsilon + \\\left(1 – (1 – \\\eta)^N\\\right)$
Other properties:
- Authentication: This e-voting protocol does not provide authentication, which should be taken care of by the physical implementation of the protocol.
- Double voting: Each voter can vote at most once. Since the number of voters is known in advance for this protocol, double voting is easily taken care of.
- Verifiability: Each voter can verify that their vote has been counted correctly. In this protocol, the tally is performed by the voters themselves. The bulletin board produced as an output of the protocol is public and can always be checked by everyone, while still appearing random.
- Receipt freeness: In order to prevent vote-selling, voters should not be able to prove how they voted. As the unique indices stay secret, voters cannot produce a receipt of their vote.
- Additional candidates: The protocol described here only allows an election consisting of 2 candidates. This can be extended to more candidates by repeating the protocol multiple times in sequence. In particular, if there are $K$ candidates, we can express each of them using $\\\log_{2} K$ bits and repeat the election as many times so that each vote set corresponds to one bit. This however, does affect the correctness and privacy.
Technical Description
Main Protocol: Quantum e-voting
Inputs: $V = \\\{v_k\\\}_{k \\\in [N]}$ – Set of votes; $S$ – Security parameter; $\\\epsilon$ – Distance from the perfect GHZ state; $\\\delta$-Threshold for verification; $\\\eta$ – Probability of failure of verification
Output: The candidate with the majority votes or Abort
Resources: Classical communication, random numbers, N-qubit GHZ source, quantum channels- Phase 1 [getting unique secret indices]
- Agents perform UniqueIndex until each agent has a secret unique random index $\\\omega_k$
- Phase 2 [casting votes]
- For $l = 1$ to $N$
- The voting agent is the agent $k$ with $\\\omega_k = l$
- Repeat until Voting is announced
- The source distributes to each of the N agents one qubit of the GHZ source
- All agents $j \\\in [N]$ set rejections$_j =$ trials$_j = 0$
- The voting agent tosses $\\\log_2\\\left[ \\\frac{16N\\\epsilon^2}{(\\\epsilon^2 – 4\\\delta)^2} \\\ln\\\left(\\\frac{1}{\\\eta}\\\right) \\\right]$
- The agents perform LogicalOR subroutine, where output 1 indicates Verification and output 0 indicates Voting. Everyone except the voting agent inputs 0; if the coin toss is ‘all heads’ the voting agent also inputs 0, otherwise the voting agent inputs 1
- If Verification is chosen, the agents perform RandomAgent and the voting agent anonymously picks an agent $j \\\in [N]$ to be the verifier. Agent $j$ updates trials$_j += 1$ and if Verification outputs reject: rejections$_j += 1$
- If for any $j \\\in [N]$, $\\\delta_j = \\\frac{\\\text{rejections}_j}{\\\text{trials}_j} > \\\delta$, the protocol Aborts
- Perform Voting. The outcome is one row of the Bulletin Board $B$. The parity of the row gives one entry in the vote vector $E$
- Given the votes $E$, the tally $T$ can be computed
- For $l = 1$ to $N$
- Phase 3 [Verification of results]
All agents perform LogicalOR with security parameter $S$, and input 1 if their vote is not the same as the entry in $E$ for the round in which they voted, and 0 otherwise
If LogicalOR outputs 1, Abort the protocol.
Else output the candidate with the most votes according to the tally $T$
Subroutine 1: UniqueIndex
Input: Security parameter $S$ to be used in LogicalOR, $N$ random boolean variables $x_i$
Output: Each agent $k$ has a secret unique index $\\\omega_k$
Resources: Classical communication and random numbers- Beginning of round $R = 1$
- Agents perform LogicalOR with inputs $x_k = 0$ if they already have an index and $x_k = 1$ if they do not
- If $y = 0$, repeat from step 2
- If an agent $k$ has a bit $x_k = 1$ and $\\\omega_k = 0$ they know they are the only one and has been assigned the secret index corresponding to the round $\\\omega_k = R$, otherwise there is a collision
- [notification] Everybody performs a LogicalOR with input 0, unless they received the index in this round, in which case they input 1
- If the output of LogicalOR is 0, no index was assigned and we repeat from step 2
- If the output of LogicalOR is 1, the index was assigned and we repeat from step 2 with $R += 1$
- Repeat from step 2 until all indices have been assigned
Subroutine 2: Verification
Input: A quantum state distributed and shared by $N$ parties, security parameter $S$ for RandomAgent
Output: If the state is a GHZ state $\\\rightarrow$ YES
Resources: Classical communication, random numbers, quantum state source, quantum channels- Everyone executes RandomAgent to choose uniformly at random one of the voters to be the verifier
- The verifier generates random angles $\\\theta_j \\\in [0,\\\pi)$ for all agents including themselves, such that the sum is a multiple of $\\\pi$. The angles are then sent out to all the agents
- Agent $j$ measures in the basis
$[|+\\\theta\\\rangle, |-\\\theta\\\rangle] = \\\left[\\\frac{1}{\\\sqrt{2}}(|0\\\rangle + e^{i\\\theta_j}|1\\\rangle), \\\frac{1}{\\\sqrt{2}}(|0\\\rangle – e^{i\\\theta_j}|1\\\rangle)\\\right]$ and publicly announces the result $Y_j \\\in \\\{0,1\\\}$ - The state passes the verification test when the following condition is satisfied:
if the sum of the randomly chosen angles is an even multiple of $\\\pi$, there must be an even number of 1 outcomes for $Y_j$;
if the sum is an odd multiple of $\\\pi$, there must be an odd number of 1 outcomes for:
$$Y_j: \\\bigoplus_j Y_j = \\\frac{1}{\\\pi} \\\sum_i \\\theta_i \\\mod 2$$
Subroutine 3: Voting
Input: Voting agent preference $v_k$
Output: All agents get one row of the bulletin board
Resources: Classical communication, GHZ source, quantum channels- Each agent measures the state they received in the Hadamard basis and records the outcome
- The outcomes of the measurement of each voter $k$ is $d_k$. Then we know that $\\\sum_k d_k = 0 \\\mod 2$
- The voting agent performs an XOR between the outcome $d_k$ and their vote $v_k$: $d_k \\\leftarrow d_k \\\oplus v_k$. However, this alone will still appear as a random string
- Every agent publicly broadcasts $d_k$ which gives one line $b_k$ of the bulletin board $B = \\\{b_k\\\}$
Subroutine 4: LogicalOR
Inputs: $N$ agents, $N$ boolean variables $x_i$, security parameter $S = (1 – 2^{-\\\Gamma})^\\\Sigma \\\in (0,1)$
Output: $y = \\\bigvee_{i}^{N} x_i$
Resources: Classical communication and random numbers- Decide $N$ random orderings, such that each voter is the last once. For each ordering repeat $\\\Sigma$ times the following
- Each voter $k$ gives an input $x_k$
- If $x_k = 0$, set $p_k = 0$, otherwise toss $\\\Gamma$ coins and set $p_k$ to 1 if the result is ‘all heads’ and to 0 otherwise
- Then each voter generates uniformly at random an $N$-bit string $r_k = r_k^1 r_k^2 … r_k^N$, such that $\\\bigoplus_{i=1}^{N} r_k^i = p_k$
- Voter $k$ sends $r_k^i$ to voter $i$ for all $i$, keeping $r_k^k$
- Each voter sums the received bits and broadcasts the parity $z_i = \\\bigoplus_{k=1}^{N} r_k^i$ according to the ordering
- Compute the parity of the original bits $y = \\\bigoplus_i z_i$
- From this everyone can also compute the parity of all other inputs except their own:
$w_k = \\\bigoplus_{i=1}^{N}(z_i \\\otimes r_k^i)$ - Repeat $\\\Sigma$ times from step 4: each time repeat with $p_k$ as new inputs
- If at least once in the $\\\Sigma$ repetitions for the various orderings $y = 1$, this is the output of the protocol; otherwise it is $y = 0$
Subroutine 5: RandomBit
Input: Security parameter $S$ to be used in LogicalOR, voting agent: probability distribution $D$
Output: The voting agent anonymously announces a random bit according to $D$
Resources: Classical communication and random numbers- Perform LogicalOR with security parameter $S$ where the voting agent inputs a random bit according to $D$ and the other agents input 0
Subroutine 6: RandomAgent
Input: Security parameter $S$ to be used in RandomBit, voting agent: probability distribution $D$
Output: The voting agent anonymously chooses a random agent according to $D$
Resources: Classical communication and random numbers- Repeat RandomBit $\\\log_2 N$ times
Experimental Implementations
No content has been added to this section, yet!
Further Information
Proofs of the protocol properties can be found in [1]
Subroutines 5-7 are classical anonymous protocols taken from Broadbent and Tapp(2007)[2] and used in Unnikrishnan et al.(2018)[3]
Subroutine 3 is the same as that of Pappa et al.(2011)[4]References
- Centrone, Federico, Eleni Diamanti, and Iordanis Kerenidis. “Quantum protocol for electronic voting without election authorities.” Physical Review Applied 18, no. 1 (2022): 014005.
- Broadbent, Anne, and Alain Tapp. “Information-theoretic security without an honest majority.” In International Conference on the Theory and Application of Cryptology and Information Security, pp. 410-426. Berlin, Heidelberg: Springer Berlin Heidelberg, 2007.
- Unnikrishnan, Anupama, Ian J. MacFarlane, Richard Yi, Eleni Diamanti, Damian Markham, and Iordanis Kerenidis. “Anonymity for practical quantum networks.” Physical review letters 122, no. 24 (2019): 240501.
- Pappa, Anna, André Chailloux, Stephanie Wehner, Eleni Diamanti, and Iordanis Kerenidis. “Multipartite entanglement verification resistant against dishonest parties.” Physical review letters 108, no. 26 (2012): 260502.
- 2025-05-16 at 16:22 by Mina Doosti
implements Quantum Electronic Voting
Introduction
This protocol[1] achieves the functionality of Quantum Electronic Voting. In this protocol, an untrusted multipartite entanglement source can be used to carry out an election without any election authorities.
Outline
- In the first phase of the protocol, each agent is assigned a unique secret random index
- Next, we perform multiple rounds of voting, one for each agent. In each round, the following steps are carried out:
- The agent with the same index as the round number is designated the voter for that round
- The source distributes one qubit of a GHZ state to each agent. The voting agent randomly chooses to either verify the GHZ state or vote with a certain probability. This step, including state distribution, is repeated until the voter chooses to vote. Once voting is chosen, the voter anonymously transmits their vote to all agents.
- Finally, all the votes are tallied. All agents have the votes for each round and can thus verify the final tally.
Assumptions
- The protocol assumes the existence of an authentication channel.
- The protocol assumes the ability to share multi-party entangled quantum states. But the source doesn’t need to be trusted
Requirements
Network Stage: Entanglement generation
The protocol requires:
- Classical communication between the voting agents
- A multipartite entanglement source, assigned to each agent by a quantum channel. The source need not be trusted.
- Voting agents must be able to generate random numbers
Notation
- $N$: Number of agents
- $V = {v_k}_{k in [N]}$: The votes
- $S$: Security parameter
- $epsilon$: Distance from the perfect GHZ state
- $delta$: Threshold for verification
- $eta$: Probability of failure of verification
- $B$: Bulletin board — $N times N$ binary matrix. Each row corresponds to one round of voting, and each column contains the output of a single voter across all rounds
- $E$: Vote vector — The list of votes across $N$ rounds. Each element is computed as the parity of a row from $B$
- $T$: Final tally
Properties
- $(sigma_{H}, sigma_{D}, gamma)$-Correctness:} This notion of approximate correctness includes two properties:
- $sigma_{H}$-Completeness: If all agents are honest, the election is accepted with probability more than $sigma_{H}$ – $Pr[text{election accepted}] geq sigma_{H}$
- $(sigma_{D}, gamma)$-Soundness: the probability that the election result is accepted, given that the set of the votes $E$ computed from the bulletin board $B$ resulting from the election is more than $gamma$ away from the real votes $V$, is smaller than $sigma_{D}$ –
$$Prleft[text{election accepted} ;middle|; frac{1}{N} |V – E|_1 geq gamma right] leq sigma_{D}$$
- This particular protocol is $left([1 – epsilon(1 – S)]^{N},; S^{N(1 + lambda)[epsilon(1 – eta) + eta]},; (1 + lambda)[epsilon(1 – eta) + eta]right)text{-correct}$
for a small constant $lambda > 0$ - $zeta$-Privacy: The privacy of the election scheme implies that for any voter $k$, the probability that any subset of malicious parties $D$ that deviates from the honest protocol can guess the vote $v_{k}$ of the voter is at most $zeta$ more than in the case they just have access to the bulletin board and to their own votes –
$$forall k,quad Pr[v_{k} mid D] – Pr[v_{k} mid B, v_{j} in V_{D}] leq zeta $$ - This particular protocol is $zeta$-private with $zeta = (1 – eta)^N epsilon + left(1 – (1 – eta)^Nright)$
Other properties:
- Authentication: This e-voting protocol does not provide authentication, which should be taken care of by the physical implementation of the protocol.
- Double voting: Each voter can vote at most once. Since the number of voters is known in advance for this protocol, double voting is easily taken care of.
- Verifiability: Each voter can verify that their vote has been counted correctly. In this protocol, the tally is performed by the voters themselves. The bulletin board produced as an output of the protocol is public and can always be checked by everyone, while still appearing random.
- Receipt freeness: In order to prevent vote-selling, voters should not be able to prove how they voted. As the unique indices stay secret, voters cannot produce a receipt of their vote.
- Additional candidates: The protocol described here only allows an election consisting of 2 candidates. This can be extended to more candidates by repeating the protocol multiple times in sequence. In particular, if there are $K$ candidates, we can express each of them using $log_{2} K$ bits and repeat the election as many times so that each vote set corresponds to one bit. This however, does affect the correctness and privacy.
Technical Description
Main Protocol: Quantum e-voting
Inputs: $V = {v_k}_{k in [N]}$ – Set of votes; $S$ – Security parameter; $epsilon$ – Distance from the perfect GHZ state; $delta$-Threshold for verification; $eta$ – Probability of failure of verification
Output: The candidate with the majority votes or Abort
Resources: Classical communication, random numbers, N-qubit GHZ source, quantum channels- Phase 1 [getting unique secret indices]
- Agents perform UniqueIndex until each agent has a secret unique random index $omega_k$
- Phase 2 [casting votes]
- For $l = 1$ to $N$
- The voting agent is the agent $k$ with $omega_k = l$
- Repeat until Voting is announced
- The source distributes to each of the N agents one qubit of the GHZ source
- All agents $j in [N]$ set rejections$_j =$ trials$_j = 0$
- The voting agent tosses $log_2left[ frac{16Nepsilon^2}{(epsilon^2 – 4delta)^2} lnleft(frac{1}{eta}right) right]$
- The agents perform LogicalOR subroutine, where output 1 indicates Verification and output 0 indicates Voting. Everyone except the voting agent inputs 0; if the coin toss is ‘all heads’ the voting agent also inputs 0, otherwise the voting agent inputs 1
- If Verification is chosen, the agents perform RandomAgent and the voting agent anonymously picks an agent $j in [N]$ to be the verifier. Agent $j$ updates trials$_j += 1$ and if Verification outputs reject: rejections$_j += 1$
- If for any $j in [N]$, $delta_j = frac{text{rejections}_j}{text{trials}_j} > delta$, the protocol Aborts
- Perform Voting. The outcome is one row of the Bulletin Board $B$. The parity of the row gives one entry in the vote vector $E$
- Given the votes $E$, the tally $T$ can be computed
- For $l = 1$ to $N$
- Phase 3 [Verification of results]
All agents perform LogicalOR with security parameter $S$, and input 1 if their vote is not the same as the entry in $E$ for the round in which they voted, and 0 otherwise
If LogicalOR outputs 1, Abort the protocol.
Else output the candidate with the most votes according to the tally $T$
Subroutine 1: UniqueIndex
Input: Security parameter $S$ to be used in LogicalOR, $N$ random boolean variables $x_i$
Output: Each agent $k$ has a secret unique index $omega_k$
Resources: Classical communication and random numbers- Beginning of round $R = 1$
- Agents perform LogicalOR with inputs $x_k = 0$ if they already have an index and $x_k = 1$ if they do not
- If $y = 0$, repeat from step 2
- If an agent $k$ has a bit $x_k = 1$ and $omega_k = 0$ they know they are the only one and has been assigned the secret index corresponding to the round $omega_k = R$, otherwise there is a collision
- [notification] Everybody performs a LogicalOR with input 0, unless they received the index in this round, in which case they input 1
- If the output of LogicalOR is 0, no index was assigned and we repeat from step 2
- If the output of LogicalOR is 1, the index was assigned and we repeat from step 2 with $R += 1$
- Repeat from step 2 until all indices have been assigned
Subroutine 2: Verification
Input: A quantum state distributed and shared by $N$ parties, security parameter $S$ for RandomAgent
Output: If the state is a GHZ state $rightarrow$ YES
Resources: Classical communication, random numbers, quantum state source, quantum channels- Everyone executes RandomAgent to choose uniformly at random one of the voters to be the verifier
- The verifier generates random angles $theta_j in [0,pi)$ for all agents including themselves, such that the sum is a multiple of $pi$. The angles are then sent out to all the agents
- Agent $j$ measures in the basis
$[|+thetarangle, |-thetarangle] = left[frac{1}{sqrt{2}}(|0rangle + e^{itheta_j}|1rangle), frac{1}{sqrt{2}}(|0rangle – e^{itheta_j}|1rangle)right]$ and publicly announces the result $Y_j in {0,1}$ - The state passes the verification test when the following condition is satisfied:
if the sum of the randomly chosen angles is an even multiple of $pi$, there must be an even number of 1 outcomes for $Y_j$;
if the sum is an odd multiple of $pi$, there must be an odd number of 1 outcomes for:
$$Y_j: bigoplus_j Y_j = frac{1}{pi} sum_i theta_i mod 2$$
Subroutine 3: Voting
Input: Voting agent preference $v_k$
Output: All agents get one row of the bulletin board
Resources: Classical communication, GHZ source, quantum channels- Each agent measures the state they received in the Hadamard basis and records the outcome
- The outcomes of the measurement of each voter $k$ is $d_k$. Then we know that $sum_k d_k = 0 mod 2$
- The voting agent performs an XOR between the outcome $d_k$ and their vote $v_k$: $d_k leftarrow d_k oplus v_k$. However, this alone will still appear as a random string
- Every agent publicly broadcasts $d_k$ which gives one line $b_k$ of the bulletin board $B = {b_k}$
Subroutine 4: LogicalOR
Inputs: $N$ agents, $N$ boolean variables $x_i$, security parameter $S = (1 – 2^{-Gamma})^Sigma in (0,1)$
Output: $y = bigvee_{i}^{N} x_i$
Resources: Classical communication and random numbers- Decide $N$ random orderings, such that each voter is the last once. For each ordering repeat $Sigma$ times the following
- Each voter $k$ gives an input $x_k$
- If $x_k = 0$, set $p_k = 0$, otherwise toss $Gamma$ coins and set $p_k$ to 1 if the result is ‘all heads’ and to 0 otherwise
- Then each voter generates uniformly at random an $N$-bit string $r_k = r_k^1 r_k^2 … r_k^N$, such that $bigoplus_{i=1}^{N} r_k^i = p_k$
- Voter $k$ sends $r_k^i$ to voter $i$ for all $i$, keeping $r_k^k$
- Each voter sums the received bits and broadcasts the parity $z_i = bigoplus_{k=1}^{N} r_k^i$ according to the ordering
- Compute the parity of the original bits $y = bigoplus_i z_i$
- From this everyone can also compute the parity of all other inputs except their own:
$w_k = bigoplus_{i=1}^{N}(z_i otimes r_k^i)$ - Repeat $Sigma$ times from step 4: each time repeat with $p_k$ as new inputs
- If at least once in the $Sigma$ repetitions for the various orderings $y = 1$, this is the output of the protocol; otherwise it is $y = 0$
Subroutine 5: RandomBit
Input: Security parameter $S$ to be used in LogicalOR, voting agent: probability distribution $D$
Output: The voting agent anonymously announces a random bit according to $D$
Resources: Classical communication and random numbers- Perform LogicalOR with security parameter $S$ where the voting agent inputs a random bit according to $D$ and the other agents input 0
Subroutine 6: RandomAgent
Input: Security parameter $S$ to be used in RandomBit, voting agent: probability distribution $D$
Output: The voting agent anonymously chooses a random agent according to $D$
Resources: Classical communication and random numbers- Repeat RandomBit $log_2 N$ times
Experimental Implementations
No content has been added to this section, yet!
Further Information
Proofs of the protocol properties can be found in [1]
Subroutines 5-7 are classical anonymous protocols taken from Broadbent and Tapp(2007)[2] and used in Unnikrishnan et al.(2018)[3]
Subroutine 3 is the same as that of Pappa et al.(2011)[4]References
- Centrone, Federico, Eleni Diamanti, and Iordanis Kerenidis. “Quantum protocol for electronic voting without election authorities.” Physical Review Applied 18, no. 1 (2022): 014005.
- Broadbent, Anne, and Alain Tapp. “Information-theoretic security without an honest majority.” In International Conference on the Theory and Application of Cryptology and Information Security, pp. 410-426. Berlin, Heidelberg: Springer Berlin Heidelberg, 2007.
- Unnikrishnan, Anupama, Ian J. MacFarlane, Richard Yi, Eleni Diamanti, Damian Markham, and Iordanis Kerenidis. “Anonymity for practical quantum networks.” Physical review letters 122, no. 24 (2019): 240501.
- Pappa, Anna, André Chailloux, Stephanie Wehner, Eleni Diamanti, and Iordanis Kerenidis. “Multipartite entanglement verification resistant against dishonest parties.” Physical review letters 108, no. 26 (2012): 260502.
- 2025-05-16 at 14:54 by Mina Doosti
implements Quantum Electronic Voting
Introduction
This protocol[1] achieves the functionality of Quantum Electronic Voting. In this protocol, an untrusted multipartite entanglement source can be used to carry out an election without any election authorities.
Outline
- In the first phase of the protocol, each agent is assigned a unique secret random index
- Next, we perform multiple rounds of voting, one for each agent. In each round, the following steps are carried out:
- The agent with the same index as the round number is designated the voter for that round
- The source distributes one qubit of a GHZ state to each agent. The voting agent randomly chooses to either verify the GHZ state or vote with a certain probability. This step, including state distribution, is repeated until the voter chooses to vote. Once voting is chosen, the voter anonymously transmits their vote to all agents.
- Finally, all the votes are tallied. All agents have the votes for each round and can thus verify the final tally.
Assumptions
- The protocol assumes the existence of an authentication channel.
- The protocol assumes the ability to share multi-party entangled quantum states. But the source doesn’t need to be trusted
Requirements
Network Stage: Entanglement generation
The protocol requires:
- Classical communication between the voting agents
- A multipartite entanglement source, assigned to each agent by a quantum channel. The source need not be trusted.
- Voting agents must be able to generate random numbers
Notation
- $N$: Number of agents
- $V = {v_k}_{k in [N]}$: The votes
- $S$: Security parameter
- $epsilon$: Distance from the perfect GHZ state
- $delta$: Threshold for verification
- $eta$: Probability of failure of verification
- $B$: Bulletin board — $N times N$ binary matrix. Each row corresponds to one round of voting, and each column contains the output of a single voter across all rounds
- $E$: Vote vector — The list of votes across $N$ rounds. Each element is computed as the parity of a row from $B$
- $T$: Final tally
Properties
props
Technical Description
techs
Experimental Implementations
No content has been added to this section, yet!
Further Information
No content has been added to this section, yet!
References
- Centrone, Federico, Eleni Diamanti, and Iordanis Kerenidis. “Quantum protocol for electronic voting without election authorities.” Physical Review Applied 18, no. 1 (2022): 014005.