In the dynamic landscape of digital information, the rise of misinformation and fake news presents a pressing challenge. This paper takes a completely new approach to verifying news, inspired by how quantum actors can reach agreement even when they are spatially spread out. We propose a radically new, to the best of our knowledge, algorithm that uses quantum “entanglement” (think of it as a special connection) to help news aggregators sniff out bad actors, whether they be other news sources or even fact-checkers trying to spread misinformation. This algorithm doesn't rely on quantum signatures, it just uses basic quantum technology we already have, in particular, special pairs of particles called “EPR pairs” that are much easier to create than other options. More complex entangled states are like juggling too many balls – they're hard to make and slow things down, especially when many players are involved. For instance, bigger, more complex states like “GHZ states” work for small groups, but they become messy with larger numbers. So, we stick with Bell states, the simplest form of entanglement, which are easy to generate no matter how many players are in the game. This means our algorithm is faster to set up, works for any number of participants, and is more practical for real-world use. Bonus points: it finishes in a fixed number of steps, regardless of how many players are involved, making it even more scalable. This new approach may lead to a powerful and efficient way to fight misinformation in the digital age, using the weird and wonderful world of quantum mechanics.

Keywords:: Fake news, quantum algorithms, quantum entanglement, Bell states, quantum games.

§ INTRODUCTION

In the contemporary digital era, the proliferation of fake news, defined as deliberately false information masquerading as legitimate news, has emerged as a pervasive challenge across online and social media platforms. The rapid dissemination of misinformation poses serious repercussions, eroding trust in institutions, inciting violence, and undermining democratic processes. The urgent need for robust fake news detection mechanisms is more pronounced than ever. Fake news flourishes in the online realm due to several contributing factors. The accessibility of content creation and sharing, coupled with the absence of stringent oversight and anonymity, empowers malicious actors to disseminate false narratives with impunity. Furthermore, social media algorithms, often designed to prioritize sensational and engaging content, inadvertently amplify the reach of fake news.

The prevalence of fake news underscores the necessity for the development and deployment of effective detection techniques. One strategy involves leveraging fact-checking organizations to manually verify the veracity of information. However, this approach is labor-intensive and unable to cope with the sheer volume of content produced daily. Alternatively, employing artificial intelligence (AI) and machine learning (ML) methodologies offers promise in automatically identifying fake news. These algorithms can scrutinize various factors, including language usage, writing style, and source reliability, to flag potentially misleading content. Despite the potential of AI-driven detection methods, they encounter challenges. Fake news purveyors continuously adapt their strategies to evade detection, and AI models may exhibit biases or inaccuracies if trained on inadequate or skewed datasets. A paradox emerges as AI, while possessing the capability to identify and mitigate false news, simultaneously facilitates the proliferation of such deceptive online content. Notwithstanding these obstacles, the pursuit of effective fake news detection remains imperative. By combating the dissemination of misinformation, we safeguard individuals and society against its deleterious effects, nurturing a more informed, civil, and democratic online discourse.

Recent research ([1]) underscores the necessity for social media platforms to integrate diverse content verification techniques alongside existing algorithms and AI approaches to combat false news effectively. Additionally, taxonomy frameworks like the one proposed in [2, 3], which categorizes false news into distinct types, can aid social media platforms in alerting users to potentially misleading content, contingent upon agreed-upon standards for content analysis. The endeavor to automate the detection and prevention of false news presents formidable challenges, particularly concerning the assessment of content legitimacy ([4, 5]). Contemporary efforts predominantly rely on machine learning techniques to identify and mitigate fake news articles, as evidenced by numerous recent scholarly works ([6, 7, 8, 9, 10, 11, 12, 13]). The fusion of AI with blockchain technology emerges as a promising avenue for combating fake news ([14]). This approach offers a decentralized and trustworthy platform for validating consent, authenticity, integrity, and perspectives on truth, thereby mitigating the spread of false narratives.

The quest for quantum computers that dethrone their classical counterparts continues. While we haven't reached the promised land yet, recent landmarks like IBM's 127-qubit Eagle [15], 433-qubit Osprey [16], and the colossal 1,121-qubit Condor [17] show the path forward is accelerating. Perhaps we are closer than we think to the quantum revolution. Given this broader context, it becomes evident that quantum technology has reached a level of maturity where it merits serious consideration for inclusion in a comprehensive framework aimed at combating misinformation, especially considering the potential of quantum computers to enhance the speed and efficiency of Machine Learning algorithms. Researchers are actively pursuing the development of algorithmic methods that could effectively detect fake news and deepfakes by integrating Quantum Machine Learning techniques [18]. Quantum Machine Learning seeks to merge the principles of quantum computing with those of Machine Learning, offering tangible advantages such as improved Deep Fake detection [19]. Tian et al. [20] proposed a fake news detection system utilizing quantum K-Nearest Neighbors. Furthermore, Google has introduced an open-source library for Quantum Machine Learning, suggesting the potential for quantum computing to address fake and deepfake challenges in the near term [21].

However, this paper explores a distinct quantum approach. It does not rely on Quantum Machine Learning, but, instead, draws inspiration from successful quantum protocols that achieve distributed consensus and detectable Byzantine Agreement in distributed environments (refer to recent work by Andronikos et al. [22] and related literature). We acknowledge the prevalent practice in contemporary social media platforms, wherein independent third-party fact-checking organizations, certified by impartial authorities, are employed to identify, assess, and take action on content. This fact-checking methodology primarily targets viral misinformation, particularly blatant falsehoods lacking factual basis. Ideally, fact-checking entities prioritize verifying demonstrably false claims that are both timely and impactful. Naturally, fact-checkers themselves should be subject to scrutiny and ongoing evaluation. The algorithm proposed herein envisions a decentralized setting where numerous news aggregators are overseen by multiple news verifiers responsible for content authentication. Described as a quantum game, our algorithm involves familiar figures such as Alice and Bob, alongside their numerous counterparts. Employing games in our presentation aims to facilitate comprehension of technical concepts. Quantum games, since their inception in 1999 [23, 24], have garnered significant attention. The main reason for his trend is the potential superiority of quantum strategies over classical ones [25, 26, 27, 28]. Notably, the renowned prisoners' dilemma game exemplifies this phenomenon, extending to other abstract quantum games as well [24, 29]. Moreover, the quantization of various classical systems can be applied to political structures, as demonstrated recently in [30]. In the realm of quantum cryptography, the presentation of protocols often takes the form of games, a common practice evident in recent works such as [31, 32, 33, 34, 22, 35]. Quantum strategies have demonstrated superiority over classical ones in various scenarios [25, 26, 27, 28]. The prisoners' dilemma game serves as a prominent example, and its applicability extends to other abstract quantum games [24, 29]. Notably, the quantization of classical systems finds applications even in political structures [30]. In the broader context of game-theoretic applications, unconventional environments, such as biological systems, have garnered significant attention [36, 37, 38]. It's intriguing to note that biological systems may give rise to biostrategies that outperform classical ones, even in iconic games like the Prisoners' Dilemma [39, 40, 41, 42, 43].

Contribution. This paper introduces a novel perspective on the pressing issue of news verification by drawing inspiration from quantum protocols achieving distributed consensus, diverging from the more conventional Quantum Machine Learning approach. We present the first entanglement-based algorithm, to the best of our knowledge, designed for news aggregators to identify potential malicious actors. These actors could include other news aggregators or, even more concerning, fact-checkers intentionally disseminating misinformation.

The key advantage of our algorithm, which does not rely on a quantum signature scheme, lies in its compatibility with current quantum technology, as it solely depends on EPR pairs. While more complex multi-particle entangled states are possible, they are challenging to produce with existing quantum systems, leading to extended preparation times and complexity, particularly in scenarios involving numerous participants. For example, while contemporary quantum computers can easily generate $\ket{GHZ_n}$ states for small values of $n$, the preparation and distribution of these states become increasingly difficult as $n$ grows. Therefore, we exclusively employ Bell states, the simplest among maximally entangled states, in our algorithm.

Utilizing only EPR pairs, specifically $\ket{\Phi^+}$ pairs, regardless of the number of news aggregators and verifiers, results in reduced preparation time, improved scalability, and enhanced practicality. Additionally, our algorithm completes in a constant number of steps, irrespective of the number of participants, further enhancing its scalability and efficiency.

§.§ Organization

This article is organized as follows. The Introduction (Section <ref>) presents the subject matter, accompanied by bibliographic references to related works. A concise overview of the essential concepts is provided in Section <ref>, laying the foundation for understanding our protocol. A detailed explanation of the hypotheses underlying the QNVA is given in Section <ref>. The QNVA is formally presented in Section <ref>, explaining its inner workings in detail.
The paper concludes with a summary and discussion of the finer points of the algorithm in Section <ref>.

§ BACKGROUND & NOTATION

§.§ EPR pairs

Quantum entanglement is a phenomenon where two or more particles become linked in such a way that they share the same fate, despite being separated by vast distances. This connection is so powerful that measuring the properties of one particle instantly determines the corresponding properties of its entangled partner, regardless of the separation between them. This instantaneous correlation defies our classical understanding of the universe and has profound implications for quantum mechanics and its potential applications. Mathematically, a single product state is not sufficient to describe entangled states of composite systems. So, they must be described as a linear combination of two or more product states of their subsystems. The famous Bell states are special quantum states of two qubits, also called EPR pairs, that represent the simplest form of maximal entanglement. These states can be compactly described by the next formula from [44].

\begin{align} \label{eq: Bell States General Equation}
\ket{ \beta_{ x, y } } = \frac { \ket{ 0 } \ket{ y } + (-1)^x \ket{ 1 } \ket{ \overline{ y } } } { \sqrt{ 2 } } \ ,
\end{align}

where $\ket{ \overline{ y } }$ is the negation of $\ket{ y }$.

There are four Bell states and their specific mathematical expression is given below. The subscripts $A$ and $B$ are used to emphasize the subsystem to which the corresponding qubit belongs, that is, qubits $\ket{ \cdot }_{ A }$ belong to Alice and qubits $\ket{ \cdot }_{ B }$ belong to Bob.

grow to left by = 1.00 cm,
grow to right by = 0.00 cm,
colback = white,
enhanced jigsaw,

sharp corners,

toprule = 0.1 pt,
bottomrule = 0.1 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

\begin{align} \label{eq: Bell State Phi +}
\ket{ \Phi^{ + } } = \ket{ \beta_{ 00 } } = \frac { \ket{ 0 }_{ A } \ket{ 0 }_{ B } + \ket{ 1 }_{ A } \ket{ 1 }_{ B } } { \sqrt{ 2 } }
\end{align}

\begin{align} \label{eq: Bell State Phi -}
\ket{ \Phi^{ - } } = \ket{ \beta_{ 10 } } = \frac { \ket{ 0 }_{ A } \ket{ 0 }_{ B } - \ket{ 1 }_{ A } \ket{ 1 }_{ B } } { \sqrt{ 2 } }
\end{align}

\begin{align} \label{eq: Bell State Psi +}
\ket{ \Psi^{ + } } = \ket{ \beta_{ 01 } } = \frac { \ket{ 0 }_{ A } \ket{ 1 }_{ B } + \ket{ 1 }_{ A } \ket{ 0 }_{ B } } { \sqrt{ 2 } }
\end{align}

\begin{align} \label{eq: Bell State Psi -}
\ket{ \Psi^{ - } } = \ket{ \beta_{ 11 } } = \frac { \ket{ 0 }_{ A } \ket{ 1 }_{ B } - \ket{ 1 }_{ A } \ket{ 0 }_{ B } } { \sqrt{ 2 } }
\end{align}

For existing quantum computers based on the circuit model, it is quite trivial to produce Bell states. The proposed algorithm relies on $\ket{ \Phi^{ + } } = \frac { \ket{ 0 }_{ A } \ket{ 0 }_{ B } + \ket{ 1 }_{ A } \ket{ 1 }_{ B } } { \sqrt{ 2 } }$ pairs.

§.§ The state $\ket{ + }$

Apart from $\ket{ \Phi^{ + } }$ pairs, our scheme makes use of another signature state, namely $\ket{ + }$. For completeness, we recall the definition of $\ket{ + }$ below

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = white,
enhanced jigsaw,

sharp corners,

toprule = 0.1 pt,
bottomrule = 0.1 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

\begin{align} \label{eq: Ket +}
\ket{ + } = H \ket{ 0 } = \frac { \ket{ 0 } + \ket{ 1 } } { \sqrt{ 2 } }
\ .
\end{align}

State $\ket{ + }$ can be readily produced by applying the Hadamard transform on $\ket{ 0 }$. In the rest of this paper, the set of bit values $\{ 0, 1 \}$ is denoted by $\mathbb { B }$. As a final note, let us clarify that measurements are always performed with respect to the computational basis $\{ \ket{ 0 }, \ket{ 1 } \}$.

§ HYPOTHESES & SETTING

Before we proceed with the comprehensive presentation of the proposed algorithm, it is useful to explicitly state the envisioned setting and the hypotheses that underlie the execution of our algorithm.

§.§ The protagonists

As we have previously mentioned, we follow what can, almost, be considered a tradition and describe the proposed algorithm as a game. The players in this game are the spatially distributed news verifiers and news aggregators, collectively called Alice and Bob. First, we state the actors that appear in our settings and clarify the roles they are supposed to play.

* A trusted quantum source. There exists a trusted quantum source that generates single qubits in the $\ket{ + }$ state and EPR pairs in the $\ket{ \Phi^{ + } }$ state. The source also distributes these qubits to all other players through appropriate quantum channels, according to the entanglement distribution scheme outlined in the forthcoming Definition <ref>.

* News verifiers. There exist $m$ special players that are called news verifiers. Their mission is to fact-check every piece of news and classify it as true of fake. In our game this role is undertaken by Alice and her clones, who are denoted by Alice$_{ 1 }$, …, Alice$_{ m }$. The news verifiers work independently of each other, and no communication, classical or quantum, takes place between any two of them.

* News aggregators. There are also $n$ players that are called news aggregators, and whose purpose is to gather and disseminate news that have been certified as true. This role is assumed by Bob and his clones that are denoted by Bob$_{ 1 }$, …, Bob$_{ n }$, where, typically, $n > m$.

§.§ The connections among the players

Besides the players listed above, there is a network of quantum and classical channels that enables the exchange of information among the players. In particular, we assume the existence of the following communication channels.

* It is more realistic to consider that each Alice clone is not responsible for all news aggregators, but only for a specific group of news aggregators that are under her supervision. Henceforth, we shall assume that each Alice$_{ i }$, $1 \leq i \leq m$, is connected via pairwise authenticated classical channels to a specific subset of news aggregators who constitute her active network, and Alice$_{ i }$ is their coordinator. These aggregators are Alice$_{ i }$'s receivers, their cardinality is denoted by $n_{ i }$ and they are designated by Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$.

* Each Alice$_{ i }$, $1 \leq i \leq m$, sends two things to every Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, in her active network:

$\Diamond$	The result of the verification check, denoted by $c_{ k }^{ i }$.

$\Diamond$	A proof sequence, denoted by $\mathbf { p }_{ k }^{ i }$, which is intended to convince Bob$_{ k }^{ i }$ that she is honest.

The situation is visually depicted in Figure <ref>.

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = MagentaLight!03,
enhanced jigsaw,

sharp corners,

toprule = 1.0 pt,
bottomrule = 1.0 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

[scale = 1.00]
⦜360 /

shade, top color = WordBlueDarker25, bottom color = black, rectangle, text width = 10.00 cm, align = center
] ( Label ) at ( 0.0, 7.00 )

Alice$_{ i }$ sends the verification outcome $c_{ k }^{ i }$ and the proof sequence $\mathbf { p }_{ k }^{ i }$ to every Bob$_{ k }^{ i }$ in her active network.

[ line width = 2.00 pt, MyBlue ] ( 0, 0 ) circle [ radius = cm ];

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] east: Bob$_{ 1 }^{ i }$
( ) at (  * cos(1 * ⦜) ,  * sin(1 * ⦜)  )  ;

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] west: Bob$_{ 2 }^{ i }$
( ) at (  * cos(3 * ⦜) ,  * sin(3 * ⦜)  )  ;

[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * cos(4 * ⦜) ,  * sin(4 * ⦜)  ) ;

[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * cos(5 * ⦜) ,  * sin(5 * ⦜)  ) ;

[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * cos(6 * ⦜) ,  * sin(6 * ⦜)  ) ;

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] east: Bob$_{ n_{ i } }^{ i }$
( ) at (  * cos(7 * ⦜) ,  * sin(7 * ⦜)  )  ;

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] south: Alice$_{ i }$
(Alice) at ( 0.00, 0.00 )  ;

[on background layer]
∠/ in  45/1, 135/2, 315/n_ i
[ MyDarkBlue, ->, - Latex [ width = 14mm, length = 9mm ] , line width = 6.25 mm, ]
(  1.00 * cos(∠) ,  1.00 * sin(∠)  ) –
(  4.25 * cos(∠) ,  4.25 * sin(∠)  )
node [ midway, text = white, rotate = ∠] $c_{ \index }^{ i }, \ \mathbf { p }_{ \index }^{ i }$;

∠in  180, 225, 270
[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * 0.65 * cos(∠) ,  * 0.65 * sin(∠)  ) ;

[ anchor = center, below = 5.00 cm of Alice ] (PhantomNode)  ;

The above figure illustrates the fact that Alice$_{ i }$, $1 \leq i \leq m$, sends the verification outcome $c_{ k }^{ i }$ and the proof sequence $\mathbf { p }_{ k }^{ i }$ to every Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, in her active network.

* All news aggregators that belong to the same active network are connected via pairwise authenticated classical channels. This enables them to exchange, whenever they deem necessary, the verification outcomes and the proof sequences they received from their coordinator. This action can be considered as an extra layer of verification and an indirect way in which aggregators can assess the honesty of other aggregators and also of the coordinator. This topology is shown in Figure <ref>. We clarify that aggregators that have no coordinator in common, do not communicate in any way.

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = MagentaLight!03,
enhanced jigsaw,

sharp corners,

toprule = 1.0 pt,
bottomrule = 1.0 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

[scale = 1.00]
⦜360 /

shade, top color = WordAquaLighter80, bottom color = WordAquaDarker25, rectangle, text width = 11.00 cm, align = center
] ( Label ) at ( 0.0, 7.00 )

Aggregators Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$ that have the same coordinator Alice$_{ i }$ exchange the verification outcomes and the proof sequences they received from Alice$_{ i }$ through pairwise authenticated classical channels.

[ line width = 2.00 pt, MagentaDark ] ( 0, 0 ) circle [ radius = cm ];

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] east: Bob$_{ 1 }^{ i }$
(Dave) at (  * cos(1 * ⦜) ,  * sin(1 * ⦜)  )  ;

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] west: Bob$_{ 2 }^{ i }$
(Charlie) at (  * cos(3 * ⦜) ,  * sin(3 * ⦜)  )  ;

[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * cos(4 * ⦜) ,  * sin(4 * ⦜)  ) ;

[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * cos(5 * ⦜) ,  * sin(5 * ⦜)  ) ;

[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * cos(6 * ⦜) ,  * sin(6 * ⦜)  ) ;

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] east: Bob$_{ n_{ i } }^{ i }$
(Bob) at (  * cos(7 * ⦜) ,  * sin(7 * ⦜)  )  ;

[on background layer]
[ MagentaVeryLight, <->,  Latex [ width = 14mm, length = 9mm ] - Latex [ width = 14mm, length = 9mm ] , line width = 6.25 mm, ]
(Charlie.east) – (Dave.west)
node [ black, near start, sloped ]  $c_{ 1 }^{ i }, \ \mathbf { p }_{ 1 }^{ i }$
node [ black, near end, sloped ]  $c_{ 2 }^{ i }, \ \mathbf { p }_{ 2 }^{ i }$ ;
[ MagentaVeryLight, <->,  Latex [ width = 14mm, length = 9mm ] - Latex [ width = 14mm, length = 9mm ] , line width = 6.25 mm, ]
(Bob.north west) – (Charlie.south east)
node [ black, near start, sloped ]  $c_{ 2 }^{ i }, \ \mathbf { p }_{ 2 }^{ i }$
node [ black, near end, sloped ]  $c_{ n_{ i } }^{ i }, \ \mathbf { p }_{ n_{ i } }^{ i }$ ;
[ MagentaVeryLight, <->,  Latex [ width = 14mm, length = 9mm ] - Latex [ width = 14mm, length = 9mm ] , line width = 6.25 mm, ]
(Bob.north) – (Dave.south)
node [ black, near start, sloped ]  $c_{ 1 }^{ i }, \ \mathbf { p }_{ 1 }^{ i }$
node [ black, near end, sloped ]  $c_{ n_{ i } }^{ i }, \ \mathbf { p }_{ n_{ i } }^{ i }$ ;

∠in  180, 225, 270
[ shade, shading = ball, ball color = WordAquaLighter80, circle ] () at (  * 0.65 * cos(∠) ,  * 0.65 * sin(∠)  ) ;

[ anchor = center, below = 5.00 cm of Alice ] (PhantomNode)  ;

The above figure illustrates the fact that all news aggregators with the same coordinator Alice$_{ i }$, i.e., Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$, can exchange the verification outcomes and the proof sequences they received from Alice$_{ i }$ through pairwise authenticated classical channels.

* Every news aggregator is responsible for maintaining the reputation system outlined below, independently, and in parallel with every other news aggregator.

$\Diamond$	A news ranking system that characterizes news as either true or fake.

$\Diamond$	A reputation catalog that reflects the personal assessment of the aggregator regarding every other player (both verifier and aggregator) involved in information exchange.

News deemed as fake must be appropriately flagged as such, so that the public is made aware of this. The reputation catalog takes the form of two lists containing the unreliable verifiers and aggregators.

The intuition behind the latter hypothesis

quite straightforward. It is expedient to record and consider unreliable those players that have exhibited contradictory and/or malicious behavior, and distinguish them from those players that have demonstrated consistent adherence to the rules and have a history of accurate and truthful reporting. By maintaining these records, each aggregator plays an important role in ensuring the integrity and efficiency of the news network. By identifying and isolating unreliable entities, he helps to protect the network from malicious actors and maintain the trust among participants.

§ THE QUANTUM NEWS VERIFICATION ALGORITHM

In this section we present the quantum news verification algorithm, or QNVA for short. Every Alice is tasked with verifying important news, and sending the result of her verification check to all her agents.

$\Diamond$	If the news in question passed the verification check, then Alice sends via the classical channel the bit $1$ to every Bob in her active network to signify its credibility. Additionally, she sends a personalized proof, which is a sequence of bits, to each of her agents. The important thing here is that for each Bob the proof is different because it is constructed specifically for him.

$\Diamond$	Symmetrically, if the news failed to pass the check, Alice sends via the classical channel the bit $0$ to every agent in her active network to indicate that it is fake, together with a personalized proof.

The QNVA is presented from the point of view of the individual Bob, where, of course, we assume that all Bobs implement the same algorithm consistently. The algorithm itself can be conceptually organized into $3$ distinct phases.

§.§ The entanglement distribution phase

The first is the entanglement distribution phase, which refers to the generation and distribution of entangled $\ket{ \Phi^{ + } }$ pairs and qubits in the $\ket{ + }$ state. As we have explained in hypothesis ($\mathbf { H }_{ 1 }$), we assume the existence of a trusted quantum source that undertakes this task. In view of the capabilities of modern quantum apparatus, the trusted quantum source should have no difficulty in accomplishing this task. In terms of notation, we use the small Latin letters $q$ and $r$, with appropriate subscripts and superscripts, to designate the first and the second qubit, respectively, of the same $\ket{ \Phi^{ + } }$ pair.

The trusted source creates two types of sequences, one that is intended for verifiers and one that is intended for aggregators. Both are distributed through quantum channels to their intended recipients. Specifically, for each piece of news that must be checked, and for each Alice$_{ i }$, $1 \leq i \leq m$, the source creates

$\Diamond$	one verification sequence $\mathbf { q }^{ i }$ that is sent to Alice$_{ i }$ and has the form

\begin{align}
\mathbf { q }^{ i }
\underbrace { \colorbox {WordAquaLighter40} { $q_{ n_{ i }, d }^{ i } \dots q_{ k, d }^{ i } \dots q_{ 1, d }^{ i }$ } }_{ \text{ tuple } d }
\cdots
\underbrace { \colorbox {WordAquaLighter60} { $q_{ n_{ i }, 2 }^{ i } \dots q_{ k, 2 }^{ i } \dots q_{ 1, 2 }^{ i }$ } }_{ \text{ tuple } 2 }
\underbrace { \colorbox {WordAquaLighter80} { $q_{ n_{ i }, 1 }^{ i } \dots q_{ k, 1 }^{ i } \dots q_{ 1, 1 }^{ i }$ } }_{ \text{ tuple } 1 }
\ , \text{ and }
\label{eq: Alice's Verification Sequence}
\end{align}

$\Diamond$	$n_{ i }$ verification sequences $\mathbf { r }_{ 1 }^{ i }$, $\mathbf { r }_{ 2 }^{ i }$, …, $\mathbf { r }_{ n_{ i } }^{ i }$ sent to Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$, respectively, that have the form

\begin{align}
\mathbf { r }_{ k }^{ i }
\underbrace { \colorbox {WordLightGreen} { $\ket{ + } \dots r_{ k, d }^{ i } \dots \ket{ + }$ } }_{ \text{ tuple } d }
\cdots
\underbrace { \colorbox {WordLightGreen!66} { $\ket{ + } \dots r_{ k, 2 }^{ i } \dots \ket{ + }$ } }_{ \text{ tuple } 2 } \
\underbrace { \colorbox {WordLightGreen!33} { $\ket{ + } \dots r_{ k, 1 }^{ i } \dots \ket{ + }$ } }_{ \text{ tuple } 1 }
\ , \ 1 \leq k \leq n_{ i }
\ .
\label{eq: Bob's Verification Sequence}
\end{align}

In the $\mathbf { q }^{ i }$ and $\mathbf { r }_{ 1 }^{ i }$, $\mathbf { r }_{ 2 }^{ i }$, …, $\mathbf { r }_{ n_{ i } }^{ i }$ sequences, the subscript $d$ is a positive integer called the degree of accuracy of the verification. Furthermore, according to our convention, $q_{ k, l }^{ i }$ and $r_{ k, l }^{ i }$ denote the first and second qubits of the same $\ket{ \Phi^{ + } }$ pair that is used in the formation of the $l^{ th }$ tuple. Obviously, $\ket{ + }$ designates qubits that are in the $\ket{ + }$ state.

The situation regarding the sequences of qubits distributed to Alice$_{ i }$ and the Bobs in her active network is visualized in Figure <ref>.

grow to left by = 1.50 cm,
grow to right by = 1.50 cm,
colback = MagentaLight!03,
enhanced jigsaw,

sharp corners,

toprule = 1.0 pt,
bottomrule = 1.0 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ,
[ scale = 0.25 ]

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] west: Alice$_{ i }$
(Alice)  ;
matrix of nodes, nodes in empty cells,
column sep = 0.000 mm, right = 0.50 of Alice,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = RedPurple!50, inner color = white ] (A-n-d)  $q_{ n_{ i }, d }^{ i }$ ;
[ shade, outer color = WordAquaLighter60, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (A-2-d)  $q_{ 2, d }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (A-1-d)  $q_{ 1, d }^{ i }$ ;

[ shade, outer color = RedPurple!50, inner color = white ] (A-n-2)  $q_{ n_{ i }, 2 }^{ i }$ ;
[ shade, outer color = WordAquaLighter60, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (A-2-2)  $q_{ 2, 2 }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (A-1-2)  $q_{ 1, 2 }^{ i }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = RedPurple!50, inner color = white ] (A-n-1)  $q_{ n_{ i }, 1 }^{ i }$ ;
[ shade, outer color = WordAquaLighter60, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (A-2-1)  $q_{ 2, 1 }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (A-1-1)  $q_{ 1, 1 }^{ i }$ ;

scale = 1.50,
anchor = center,
above = 1.50 cm of Alice,
label =  [ label distance = 0.00 cm ] west: Bob$_{ n_{ i } }^{ i }$
(Bob)  ;
column sep = 0.000 mm, right = 0.50 of Bob,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = RedPurple!50, inner color = white ] (B-n-d)  $r_{ n_{ i }, d }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;

[ shade, outer color = RedPurple!50, inner color = white ] (B-n-2)  $r_{ n_{ i }, 2 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = RedPurple!50, inner color = white ] (B-n-1)  $r_{ n_{ i }, 1 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;

anchor = center,
above = 1.00 cm of Bob,
(Dots)  ⋮;
column sep = 0.000 mm, right = 3.00 of Dots,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

scale = 1.50,
anchor = center,
above = 1.00 cm of Dots,
label =  [ label distance = 0.00 cm ] west: Bob$_{ 2 }^{ i }$
(Charlie)  ;
column sep = 0.000 mm, right = 0.50 of Charlie,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (C-2-d)  $r_{ 2, d }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;

[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (C-2-2)  $r_{ 2, 2 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (C-2-1)  $r_{ 2, 1 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;

scale = 1.50,
anchor = center,
above = 1.50 cm of Charlie,
label =  [ label distance = 0.00 cm ] west: Bob$_{ 1 }^{ i }$
(Dave)  ;
column sep = 0.000 mm, right = 0.50 of Dave,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (D-1-d)  $r_{ 1, d }^{ i }$ ;

[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (D-1-2)  $r_{ 1, 2 }^{ i }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $\ket{ + }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (D-1-1)  $r_{ 1, 1 }^{ i }$ ;

[on background layer]
[ RedPurple, -, >=stealth, line width = 0.7 mm, decoration = coil, decorate ]
(A-n-d.center) – (B-n-d.center);
[ RedPurple, -, >=stealth, line width = 0.7 mm, decoration = coil, decorate ]
(A-n-2.center) – (B-n-2.center);
[ RedPurple, -, >=stealth, line width = 0.7 mm, decoration = coil, decorate ]
(A-n-1.center) – (B-n-1.center);

[ GreenLighter2, -, >=stealth, line width = 0.7 mm, decoration = coil, decorate ]
(A-2-d.center) – (C-2-d.center);
[ GreenLighter2, -, >=stealth, line width = 0.7 mm, decoration = coil, decorate ]
(A-2-2.center) – (C-2-2.center);
[ GreenLighter2, -, >=stealth, line width = 0.7 mm, decoration = coil, decorate ]
(A-2-1.center) – (C-2-1.center);

[ WordBlueVeryLight, -, >=stealth, line width = 0.7mm , decoration = coil, decorate ]
(A-1-d.center) – (D-1-d.center);
[ WordBlueVeryLight, -, >=stealth, line width = 0.7mm , decoration = coil, decorate ]
(A-1-2.center) – (D-1-2.center);
[ WordBlueVeryLight, -, >=stealth, line width = 0.7mm , decoration = coil, decorate ]
(A-1-1.center) – (D-1-1.center);

above right = 2.00 cm and 7.50 cm of Dave, anchor = center, shade, top color = MagentaLighter, bottom color = black, rectangle, text width = 9.50 cm, align = center
The entangled sequences of qubits distributed to Alice and the news aggregators in her active network. ;

[ anchor = west, below = 0.50 cm of Alice ] (PhantomNode1)  ;
[ anchor = west, above = 0.25 cm of Label ] (PhantomNode2)  ;

The above figure depicts the entangled sequences of qubits distributed to Alice and the news aggregators in her active network. Qubits that belong to the same $\ket{ \Phi^{ + } }$ pair are indicated by the same color and a wavy line that connects them. Specifically, blue indicates the EPR pairs shared between Alice$_{ i }$ and Bob$_{ 1 }^{ i }$, which occupy position $1$ in each $n_{ i }$-tuple of the $\mathbf { q }^{ i }$ and $\mathbf { r }_{ 1 }^{ i }$ sequences. Analogously, green is used for the EPR pairs shared between Alice$_{ i }$ and Bob$_{ 2 }^{ i }$, and red for the EPR pairs linking Alice$_{ i }$ and Bob$_{ n_{ i } }^{ i }$. The silver qubits designate those in the $\ket{ + }$ state that fill the remaining positions of the sequences $\mathbf { r }_{ 1 }^{ i }$, $\mathbf { r }_{ 2 }^{ i }$, …, $\mathbf { r }_{ n_{ i } }^{ i }$.

The visual convention is to draw qubits that belong to the same $\ket{ \Phi^{ + } }$ pair with the same color. Blue is used to indicate the EPR pairs shared between Alice$_{ i }$ and Bob$_{ 1 }^{ i }$, which occupy position $1$ in each $n_{ i }$-tuple of the $\mathbf { q }^{ i }$ and $\mathbf { r }_{ 1 }^{ i }$ sequences. Analogously, green is used for the EPR pairs shared between Alice$_{ i }$ and Bob$_{ 2 }^{ i }$ located in the second position of every $n_{ i }$-tuple of the $\mathbf { q }^{ i }$ and $\mathbf { r }_{ 2 }^{ i }$ sequences, and red signifies EPR pairs linking Alice$_{ i }$ and Bob$_{ n_{ i } }^{ i }$ occupying the last position of every $n_{ i }$-tuple of the $\mathbf { q }^{ i }$ and $\mathbf { r }_{ n_{ i } }^{ i }$ sequences. The silver qubits designate those in the $\ket{ + }$ state that fill the remaining positions of the sequences $\mathbf { r }_{ 1 }^{ i }$, $\mathbf { r }_{ 2 }^{ i }$, …, $\mathbf { r }_{ n_{ i } }^{ i }$. The intuition behind the construction of the above quantum sequences is outlined below.

* Alice$_{ i }$, $1 \leq i \leq m$, is linked to each one of her agents Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$ because her verification sequence $\mathbf { q }^{ i }$ is entangled with their verification sequences sequences $\mathbf { r }_{ 1 }^{ i }$, $\mathbf { r }_{ 2 }^{ i }$, …, $\mathbf { r }_{ n_{ i } }^{ i }$.

* All these quantum sequences are made up of $d$ in total $n_{ i }$-tuples of qubits.

* Sequence $\mathbf { q }^{ i }$ is made up exclusively from entangled qubits.

* In $\mathbf { q }^{ i }$ the qubits in position $1$, namely $q_{ 1, 1 }^{ i }$, $q_{ 1, 2 }^{ i }$, …, $q_{ 1, d }^{ i }$, are entangled with the corresponding qubits $r_{ 1, 1 }^{ i }$, $r_{ 1, 2 }^{ i }$, …, $r_{ 1, d }^{ i }$ of the sequence $\mathbf { r }_{ 1 }^{ i }$ that belongs to Bob$_{ 1 }^{ i }$. This is because $q_{ 1, l }^{ i }$ and $r_{ 1, l }^{ i }$, $1 \leq l \leq d$, belong to the same $\ket{ \Phi^{ + } }$ pair by construction.

* For precisely the same reason, the qubits in position $k, \ k = 2, \dots, n_{ i }$, i.e., $q_{ k, 1 }^{ i }$, $q_{ k, 2 }^{ i }$, …, $q_{ k, d }^{ i }$, are entangled with the corresponding qubits $r_{ k, 1 }^{ i }$, $r_{ k, 2 }^{ i }$, …, $r_{ k, d }^{ i }$ of the sequence $\mathbf { r }_{ k }^{ i }$ owned by Bob$_{ k }^{ i }$.

* In every sequence $\mathbf { r }_{ k }^{ i }$, $k = 1, \dots, n_{ i }$, the qubits $r_{ k, l }^{ i }$, $l = 1, \dots, d$, that occupy the $k^{ th }$ position in each $n_{ i }$-tuple, are entangled with the corresponding qubits $q_{ k, l }^{ i }$ of $\mathbf { q }^{ i }$. All other qubits are in the $\ket{ + }$ state.

In Section <ref>, where we discuss the effect of the degree of accuracy of the QNVA, we shall suggest appropriate values for $d$.

In view of the structural form of the sequences defined by formulae (<ref>) and (<ref>), we also refer to them as $( d, n_{ i } )$ quantum sequences because they are constructed by $d$ repetitions of structurally similar tuples of the same length, namely $n_{ i }$. These $d$ tuples are enumerated as shown in (<ref>) and (<ref>), that is tuple $1$ is the rightmost tuple and tuple $d$ is the leftmost tuple.

§.§ Entanglement validation phase

Undoubtedly, this is a most crucial phase, as the entire algorithm hinges upon the existence of entanglement. Without guaranteed entanglement, the algorithm's functionality is compromised. The validation procedure can result into two distinct outcomes. If entanglement is successfully ascertained, the QNVA can proceed to confidently verify the information at hand. Failure to validate entanglement indicates the absence of the necessary entanglement. This could stem from either noisy quantum channels or malicious interference from an adversary. Regardless of the cause, the only viable solution is to halt the ongoing algorithm execution and commence the entire procedure anew, after implementing corrective measures.

Given its utmost significance, this phase has undergone thorough scrutiny in the existing literature. Our algorithm adheres to the sophisticated methodologies outlined in prior works, including [45, 46, 47, 48, 49, 50]. Hence, to preclude redundant exposition, we direct the reader to the previously mentioned bibliography for all the details essential for the successful implementation of this phase.

§.§ The news verification phase

Our algorithm classifies news as true or fake during the third and last phase, aptly named news verification phase. To initiate this phase, Alice$_{ i }$ and the agents in her active network, Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$, measure their quantum sequences to obtain the classical bit sequences denoted by the lower case bold letters $\mathbf { a }^{ i }$ and $\mathbf { b }_{ 1 }^{ i }$, $\mathbf { b }_{ 2 }^{ i }$, …, $\mathbf { b }_{ n_{ i } }^{ i }$, respectively. Taking into account the entanglement distribution scheme of Definition <ref>, we see that the measurement has revealed some important correlations among these sequences. These correlations are depicted in the next Figure <ref>.

grow to left by = 1.50 cm,
grow to right by = 1.50 cm,
colback = MagentaLight!03,
enhanced jigsaw,

sharp corners,

toprule = 1.0 pt,
bottomrule = 1.0 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]
[ scale = 0.25 ]

scale = 1.50,
anchor = center,
label =  [ label distance = 0.00 cm ] west: Alice$_{ i }$
(Alice)  ;
matrix of nodes, nodes in empty cells,
column sep = 0.000 mm, right = 0.50 of Alice,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = RedPurple!50, inner color = white ] (A-n-d)  $a_{ n_{ i }, d }^{ i }$ ;
[ shade, outer color = WordAquaLighter60, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (A-2-d)  $a_{ 2, d }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (A-1-d)  $a_{ 1, d }^{ i }$ ;

[ shade, outer color = RedPurple!50, inner color = white ] (A-n-2)  $a_{ n_{ i }, 2 }^{ i }$ ;
[ shade, outer color = WordAquaLighter60, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (A-2-2)  $a_{ 2, 2 }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (A-1-2)  $a_{ 1, 2 }^{ i }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = RedPurple!50, inner color = white ] (A-n-1)  $a_{ n_{ i }, 1 }^{ i }$ ;
[ shade, outer color = WordAquaLighter60, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (A-2-1)  $a_{ 2, 1 }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (A-1-1)  $a_{ 1, 1 }^{ i }$ ;

scale = 1.50,
anchor = center,
above = 1.50 cm of Alice,
label =  [ label distance = 0.00 cm ] west: Bob$_{ n_{ i } }^{ i }$
(Bob)  ;
column sep = 0.000 mm, right = 0.50 of Bob,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = RedPurple!50, inner color = white ] (B-n-d)  $b_{ n_{ i }, d }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 2, d }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 1, d }^{ i }$ ;

[ shade, outer color = RedPurple!50, inner color = white ] (B-n-2)  $b_{ n_{ i }, 2 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 2, 2 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 1, 2 }^{ i }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = RedPurple!50, inner color = white ] (B-n-1)  $b_{ n_{ i }, 1 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 2, 1 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 1, 1 }^{ i }$ ;

anchor = center,
above = 1.00 cm of Bob,
(Dots)  ⋮;
column sep = 0.000 mm, right = 3.00 of Dots,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

scale = 1.50,
anchor = center,
above = 1.00 cm of Dots,
label =  [ label distance = 0.00 cm ] west: Bob$_{ 2 }^{ i }$
(Charlie)  ;
column sep = 0.000 mm, right = 0.50 of Charlie,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ n_{ i }, d }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (C-2-d)  $b_{ 2, d }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 1, d }^{ i }$ ;

[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ n_{ i }, 2 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (C-2-2)  $b_{ 2, 2 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 1, 2 }^{ i }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ n_{ i }, 1 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = GreenLighter2!50, inner color = white ] (C-2-1)  $b_{ 2, 1 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 1, 1 }^{ i }$ ;

scale = 1.50,
anchor = center,
above = 1.50 cm of Charlie,
label =  [ label distance = 0.00 cm ] west: Bob$_{ 1 }^{ i }$
(Dave)  ;
column sep = 0.000 mm, right = 0.50 of Dave,
nodes =  circle, minimum size = 12 mm, semithick, font = ,

[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ n_{ i }, d }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 2, d }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (D-1-d)  $b_{ 1, d }^{ i }$ ;

[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ n_{ i }, 2 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 2, 2 }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (D-1-2)  $b_{ 1, 2 }^{ i }$ ;

[ minimum size = 0.1 mm ]  ;

[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ n_{ i }, 1 }^{ i }$ ;
[ shade, outer color = WordIceBlue, inner color = white ]  …;
[ shade, outer color = WordIceBlue, inner color = white ]  $b_{ 2, 1 }^{ i }$ ;
[ shade, outer color = WordBlueVeryLight, inner color = white ] (D-1-1)  $b_{ 1, 1 }^{ i }$ ;

above right = 2.00 cm and 8.00 cm of Dave, anchor = center, shade, top color = WordDarkTeal, bottom color = black, rectangle, text width = 10.00 cm, align = center
The classical bit sequences resulting after the measurement of the quantum sequences and their correlations. ;

[ anchor = west, below = 0.50 cm of Alice ] (PhantomNode1)  ;
[ anchor = west, above = 0.25 cm of Label ] (PhantomNode2)  ;

This figure shows the classical bit sequences that result after Alice and the news aggregators measure their quantum sequences. The correlations among pairs of bits in these sequences are visualized by drawing correlated pairs with the same color.

Upon measuring their qubit sequences, news verifier Alice$_{ i }$ and news aggregators Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$, obtain the classical bit sequences $\mathbf { a }^{ i }$ and $\mathbf { b }_{ 1 }^{ i }$, $\mathbf { b }_{ 2 }^{ i }$, …, $\mathbf { b }_{ n_{ i } }^{ i }$, respectively, that can be written explicitly as follows.

\begin{align}
\mathbf { a }^{ i }
\underbrace { \colorbox {WordAquaLighter40} { $a_{ n_{ i }, d }^{ i } \dots a_{ k, d }^{ i } \dots a_{ 1, d }^{ i }$ } }_{ \text{ tuple } d }
\cdots
\underbrace { \colorbox {WordAquaLighter60} { $a_{ n_{ i }, 2 }^{ i } \dots a_{ k, 2 }^{ i } \dots a_{ 1, 2 }^{ i }$ } }_{ \text{ tuple } 2 }
\underbrace { \colorbox {WordAquaLighter80} { $a_{ n_{ i }, 1 }^{ i } \dots a_{ k, 1 }^{ i } \dots a_{ 1, 1 }^{ i }$ } }_{ \text{ tuple } 1 }
\ , \text{ and }
\label{eq: Alice's Classical Bit Sequence}
\\
\mathbf { b }_{ k }^{ i }
\underbrace { \colorbox {WordLightGreen} { $b_{ n_{ i }, d }^{ i } \dots b_{ k, d }^{ i } \dots b_{ 1, d }^{ i }$ } }_{ \text{ tuple } d }
\cdots
\underbrace { \colorbox {WordLightGreen!50} { $b_{ n_{ i }, 2 }^{ i } \dots b_{ k, 2 }^{ i } \dots b_{ 1, 2 }^{ i }$ } }_{ \text{ tuple } 2 } \
\underbrace { \colorbox {WordLightGreen!25} { $b_{ n_{ i }, 1 }^{ i } \dots b_{ k, 1 }^{ i } \dots b_{ 1, 1 }^{ i }$ } }_{ \text{ tuple } 1 }
\label{eq: Bob's Classical Bit Sequence}
\ ,
\end{align}

where $k = 1, \dots, n_{ i }$.

Although the sequences defined by formulae (<ref>) and (<ref>) consist of classical bits, their structural form is identical to that of the original qubit sequences. So, we will also refer to them as $( d, n_{ i } )$ classical sequences because they are constructed by repeating $d$ times structurally similar tuples of length $n_{ i }$. Following this line of thought, we may consider an arbitrary $( d, n_{ i } )$ sequence $\mathbf { s }$ made of symbols from some fixed alphabet, and express it in an alternative but equivalent way, emphasizing its composition in terms of $n_{ i }$-tuples, as follows.

\begin{align}
\mathbf { s }
\underbrace { \colorbox {WordAquaLighter40} { $s_{ n_{ i }, d } \dots s_{ 2, d } s_{ 1, d }$ } }_{ \text{ tuple } d }
\cdots
\underbrace { \colorbox {WordAquaLighter60} { $s_{ n_{ i }, 2 } \dots s_{ 2, 2 } s_{ 1, 2 }$ } }_{ \text{ tuple } 2 }
\underbrace { \colorbox {WordAquaLighter80} { $s_{ n_{ i }, 1 } \dots s_{ 2, 1 } s_{ 1, 1 }$ } }_{ \text{ tuple } 1 }
\nonumber \\
\mathbf { s }
\hspace{ 1.05 cm }
\overset { \downarrow } { \colorbox {MagentaVeryLight} { $\mathbf { s }_{ d }$ } }
\hspace{ 1.00 cm }
\cdots
\hspace{ 1.05 cm }
\overset { \downarrow } { \colorbox {MagentaVeryLight!40!MyLightRed} { $\mathbf { s }_{ 2 }$ } }
\hspace{ 2.00 cm }
\overset { \downarrow } { \colorbox {MyLightRed} { $\mathbf { s }_{ 1 }$ } }
\label{eq: Classical Bit Sequence Tuple Form}
\ .
\end{align}

Let us also clarify that by writing $\mathbf { s } = \mathbf { s }_{ d } \cdots \mathbf { s }_{ 2 } \mathbf { s }_{ 1 }$, where $\mathbf { s }_{ l } = s_{ n_{ i }, l } \dots s_{ 2, l } s_{ 1, l }$ and $1 \leq l \leq d$, we have effectively enumerated the $d$ tuples of $\mathbf { s }$ in a way that $1$ is the rightmost and $d$ is the leftmost tuple. In the rest of our exposition, we will also need a special $n_{ i }$-tuple that is constructed by using a new symbol $\ast$, different from $0$ and $1$. This is denoted by $\mathbf { s }_{ \ast }$ and is referred to the cryptic tuple.

\begin{align}
\mathbf { s }_{ \ast }
\underbrace { \colorbox {orange!25} { $\ast \ \dots \ \ast \ \ast$ } }_{ n_{ i } \text{ occurrences} }
\label{eq: The Special Tuple}
\ .
\end{align}

With the above convention, we may write Alice$_{ i }$'s bit sequence $\mathbf { a }^{ i }$ in the next form, emphasizing the fact that it is composed by $d$ tuples.

\begin{align}
\mathbf { a }^{ i }
\colorbox {WordAquaLighter40} { $\mathbf { a }_{ d }$ }
\cdots
\colorbox {WordAquaLighter60} { $\mathbf { a }_{ 2 }$ }
\colorbox {WordAquaLighter80} { $\mathbf { a }_{ 1 }$ }
\label{eq: Alice's Classical Bit Sequence Tuple Form}
% \ .
\end{align}

News verifier Alice$_{ i }$, $1 \leq i \leq m$, sends two things to all the news aggregators in her active network, namely Bob$_{ 1 }^{ i }$, Bob$_{ 2 }^{ i }$, …, Bob$_{ n_{ i } }^{ i }$:

$\Diamond$	The result of the verification check, denoted by $c_{ k }^{ i } \in \mathbb { B }$, which is just a single bit. If the news is true, then $c_{ k }^{ i }$ is just the bit $1$, whereas if the news is fake, $c_{ k }^{ i }$ is the bit $0$.

$\Diamond$	A proof sequence, denoted by $\mathbf { p }_{ k }^{ i }$, which is intended to convince Bob$_{ k }^{ i }$ that she is honest. Each proof sequence $\mathbf { p }_{ k }^{ i }$ is a $( d, n_{ i } )$ sequence of symbols from $\mathbb { B } \cup \{ \ast \}$, i.e., $\mathbf { p }_{ k }^{ i } = \mathbf { p }_{ d } \ \dots \ \mathbf { p }_{ 2 } \ \mathbf { p }_{ 1 }$. It is critical that these proof sequences be personalized, which effectively means they must be different for every news aggregator. Their construction is described below.

* If $c_{ k }^{ i } = 1$, the proof $\mathbf { p }_{ k }^{ i }$ sequence sent to news aggregator Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, also designated by $\mathds{ 1 }_{ k }^{ i }$ for emphasis, has the explicit form shown below.

\begin{align}
\mathds{ 1 }_{ k }^{ i }
\mathbf { p }_{ d } \ \dots \ \mathbf { p }_{ 2 } \ \mathbf { p }_{ 1 }
\ ,
\ \text{ where } \
\mathbf { p }_{ l }
\left\{
\begin{matrix*}[l]
\ \mathbf { a }_{ l } & \text{ if } a_{ k, l }^{ i } = 1 \\
\ \mathbf { s }_{ \ast } & \text{ if } a_{ k, l }^{ i } = 0
\end{matrix*}
\right.
\ , \ 1 \leq l \leq d \ .
\label{eq: Bob's k Proof Sequence for True}
\end{align}

* Symmetrically, if $c_{ k }^{ i } = 0$, the proof sequence sent to Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, denoted by $\vmathbb{ 0 }_{ k }^{ i }$ for emphasis, has the following explicit form.

\begin{align}
\vmathbb{ 0 }_{ k }^{ i }
\mathbf { p }_{ d } \ \dots \ \mathbf { p }_{ 2 } \ \mathbf { p }_{ 1 }
\ ,
\ \text{ where } \
\mathbf { p }_{ l }
\left\{
\begin{matrix*}[l]
\ \mathbf { a }_{ l } & \text{ if } a_{ k, l }^{ i } = 0 \\
\ \mathbf { s }_{ \ast } & \text{ if } a_{ k, l }^{ i } = 1
\end{matrix*}
\right.
\ , \ 1 \leq l \leq d \ .
\label{eq: Bob's k Proof Sequence for Fake}
\end{align}

A proof sequence for a verification check $c_{ k }^{ i }$ that is faithfully constructed according to Definition <ref> is said to be consistent with $c_{ k }^{ i }$. The previous Definition <ref> guarantees that, no matter what the verification outcome is, Bob$_{ k }^{ i }$ receives a different proof sequence from every other Bob$_{ k^{ \prime } }^{ i }$ when $k^{ \prime } \neq k$. The other crucial property that characterizes the proof sequences is the fact that besides tuples comprised entirely of $0$ and $1$ bits, they also contain a statistically equal number of cryptic tuples consisting of the special symbol $\ast$. Probabilistic analysis allows Bob$_{ k }^{ i }$ to assess whether or not Alice$_{ i }$ and the other Bobs act honestly and consistently. To this end, it is necessary to examine the positions of the $n_{ i }$-tuples that contain specific combinations of bits.

\mathbf { s }
\underbrace { s_{ n_{ i }, d } \dots s_{ 2, d } s_{ 1, d } }_{ \text{ tuple } d }
\cdots
\underbrace { s_{ n_{ i }, 2 } \dots s_{ 2, 2 } s_{ 1, 2 } }_{ \text{ tuple } 2 }
\underbrace { s_{ n_{ i }, 1 } \dots s_{ 2, 1 } s_{ 1, 1 } }_{ \text{ tuple } 1 }
be a $( d, n_{ i } )$ sequence. If $k$ and $k^{ \prime }$, $1 \leq k \neq k^{ \prime } \leq n_{ i }$, are two given indices, and $x, y \in \mathbb { B }$, we define the following sets

\begin{align}
P_{ x } ( \mathbf { s }, k )
\{ l \ \vert \ s_{ k, l }  = x \}
\ ,
\label{eq: P_x Definition}
\\
P_{ x, y } ( \mathbf { s }, k, k^{ \prime } )
\{ l \ \vert \ s_{ k, l }  = x \wedge s_{ k^{ \prime }, l }  = y \}
\ , \text{ and }
\label{eq: P_xy Definition}
\\
P_{ \ast } ( \mathbf { s } )
\{ l \ \vert \ \mathbf { s }_{ l } = \mathbf { s }_{ \ast } \}
\ .
\label{eq: P_* Definition}
\end{align}

The previous definition completes the necessary machinery and notation for the presentation of the QNVA. We may now proceed to explain the QNVA in detail and, at the same time, prove its correctness. In the rest of this section, we present the algorithm from the point of view of the typical news aggregator Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$. In what follows, we use the notation $\lvert S \rvert$ to designate the number of elements of a given set $S$.

In today's complex news environment malicious intent can manifest in many subtle ways. One may easily envision the next most critical scenarios.

* An unreliable and dishonest Alice$_{ i }$ sends to Bob$_{ k }^{ i }$ the verification outcome $c_{ k }^{ i }$, but the latter is accompanied with the wrong proof sequence $\mathbf { p }_{ k }^{ i }$.

* A malicious news aggregator, say Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$), falsely claims that he received from Alice$_{ i }$ the opposite verification outcome accompanied by a consistent proof sequence.

* An insidious Alice$_{ i }$ deliberately spreads disinformation and confusion by sending opposite verification outcomes $c_{ k }^{ i }$ and $\overline { c_{ k }^{ i } }$ to Bob$_{ k }^{ i }$ and Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$), using consistent proof sequences $\mathbf { p }_{ k }^{ i }$ and $\mathbf { p }_{ k^{ \prime } }^{ i }$ in each case.

The first scenario (S$_{ 1 }$) can be easily detected and countered by the QNVA. The second scenario (S$_{ 2 }$) can also be countered with additional effort. Our algorithm can also deal with the third scenario (S$_{ 3 }$), which reveals the existence of a truly malicious Alice, with some additional inference on the part of Bob. QNVA owes its ability to cope with each one of the above scenarios to the structural properties of the proof sequences. These properties are a direct result of the entanglement distribution scheme explained in Definition <ref>. The next Proposition <ref> lays the groundwork for the subsequent analysis of our verification procedures.

Let us assume that news aggregator Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, has received from his coordinator Alice$_{ i }$, $1 \leq i \leq m$, the verification outcome $c_{ k }^{ i } \in \mathbb { B }$, and the proof sequence $\mathbf { p }_{ k }^{ i }$. If the proof sequence $\mathbf { p }_{ k }^{ i }$ is consistent with $c_{ k }^{ i }$, then it must satisfy the following properties.

\begin{align}
\mathbb { E }
\left[
\
\lvert
\
P_{ c_{ k }^{ i } }
( \mathbf { p }_{ k }^{ i }, k )
\
\rvert
\
\right]
\mathbb { E }
\left[
\
\lvert
\
P_{ \ast }
( \mathbf { p }_{ k }^{ i } )
\
\rvert
\
\right]
\frac { d } { 2 }
\ , \ \text{and}
\label{eq: Expected Number of Tuples with Specific Value in Position k}
\\
\mathbb { E }
\left[
\
\lvert
\
P_{ c_{ k }^{ i }, c_{ k }^{ i } }
( \mathbf { p }_{ k }^{ i }, k, k^{ \prime }  )
\
\rvert
\
\right]
\mathbb { E }
\left[
\
\lvert
\
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } }
( \mathbf { p }_{ k }^{ i }, k, k^{ \prime }  )
\
\rvert
\
\right]
\frac { d } { 4 }
\ , \ \forall k^{ \prime } \ , \ 1 \leq k^{ \prime } \neq k \leq n_{ i } \ .
\label{eq: Expected Number of Tuples with Specific Values in Positions k & k'}
\end{align}

The proof is quite straightforward because it is based on the entanglement distribution scheme of Definition <ref>. The entanglement distribution scheme stipulates that each $n_{ i }$-tuple in the original qubit sequence of Alice$_{ i }$ shares one $\ket{ \Phi^{ + } } = \frac { \ket{ 0 }_{ A } \ket{ 0 }_{ k } + \ket{ 1 }_{ A } \ket{ 1 }_{ k } } { \sqrt{ 2 } }$ pair with every Bob$_{ k }^{ i }$, $k = 1, \dots, n_{ i }$. Therefore, there are $d$ in total bits $a_{ k, l }^{ i }$ that occupy the $k^{ th }$ position in every tuple $l$ of $\mathbf { a }^{ i }$, $1 \leq l \leq d$, which are equal to the corresponding bits $b_{ k, l }^{ i }$ of $\mathbf { b }_{ k }^{ i }$. This is captured by the next formula:

\begin{align}
a_{ k, l }^{ i } = b_{ k, l }^{ i }
\ , \ 1 \leq l \leq d \ .
\label{eq: Alice & Bob's k Equal Bits}
\end{align}

The remaining bits of $\mathbf { b }_{ k }^{ i }$ result from measuring qubits in the $\ket{ + }$ state. Hence, we expect half of them to end up $0$, and the remaining half to end up $1$. More importantly though, these bits are not correlated with the corresponding bits of $\mathbf { a }^{ i }$. Consequently, we can easily draw the following conclusions.

* Measuring a pair of qubits in the $\ket{ \Phi^{ + } }$ state will result in both qubits collapsing in state $\ket{ 0 }$ with probability $0.5$, or in state $\ket{ 1 }$ with probability $0.5$. This implies that the expected number of the $a_{ k, l }^{ i }$ and $b_{ k, l }^{ i }$ bits with value $1 (0)$ is $\frac { d } { 2 }$. Consequently, the expected number of tuples in $\mathbf { a }^{ i }$ (and in $\mathbf { b }_{ k }^{ i }$) in which the bit in the $k^{ th }$ position has value $1 (0)$ is $\frac { d } { 2 }$. Thus, irrespective of whether the verification outcome $c_{ k }^{ i }$ is $1$ or $0$, the expected number of tuples in $\mathbf { p }_{ k }^{ i }$ in which the bit in the $k^{ th }$ position has value $c_{ k }^{ i }$ is $\frac { d } { 2 }$, which proves property (<ref>). This also means that the expected number of the remaining tuples in $\mathbf { p }_{ k }^{ i }$, which are cryptic tuples according to Definition <ref>, is also $\frac { d } { 2 }$.

* Measuring two pairs of qubits, both in the $\ket{ \Phi^{ + } }$ state, will result in both qubits of the first pair collapsing in state $\ket{ 0 }$ with probability $0.5$, or in state $\ket{ 1 }$ with probability $0.5$, and, independently, both qubits of the second pair collapsing in state $\ket{ 0 }$ with probability $0.5$, or in state $\ket{ 1 }$ with probability $0.5$. This means that the expected number of the $a_{ k, l }^{ i }$ and $a_{ k^{ \prime }, l }^{ i }$ bits with values “$00$”, “$01$”, “$10$”, and “$11$” is $\frac { d } { 4 }$. Consequently, the expected number of tuples in $\mathbf { a }^{ i }$ in which the bits in positions $k$ and $k^{ \prime }$ contain any one of the aforementioned combinations is $\frac { d } { 4 }$. Thus, irrespective of whether the verification outcome $c_{ k }^{ i }$ is $1$ or $0$, the expected number of tuples in $\mathbf { p }_{ k }^{ i }$ in which the bits in positions $k$ and $k^{ \prime }$ are $c_{ k }^{ i } c_{ k }^{ i }$ or $c_{ k }^{ i } \overline { c_{ k }^{ i } }$ is $\frac { d } { 4 }$, which proves property (<ref>).

This completes the proof of this proposition.

The properties outlined in Proposition <ref> are instrumental in the design of the verification tests that are used as subroutines for the QNVA. These tests, which are performed by every news aggregator Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, in order to assess whether or not the coordinator Alice$_{ i }$ and the other news aggregators are honest, are based on the verification outcome $c_{ k }^{ i }$ and the proof sequence $\mathbf { p }_{ k }^{ i }$ that Bob$_{ k }^{ i }$ has received from Alice$_{ i }$.

As we have emphasized, our algorithm can handle all three scenarios mentioned above. For the first scenario (S$_{ 1 }$), the verification test IsAlice'sProofConsistent contained in Figure <ref> can decide whether or not $\mathbf { p }_{ k }^{ i }$ is consistent with $c_{ k }^{ i }$ by checking if it satisfies Proposition <ref>. It relies on the auxiliary test IsProofBalanced shown below. It is essential to point out that in a real implementation of these tests one must take into account the possible imperfections of the quantum channel, and the probabilistic outcome of the measurements. That means that the stringent equality requirement of the expected values as expressed in the propositions should be relaxed and one should instead check for approximate equality $\approx$ or approximate inequality $\napprox$. In the presentation of the pseudocode, we adopt the following conventions.

* $i$, $1 \leq i \leq m$, is the index of Alice$_{ i }$

* $k$, $1 \leq k \leq n_{ i }$, is the index of Bob$_{ k }^{ i }$

* $c_{ k }^{ i }$ is the verification outcome that Alice$_{ i }$ sends to Bob$_{ k }^{ i }$

* $\mathbf { p }_{ k }^{ i }$ is the proof sequence that Alice$_{ i }$ sends to Bob$_{ k }^{ i }$

* $\mathbf { b }_{ k }^{ i }$ is the classical bit sequence of Bob$_{ k }^{ i }$

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = WordVeryLightTeal!50,
enhanced jigsaw,

sharp corners,

toprule = 0.10 pt,
bottomrule = 0.10 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

Auxiliary Test

IsProofBalanced$( i, k, c_{ k }^{ i }, \mathbf { p }_{ k }^{ i } )$

$r ( \neq k ) = 1$ $n_{ i }$

$N_{ 1 }
\lvert
\
P_{ c_{ k }^{ i }, c_{ k }^{ i } }
( \mathbf { p }_{ k }^{ i }, k, r )
\
\rvert

$N_{ 2 }
\lvert
\
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } }
( \mathbf { p }_{ k }^{ i }, k, r )
\
\rvert

$( N_{ 1 } \neq \frac { d } { 4 } \ \mathbf{ OR } \ N_{ 2 } \neq \frac { d } { 4 } )$

This auxiliary algorithm is invoked by Bob$_{ k }^{ i }$ during the main verification tests to ascertain whether property (<ref>) of Proposition <ref> holds.

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = WordVeryLightTeal!50,
enhanced jigsaw,

sharp corners,

toprule = 0.10 pt,
bottomrule = 0.10 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

Verification Test

IsAlice'sProofConsistent$( i, k, c_{ k }^{ i }, \mathbf { p }_{ k }^{ i }, \mathbf { b }_{ k }^{ i } )$

\lvert
\
P_{ c_{ k }^{ i } }
( \mathbf { p }_{ k }^{ i }, k )
\
\rvert

$N \neq \frac { d } { 2 }$

$l \in P_{ c_{ k }^{ i } } ( \mathbf { p }_{ k }^{ i }, k )$

$( p_{ k, l }^{ i } \neq b_{ k, l }^{ i } )$

IsProofBalanced$( i, k, c_{ k }^{ i }, \mathbf { p }_{ k }^{ i } )$

Bob$_{ k }^{ i }$ uses the above algorithm to check if the proof sequence $\mathbf { p }_{ k }^{ i }$ is consistent with the verification outcome $c_{ k }^{ i }$.

To cope with the second scenario (S$_{ 2 }$), the verification test IsBob'sProofConsistent contained in Figure <ref> can decide whether or not $\mathbf { p }_{ k }^{ i }$ is consistent with $c_{ k }^{ i }$ by virtue of the results proved in the next proposition.

Suppose that Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, has received from Alice$_{ i }$, $1 \leq i \leq m$, the verification outcome $c_{ k }^{ i } = 1$ $( c_{ k }^{ i } = 0 )$, and the consistent proof sequence $\mathds{ 1 }_{ k }^{ i }$ $( \vmathbb{ 0 }_{ k }^{ i } )$.

Let us further assume that Bob$_{ k }^{ i }$ has also received from Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$) the opposite verification outcome $c_{ k^{ \prime } }^{ i } = 0$ $( c_{ k^{ \prime } }^{ i } = 1 )$ and the sequence $\vmathbb{ 0 }_{ k^{ \prime } }^{ i }$ $( \mathds{ 1 }_{ k^{ \prime } }^{ i } )$ as proof. If $\vmathbb{ 0 }_{ k^{ \prime } }^{ i }$ $( \mathds{ 1 }_{ k^{ \prime } }^{ i } )$ is consistent with $0$ $( 1 )$, then, in addition to the properties listed in Proposition <ref>, it must also satisfy the following property.

\begin{align}
\left\{
\
\begin{matrix*}[l]
P_{ 1, 0 }
( \mathds{ 1 }_{ k }^{ i }, k, k^{ \prime } )
P_{ 1, 0 }
( \vmathbb{ 0 }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )
\\
\\
P_{ 0, 1 }
( \vmathbb{ 0 }_{ k }^{ i }, k, k^{ \prime } )
P_{ 0, 1 }
( \mathds{ 1 }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )
\end{matrix*}
\
\right\}
% \ .
\label{eq: The Explicit Equality of Tuples with Opposite Values in Positions k & k'}
\end{align}

Without loss of generality we consider the situation that has evolved as follows.

* Initially, Bob$_{ k }^{ i }$ received from Alice$_{ i }$ the verification outcome $c_{ k }^{ i } = 1$ and the consistent proof sequence $\mathds{ 1 }_{ k }^{ i }$, and

* subsequently, Bob$_{ k }^{ i }$ received from Bob$_{ k^{ \prime } }^{ i }$ the opposite verification outcome $c_{ k^{ \prime } }^{ i } = 0$ and the sequence $\vmathbb{ 0 }_{ k^{ \prime } }^{ i }$ as proof.

We shall prove that if $\vmathbb{ 0 }_{ k^{ \prime } }^{ i }$ is consistent with the outcome $0$, then, in addition to the properties listed in Proposition <ref>, it must also satisfy the properties outlined above.

The proof is an immediate consequence of the manner proof sequences are constructed. If we recall Definition <ref>, we see that the proof sequence $\mathds{ 1 }_{ k }^{ i }$ $( \vmathbb{ 0 }_{ k }^{ i } )$, which is consistent with the verification outcome $c_{ k }^{ i } = 1$ $( c_{ k }^{ i } = 0 )$, contains all the $n_{ i }$-tuples of Alice$_{ i }$'s bit sequence $\mathbf { a }^{ i }$ in which the bit in the $k^{ th }$ position has value $1$ $( 0 )$, including all those in which the bit in position $k^{ \prime }$ has the value $1$, and all those in which the bit in position $k^{ \prime }$ has the value $0$.

\begin{align}
\mathbf { a }^{ i }
\underbrace { \colorbox {WordAquaLighter40} { $a_{ n_{ i }, d }^{ i } \dots a_{ k, d }^{ i } \dots a_{ 1, d }^{ i }$ } }_{ \text{ tuple } d }
\cdots
\underbrace { \colorbox {WordAquaLighter60} { $a_{ n_{ i }, 2 }^{ i } \dots a_{ k, 2 }^{ i } \dots a_{ 1, 2 }^{ i }$ } }_{ \text{ tuple } 2 }
\underbrace { \colorbox {WordAquaLighter80} { $a_{ n_{ i }, 1 }^{ i } \dots a_{ k, 1 }^{ i } \dots a_{ 1, 1 }^{ i }$ } }_{ \text{ tuple } 1 }
\ , \text{ and }
\label{eq: Alice's Classical Bit Se quence}
\\
\mathbf { b }_{ k }^{ i }
\underbrace { \colorbox {WordLightGreen} { $b_{ n_{ i }, d }^{ i } \dots b_{ k, d }^{ i } \dots b_{ 1, d }^{ i }$ } }_{ \text{ tuple } d }
\cdots
\underbrace { \colorbox {WordLightGreen!50} { $b_{ n_{ i }, 2 }^{ i } \dots b_{ k, 2 }^{ i } \dots b_{ 1, 2 }^{ i }$ } }_{ \text{ tuple } 2 } \
\underbrace { \colorbox {WordLightGreen!25} { $b_{ n_{ i }, 1 }^{ i } \dots b_{ k, 1 }^{ i } \dots b_{ 1, 1 }^{ i }$ } }_{ \text{ tuple } 1 }
\label{eq: Bob's Classical Bit Se quence}
\ ,
\end{align}

Symmetrically, if the proof sequence $\vmathbb{ 0 }_{ k^{ \prime } }^{ i }$  $( \mathds{ 1 }_{ k^{ \prime } }^{ i } )$ is consistent with the opposite verification outcome $c_{ k^{ \prime } }^{ i } = 0$ $( c_{ k^{ \prime } }^{ i } = 1 )$, then it must contain all the $n_{ i }$-tuples of $\mathbf { a }^{ i }$ in which the bit in position $k^{ \prime }$ has value $0$ $( 1 )$, including all those in which the bit in position $k$ has the value $0$, and all those in which the bit in position $k$ has the opposite value $1$.

Therefore, if both proof sequences $\mathds{ 1 }_{ k }^{ i }$ and $\vmathbb{ 0 }_{ k^{ \prime } }^{ i }$ ($\vmathbb{ 0 }_{ k }^{ i }$ and $\mathds{ 1 }_{ k^{ \prime } }^{ i }$) are consistent with the verification checks $c_{ k }^{ i } = 1$ and $c_{ k^{ \prime } }^{ i } = 0$ ($c_{ k }^{ i } = 0$ and $c_{ k^{ \prime } }^{ i } = 1$), respectively, then they must contain all the $n_{ i }$-tuples of $\mathbf { a }^{ i }$ in which the bit in the $k^{ th }$ position has the value $1$ ($0$) and the bit in position $k^{ \prime }$ has the opposite value $0$ ($1$). Formally, we can express this fact as

\begin{align}
\left\{
\
\begin{matrix*}[l]
P_{ 1, 0 }
( \mathds{ 1 }_{ k }^{ i }, k, k^{ \prime } )
P_{ 1, 0 }
( \vmathbb{ 0 }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )
\\
\\
P_{ 0, 1 }
( \vmathbb{ 0 }_{ k }^{ i }, k, k^{ \prime } )
P_{ 0, 1 }
( \mathds{ 1 }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )
\end{matrix*}
\
\right\}
\ ,
\label{eq: Explicit Consistent Proofs Contain the Same Tuples with Opposite Values in Positions k & k'}
\end{align}

which concludes this proof.
The opposite case is completely symmetrical and will be omitted.

The previous proposition can be cast into its most general form as the following Corollary.

Let us assume that Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, has received

$\Diamond$	from Alice$_{ i }$, $1 \leq i \leq m$, the verification outcome $c_{ k }^{ i }$ and the sequence $\mathbf { p }_{ k }^{ i }$ as proof, and

$\Diamond$	from Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$) the opposite verification outcome $c_{ k^{ \prime } }^{ i } = \overline { c_{ k }^{ i } }$ and the sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ as proof.

Then, if both $\mathbf { p }_{ k^{ \prime } }^{ i }$ and $\mathbf { p }_{ k^{ \prime } }^{ i }$ are consistent with $c_{ k }^{ i }$ and $\overline { c_{ k }^{ i } }$, respectively, they must also satisfy the following property.

\begin{align}
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } }
( \mathbf { p }_{ k }^{ i }, k, k^{ \prime } )
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } }
( \mathbf { p }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )
% \ .
\label{eq: The Equality of Tuples with Opposite Values in Positions k & k'}
\end{align}

If we recall Definition <ref> again, we see that if the proof sequence $\mathbf { p }_{ k }^{ i }$ is consistent with $c_{ k }^{ i }$, then it contains all the $n_{ i }$-tuples of Alice$_{ i }$'s bit sequence $\mathbf { a }^{ i }$ in which the bit in the $k^{ th }$ position has value $c_{ k }^{ i }$, including all those in which the bit in position $k^{ \prime }$ has the same value $c_{ k }^{ i }$, and all those in which the bit in position $k^{ \prime }$ has the opposite value $\overline { c_{ k }^{ i } }$. Symmetrically, if the proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ is consistent with $\overline { c_{ k }^{ i } }$, then it contains all the $n_{ i }$-tuples of $\mathbf { a }^{ i }$ in which the bit in position $k^{ \prime }$ has value $\overline { c_{ k }^{ i } }$, including all those in which the bit in position $k$ has the same value $\overline { c_{ k }^{ i } }$, and all those in which the bit in position $k$ has the opposite value $c_{ k }^{ i }$. Therefore, if they are consistent, both proof sequences $\mathbf { p }_{ k }^{ i }$ and $\mathbf { p }_{ k^{ \prime } }^{ i }$ contain all the $n_{ i }$-tuples of $\mathbf { a }^{ i }$ in which the bit in the $k^{ th }$ position has value $c_{ k }^{ i }$ and the bit in position $k^{ \prime }$ has the opposite value $\overline { c_{ k }^{ i } }$. This is simply written as

\begin{align}
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } }
( \mathbf { p }_{ k }^{ i }, k, k^{ \prime } )
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } }
( \mathbf { p }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )
\ ,
\label{eq: Consistent Proofs Conatian the Same Tuples with Opposite Values in Positions k & k'}
\end{align}

which completes the proof of this corollary.

To sum it up, the property expressed by relation (<ref>) asserts that if two proof sequences $\mathbf { p }_{ k }^{ i }$ and $\mathbf { p }_{ k^{ \prime } }^{ i }$ that correspond to opposite outcomes $c_{ k }^{ i }$ and $\overline { c_{ k }^{ i } }$ are both consistent, then they must contain precisely the same tuples of $\mathbf { a }^{ i }$ in which the bit in the $k^{ th }$ position is $c_{ k }^{ i }$ and the bit in position $k^{ \prime }$ is $\overline { c_{ k }^{ i } }$. This property can be employed by Bob$_{ k }^{ i }$ to detect if Bob$_{ k^{ \prime } }^{ i }$ deliberately spreads misinformation, as formalized by the next Theorem <ref>.

Suppose that Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, has received from Alice$_{ i }$, $1 \leq i \leq m$, the verification outcome $c_{ k }^{ i }$, and the consistent proof sequence $\mathbf { p }_{ k }^{ i }$.

Any attempt by another news aggregator Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$) to falsely claim that he received $\overline { c_{ k }^{ i } }$ from Alice$_{ i }$, despite the fact that in reality he received $c_{ k }^{ i }$, and forge a proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ consistent with $\overline { c_{ k }^{ i } }$ will be detected by Bob$_{ k }^{ i }$.

The present situation concerns how a malicious Bob$_{ k^{ \prime } }^{ i }$ may try to deceive Bob$_{ k }^{ i }$ ($k^{ \prime } \neq k$). Bob$_{ k^{ \prime } }^{ i }$ has received from Alice$_{ i }$ the verification outcome $c_{ k }^{ i }$ together with a proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ consistent with $c_{ k }^{ i }$. Nevertheless, Bob$_{ k^{ \prime } }^{ i }$ intends to falsely claim that he has received $\overline { c_{ k }^{ i } }$. The question is: can Bob$_{ k^{ \prime } }^{ i }$ construct a convincing proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ consistent with $\overline { c_{ k }^{ i } }$. We proceed to show that this is probabilistically impossible.

Having received and validated $\mathbf { p }_{ k }^{ i }$, Bob$_{ k }^{ i }$ knows the set $P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k }^{ i }, k, k^{ \prime } )$ of the positions of all the $n_{ i }$-tuples of $\mathbf { a }^{ i }$ that contain $c_{ k }^{ i }$ and $\overline { c_{ k }^{ i } }$ in positions $k$ and $k^{ \prime }$ respectively.

On the other hand, Bob$_{ k^{ \prime } }^{ i }$ has received the proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ that is also consistent with $c_{ k }^{ i }$. Accordingly, Bob$_{ k^{ \prime } }^{ i }$ knows the following two facts.

* The indices of the $n_{ i }$-tuples of $\mathbf { a }^{ i }$ that contain $c_{ k }^{ i }$ in position $k^{ \prime }$, which includes those that also contain $c_{ k }^{ i }$ in position $k$, and those that also contain $\overline { c_{ k }^{ i } }$ in position $k$, i.e., the set

\begin{align}
P_{ c_{ k }^{ i } }
( \mathbf { p }_{ k^{ \prime } }^{ i }, k^{ \prime } )
P_{ c_{ k }^{ i }, c_{ k }^{ i } }
( \mathbf { p }_{ k^{ \prime } }^{ i }, k^{ \prime }, k )
\cup
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } }
( \mathbf { p }_{ k^{ \prime } }^{ i }, k^{ \prime }, k )
\ .
\end{align}

* The indices of the cryptic tuples $\mathbf { s }_{ \ast }$ of $\mathbf { a }^{ i }$, i.e., the set $P_{ \ast } ( \mathbf { p }_{ k^{ \prime } }^{ i } )$.

By knowing the indices of the cryptic tuples, Bob$_{ k^{ \prime } }^{ i }$ is able to infer with certainty, i.e., probability $1$, that these indices correspond to $n_{ i }$-tuples of $\mathbf { a }^{ i }$ that contain $\overline { c_{ k }^{ i } }$ in position $k^{ \prime }$. In his effort to forge a proof sequence consistent with $\overline { c_{ k }^{ i } }$, Bob$_{ k^{ \prime } }^{ i }$ will correctly place all the tuples of $\mathbf { a }^{ i }$ that contain $\overline { c_{ k }^{ i } }$ in position $k^{ \prime }$. According to Proposition <ref>, their expected number is $\frac { d } { 2 }$, so in reality they would be $\approx \frac { d } { 2 }$. So, Bob$_{ k^{ \prime } }^{ i }$ will avoid trivial mistakes, such as

* including a tuple where the bit in the $k^{ \prime }$ position has the wrong value, or

* using fewer than expected tuples with $\overline { c_{ k }^{ i } }$ in position $k^{ \prime }$.

Bob$_{ k^{ \prime } }^{ i }$'s real weakness stems from the fact that the tuples he must include in his forged proof sequence may contain either $c_{ k }^{ i }$ with probability $0.5$, or $\overline { c_{ k }^{ i } }$ with equal probability $0.5$ in the $k^{ th }$ position because Bob$_{ k^{ \prime } }^{ i }$ doesn't know with certainty, even for a single tuple, if it contains $c_{ k }^{ i }$ or $\overline { c_{ k }^{ i } }$ in position $k$. Therefore, when forging a proof sequence consistent with $\overline { c_{ k }^{ i } }$, Bob$_{ k^{ \prime } }^{ i }$ has to guess for every tuple whether to place $c_{ k }^{ i }$ or $\overline { c_{ k }^{ i } }$ in position $k$. Thus, he is prone to make two types of mistakes.

* Place $c_{ k }^{ i }$ in the $k^{ th }$ position of a wrong $n_{ i }$-tuple not contained in $P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k }^{ i }, k, k^{ \prime } )$.

* Place $\overline { c_{ k }^{ i } }$ in the $k^{ th }$ position of a wrong $n_{ i }$-tuple that does appear in $P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k }^{ i }, k, k^{ \prime } )$.

In other words, the question now becomes: how probable is for Bob$_{ k^{ \prime } }^{ i }$ to construct a proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ so that the set $P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )$ is equal to the set $P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k }^{ i }, k, k^{ \prime } )$?

The probability that Bob$_{ k^{ \prime } }^{ i }$ succeeds in doing so equals the probability of picking the one correct configuration out of many. The total number of configurations is equal to the number of ways to place $\approx \frac { d } { 4 }$ identical objects into $\approx \frac { d } { 2 }$ distinguishable boxes. Hence, the probability that Bob$_{ k^{ \prime } }^{ i }$ places all the $\approx \frac { d } { 4 }$ values $c_{ k }^{ i }$ correctly in the $\approx \frac { d } { 2 }$ cryptic $n_{ i }$-tuples is

\begin{align}
\left(
\text{Bob$_{ k^{ \prime } }^{ i }$ places all $c_{ k }^{ i }$ correctly}
\right)
\approx
\frac { 1 }
{ \binom { \ d / 2 \ } { \ d / 4 \ } }
\ ,
\label{eq: Probability Bob k' Deceives Bob k}
\end{align}

which is practically zero for appropriately chosen values of $d$. Thus, the end result will violate property (<ref>) of Corollary <ref>.

Ergo, when Bob$_{ k }^{ i }$ checks the consistency of the proof sequence sent by Bob$_{ k^{ \prime } }^{ i }$ he will easily detect inconsistencies and infer that Bob$_{ k^{ \prime } }^{ i }$ deliberately spreads disinformation.

So, to cope with the second scenario (S$_{ 2 }$), one may rely on the verification test IsBob'sProofConsistent shown in Figure <ref>, which can decide whether or not $\mathbf { p }_{ k^{ \prime } }^{ i }$ is consistent with $\overline { c_{ k }^{ i } }$, by checking if it satisfies property (<ref>) of Corollary <ref>.

We again note that in a real implementation of the next test we must take into account the possible imperfections of the quantum channel, and the probabilistic outcome of the measurements, which implies that the strict inequality requirement should be relaxed and we should test for approximate inequality $\napprox$. In the pseudocode, we use the following conventions.

* $i$, $1 \leq i \leq m$, is the index of Alice$_{ i }$

* $k$, $1 \leq k \leq n_{ i }$, is the index of Bob$_{ k }^{ i }$

* $k^{ \prime }$, $1 \leq k^{ \prime } \neq k \leq n_{ i }$, is the index of Bob$_{ k^{ \prime } }^{ i }$

* $c_{ k }^{ i }$ is the verification outcome that Alice$_{ i }$ has send to Bob$_{ k }^{ i }$

* $\mathbf { p }_{ k }^{ i }$ is the proof sequence that Alice$_{ i }$ has send to Bob$_{ k }^{ i }$

* $\overline { c_{ k }^{ i } }$ is the verification outcome that Bob$_{ k^{ \prime } }^{ i }$ claims he received from Alice$_{ i }$

* $\mathbf { p }_{ k^{ \prime } }^{ i }$ is the proof sequence that Bob$_{ k^{ \prime } }^{ i }$ claims he received from Alice$_{ i }$

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = WordVeryLightTeal!50,
enhanced jigsaw,

sharp corners,

toprule = 0.10 pt,
bottomrule = 0.10 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

Verification Test

IsBob'sProofConsistent$( i, k, k^{ \prime }, c_{ k }^{ i }, \mathbf { p }_{ k }^{ i }, \overline { c_{ k }^{ i } }, \mathbf { p }_{ k^{ \prime } }^{ i } )$

\lvert
\
P_{ \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k^{ \prime } }^{ i }, k^{ \prime } )
\
\rvert

$N \neq \frac { d } { 2 }$

$P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k }^{ i }, k, k^{ \prime } )
\neq
P_{ c_{ k }^{ i }, \overline { c_{ k }^{ i } } } ( \mathbf { p }_{ k^{ \prime } }^{ i }, k, k^{ \prime } )$

IsProofBalanced$( i, k^{ \prime }, \overline { c_{ k }^{ i } }, \mathbf { p }_{ k^{ \prime } }^{ i } )$

Bob$_{ k }^{ i }$ uses the above algorithm to check if $\mathbf { p }_{ k^{ \prime } }^{ i }$ is consistent with $\overline { c_{ k }^{ i } }$ that Bob$_{ k^{ \prime } }^{ i }$ claims to have received from Alice$_{ i }$.

By combining both verification checks, it is possible to detect an insidious Alice$_{ i }$ who deliberately spreads disinformation and confusion by sending opposite verification outcomes $c_{ k }^{ i }$ and $\overline { c_{ k }^{ i } }$ to Bob$_{ k }^{ i }$ and Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$), using the correct proof sequences $\mathbf { p }_{ k }^{ i }$ and $\mathbf { p }_{ k^{ \prime } }^{ i }$ in each case. This is analyzed in the following Theorem <ref>.

Suppose that Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, has received from Alice$_{ i }$, $1 \leq i \leq m$, the verification outcome $c_{ k }^{ i }$ and the consistent proof sequence $\mathbf { p }_{ k }^{ i }$.

Bob$_{ k }^{ i }$ infers that Alice$_{ i }$ is a malicious actor that deliberately spreads disinformation, if he also receives a proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ consistent with the opposite outcome $\overline { c_{ k }^{ i } }$ from another news aggregator Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$).

The present situation examines how a news aggregator can uncover an insidious news verifier Alice$_{ i }$ who deliberately spreads disinformation and confusion by sending the verification outcome $c_{ k }^{ i }$ to Bob$_{ k }^{ i }$ and, at the same time, sending the opposite verification outcome $\overline { c_{ k }^{ i } }$ to Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$), using consistent proof sequences $\mathbf { p }_{ k }^{ i }$ and $\mathbf { p }_{ k^{ \prime } }^{ i }$ in each case.

According to Theorem <ref>, the probability that another news aggregator Bob$_{ k^{ \prime } }^{ i }$ ($k^{ \prime } \neq k$) will manage to construct on his own a proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ consistent is negligible. Hence, if the verification test IsBob'sProofConsistent shown in Figure <ref> returns TRUE, the logical conclusion is that Alice$_{ i }$ herself must have sent the consistent proof sequence $\mathbf { p }_{ k^{ \prime } }^{ i }$ to Bob$_{ k^{ \prime } }^{ i }$.

Thus, Alice$_{ i }$ deliberately sends contradictory verification outcomes to create confusion and spread disinformation.

At this point, considering all the previous analysis, we present the proposed quantum news verification algorithm (QNVA) below. For every piece of news that must be checked, the QNVA is employed by each news aggregator Bob$_{ k }^{ i }$, $1 \leq k \leq n_{ i }$, independently and in parallel with every other news aggregator. In the presentation, we use the following notation.

* $i$, $1 \leq i \leq m$, is the index of Alice$_{ i }$

* $k$, $1 \leq k \leq n_{ i }$, is the index of Bob$_{ k }^{ i }$

* QNVA$( k )$ is the instance of QVNA executed by Bob$_{ k }^{ i }$

* $M_{ A }$ and $M_{ V }$ are the list of malicious news aggregators and news verifiers, respectively, as surmised by Bob$_{ k }^{ i }$. The purpose of the reputation lists is to identity insidious agents and ignore any further communication originating from them.

* $k^{ \prime }$, $1 \leq k^{ \prime } \neq k \leq n_{ i }$, is the index of Bob$_{ k^{ \prime } }^{ i }$

* $c_{ k }^{ i }$ is the verification outcome that Alice$_{ i }$ has send to Bob$_{ k }^{ i }$

* $\mathbf { p }_{ k }^{ i }$ is the proof sequence that Alice$_{ i }$ has send to Bob$_{ k }^{ i }$

* $c_{ k^{ \prime } }^{ i }$ is the verification outcome that Bob$_{ k^{ \prime } }^{ i }$ claims he received from Alice$_{ i }$

* $\mathbf { p }_{ k^{ \prime } }^{ i }$ is the proof sequence that Bob$_{ k^{ \prime } }^{ i }$ claims he received from Alice$_{ i }$

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = WordVeryLightTeal!50,
enhanced jigsaw,

sharp corners,

toprule = 0.01 pt,
bottomrule = 0.01 pt,
leftrule = 0.1 pt,
rightrule = 0.1 pt,
sharp corners,
center title,
fonttitle = ]

QNVA$( k )$

* Initialize $\triangleright$ $M_{ A } = M_{ V } = \emptyset$

* Receive $\triangleright$ Bob$_{ k }^{ i }$ receives Alice$_{ i }$'s verification outcome $c_{ k }^{ i }$ and proof $\mathbf { p }_{ k }^{ i }$.

* Test $\triangleright$ Bob$_{ k }^{ i }$ calls the verification test IsAlice'sProofConsistent (Figure <ref>) to check whether $\mathbf { p }_{ k }^{ i }$ is consistent with $c_{ k }^{ i }$.

$\star$	If the test returns TRUE, then Bob$_{ k }^{ i }$ accepts Alice$_{ i }$'s assessment.

$\star$	If the test returns FALSE, then Bob$_{ k }^{ i }$ rejects the news in question as fake, adds Alice$_{ i }$ to his $M_{ V }$ list, and terminates the algorithm.

* Send $\triangleright$ Upon the successful completion of the previous verification check, Bob$_{ k }^{ i }$ sends every other Bob$_{ k^{ \prime } }^{ i }$ ($1 \leq k^{ \prime } \neq k \leq n_{ i }$) not contained in his $M_{ A }$ list, the verification outcome $c_{ k }^{ i }$ and the accompanying proof $\mathbf { p }_{ k }^{ i }$ received from Alice$_{ i }$.

* Receive $\triangleright$ Bob$_{ k }^{ i }$ receives from every other Bob$_{ k^{ \prime } }^{ i }$ ($1 \leq k^{ \prime } \neq k \leq n_{ i }$) not contained in his $M_{ A }$ list, the verification outcome $c_{ k^{ \prime } }^{ i }$ and proof $\mathbf { p }_{ k^{ \prime } }^{ i }$ Bob$_{ k^{ \prime } }^{ i }$ claims he received from Alice$_{ i }$.

* Compare $\triangleright$ Bob$_{ k }^{ i }$ compares his $c_{ k }^{ i }$ to all other $c_{ k^{ \prime } }^{ i }$.

$\star$	If all $c_{ k^{ \prime } }^{ i }$ coincide with $c_{ k }^{ i }$, then Bob$_{ k }^{ i }$ sticks to his preliminary decision, and terminates the algorithm.

$\star$	If there is at least one $c_{ k^{ \prime } }^{ i }$ such that $c_{ k^{ \prime } }^{ i } = \overline { c_{ k }^{ i } }$, Bob$_{ k }^{ i }$ calls the verification test IsBob'sProofConsistent (Figure <ref>) to check whether $\mathbf { p }_{ k^{ \prime } }^{ i }$ is consistent with $\overline { c_{ k }^{ i } }$.

$\square$	If the test returns FALSE, then Bob$_{ k }^{ i }$ adds Bob$_{ k^{ \prime } }^{ i }$ to his $M_{ A }$ list, and repeats the same procedure for the next opposite verification outcome, if any.

$\square$	If the test returns TRUE, then Bob$_{ k }^{ i }$ rejects the news in question as fake, adds Alice$_{ i }$ to his $M_{ V }$ list, and terminates the algorithm.

In real life, the existence of opposite conflicting verification outcomes increases the odds of confusion and unchecked spread of misinformation. The quantum news verification algorithm, by taking advantage of the phenomenon of entanglement and its unique ramifications, can eliminate the risks in certain critical situations, as those outline in the preceding scenarios (S$_{ 1 }$) – (S$_{ 3 }$).

§ DISCUSSION AND CONCLUSIONS

In the era of social media, the proliferation of fake news has emerged as a pressing issue. Particularly in economically developed countries, users tend to encounter more false information than accurate content. The impact of fake news on major social media platforms extends beyond the digital realm, influencing people’s opinions and actions in the real world. Researchers have been driven to seek practical solutions to address this undesirable situation.

This research paper introduces a fresh perspective on the critical topic of news verification. Departing from the conventional Quantum Machine Learning approach, our approach explores an alternative quantum avenue. Drawing inspiration from successful quantum protocols that achieve distributed and detectable Byzantine Agreement in massively distributed environments, we propose the entanglement-based quantum algorithm QNVA.

The QNVA offers several advantages:

* Generality: It can handle any number of news aggregators and verifiers.

* Efficiency: The algorithm completes in a constant number of steps, regardless of the participant count.

* Simplicity: It relies solely on EPR (specifically $\ket{ \Phi^{ + } }$) pairs. EPR pairs are the easiest maximally entangled states to produce, unlike more complex states such as $\ket{ GHZ_{ n } }$, which do not scale well as the number of players increases.

The aforementioned attributes underscore its scalability and practical applicability. To reinforce this assertion, we examine in Table <ref> how the chosen value of the accuracy degree $d$ influences the likelihood of a malicious aggregator successfully fabricating a consistent proof sequence. Notably, the accuracy degree $d$ remains independent of the number of participants, further enhancing the algorithm's scalability. Naturally, selecting an appropriate value for $d$ is crucial to ensure the negligible probability of a malicious actor successfully forging a consistent proof sequence. The rationale behind $d$ not scaling with the number of aggregators and verifiers lies in the protocol's consistent utilization of EPR pairs, signifying bipartite entanglement. As per protocol guidelines, each consistency check involves a comparison between two bit vectors. Consequently, irrespective of the participant count, each comparison entails only two bit strings. Furthermore, even in the most general scenario, this comparison involves just two bits, denoted as $i$ and $j$, in each tuple. Thus, probabilistically, the situation remains consistent. In essence, the probability of a malicious aggregator deceiving an honest aggregator hinges on the likelihood of selecting the correct configuration from many possibilities. The total number of configurations equals the ways to distribute approximately $\frac{d}{4}$ identical objects (either $0$ or $1$) into approximately $\frac{d}{2}$ distinguishable boxes (representing the uncertain tuples). The probability of a cheater correctly placing all the approximately $\frac{d}{4}$ bits within the approximately $\frac{d}{2}$ cryptic tuples is

\begin{align}
P( \text{ malicious aggregator cheats } )
\approx
\frac { 1 }
{ \binom { \ d / 2 \ } { \ d / 4 \ } }
\ , \label{eq: Malicious Aggregator Cheats}
\end{align}

which tends to zero as $d$ increases.

grow to left by = 0.00 cm,
grow to right by = 0.00 cm,
colback = WordVeryLightTeal!25,
enhanced jigsaw,

sharp corners,
boxrule = 0.1 pt,
toprule = 0.1 pt,
bottomrule = 0.1 pt

This table shows how the chosen value of the degree of accuracy $d$ affects the probability that a malicious aggregator succeeds in forging a consistent proof sequence.

[HTML]000000   How the degree of accuracy $d$ affects the probability $P$

[HTML]000000   $d$

$d / 2 $

$d / 4 $

$P( \text{ malicious aggregator cheats } )$

[HTML]000000   $4$

4 // 2

4 // 4

Combinations ( m ) := ( m / 2 )! // ( ( m / 4 )! ( m / 4 )! );
Probability ( m ) := 1 / Combinations ( m );
Probability ( 4 )

[HTML]000000   $8$

8 // 2

8 // 4

Combinations ( m ) := ( m / 2 )! // ( ( m / 4 )! ( m / 4 )! );
Probability ( m ) := 1 / Combinations ( m );
Probability ( 8 )

[HTML]000000   $16$

16 // 2

16 // 4

Combinations ( m ) := ( m / 2 )! // ( ( m / 4 )! ( m / 4 )! );
Probability ( m ) := 1 / Combinations ( m );
Probability ( 16 )

[HTML]000000   $32$

32 // 2

32 // 3

Combinations ( m ) := ( m / 2 )! // ( ( m / 4 )! ( m / 4 )! );
Probability ( m ) := 1 / Combinations ( m );
Probability ( 32 )

[HTML]000000   $64$

64 // 3

64 // 4

Combinations ( m ) := ( m / 2 )! // ( ( m / 4 )! ( m / 4 )! );
Probability ( m ) := 1 / Combinations ( m );
Probability ( 64 )

[1]
A. Campan, A. Cuzzocrea, and T. M. Truta, “Fighting fake news spread in online
social networks: Actual trends and future research directions,” in 2017
IEEE International Conference on Big Data (Big Data), IEEE, 2017.

[2]
W. Vorhies, “Using Algorithms to Detect Fake News – The State
of the Art - DataScienceCentral.com — datasciencecentral.com.”
Accessed 14-01-2024.

[3]
K. Shu, A. Sliva, S. Wang, J. Tang, and H. Liu, “Fake news detection on social
media: A data mining perspective,” ACM SIGKDD Explorations Newsletter,
vol. 19, no. 1, pp. 22–36, 2017.

[4]
H. Rashkin, E. Choi, J. Y. Jang, S. Volkova, and Y. Choi, “Truth of varying
shades: Analyzing language in fake news and political fact-checking,” in
Proceedings of the 2017 Conference on Empirical Methods in Natural
Language Processing, Association for Computational Linguistics, 2017.

[5]
E. Mustafaraj and P. T. Metaxas, “The fake news spreading plague: Was it
preventable?,” 2017.

[6]
S. Gilda, “Notice of violation of ieee publication principles: Evaluating
machine learning algorithms for fake news detection,” in 2017 IEEE 15th
Student Conference on Research and Development (SCOReD), IEEE, 2017.

[7]
M. Farajtabar, J. Yang, X. Ye, H. Xu, R. Trivedi, E. Khalil, S. Li, L. Song,
and H. Zha, “Fake news mitigation via point process based intervention,” in
Proceedings of the 34th International Conference on Machine Learning
(D. Precup and Y. W. Teh, eds.), vol. 70 of Proceedings of Machine
Learning Research, pp. 1097–1106, PMLR, 06–11 Aug 2017.

[8]
G. E. R. Agudelo, O. J. S. Parra, and J. B. Velandia, Raising a Model for
Fake News Detection Using Machine Learning in Python, pp. 596–604.
Springer International Publishing, 2018.

[9]
A. Kesarwani, S. S. Chauhan, A. R. Nair, and G. Verma, Supervised Machine
Learning Algorithms for Fake News Detection, pp. 767–778.
Springer Nature Singapore, 2020.

[10]
A. Kesarwani, S. S. Chauhan, and A. R. Nair, “Fake news detection on social
media using k-nearest neighbor classifier,” in 2020 International
Conference on Advances in Computing and Communication Engineering (ICACCE),
IEEE, 2020.

[11]
S. Vijayaraghavan, Y. Wang, Z. Guo, J. Voong, W. Xu, A. Nasseri, J. Cai, L. Li,
K. Vuong, and E. Wadhwa, “Fake news detection with different models.”

[12]
K. Nagashri and J. Sangeetha, Fake News Detection Using Passive-Aggressive
Classifier and Other Machine Learning Algorithms, pp. 221–233.
Springer Singapore, 2021.

[13]
S. Pandey, S. Prabhakaran, N. V. Subba Reddy, and D. Acharya, “Fake news
detection from online media using machine learning classifiers,” Journal of Physics: Conference Series, vol. 2161, no. 1, p. 012027, 2022.

[14]
W. J. Tee and R. K. Murugesan, “Trust network, blockchain and evolution in
social media to build trust and prevent fake news,” in 2018 Fourth
International Conference on Advances in Computing, Communication &
Automation (ICACCA), IEEE, 2018.

[15]
J. Chow, O. Dial, and J. Gambetta, “IBM Quantum breaks the 100-qubit
processor barrier.”
<https://research.ibm.com/blog/127-qubit-quantum-processor-eagle>, 2021.
Accessed: 2022-04-03.

[16]
I. Newsroom, “IBM unveils 400 qubit-plus quantum processor.”
Accessed: 2022-04-03.

[17]
J. Gambetta, “The hardware and software for the era of quantum utility is
here.” <https://www.ibm.com/quantum/blog/quantum-roadmap-2033>, 2023.
Accessed: 2023-12-06.

[18]
S. Kamal, V. Chahar, and S. Sharma, “Quantum machine learning-based detection
of fake news and deep fake videos,” IEEE Technology Policy and Ethics,
07 2022.

[19]
EPFL and Quantum Integrity, “Quantum Integrity and EPFL develop
Deep Fake Detector.”
Accessed 14-01-2024.

[20]
Z. Tian and S. Baskiyar, “Fake news detection: An application of quantum
k-nearest neighbors,” in 2021 IEEE Symposium Series on Computational
Intelligence (SSCI), IEEE, 2021.

[21]
Google, “Announcing TensorFlow Quantum: An Open Source Library
for Quantum Machine Learning — blog.research.google.”
Accessed 14-01-2024.

[22]
T. Andronikos and A. Sirokofskich, “A quantum detectable byzantine agreement
protocol using only EPR pairs,” Applied Sciences, vol. 13, no. 14,
p. 8405, 2023.

[23]
D. A. Meyer, “Quantum strategies,” Physical Review Letters, vol. 82,
no. 5, p. 1052, 1999.

[24]
J. Eisert, M. Wilkens, and M. Lewenstein, “Quantum games and quantum
strategies,” Physical Review Letters, vol. 83, no. 15, p. 3077, 1999.

[25]
T. Andronikos, A. Sirokofskich, K. Kastampolidou, M. Varvouzou, K. Giannakis,
and A. Singh, “Finite automata capturing winning sequences for all possible
variants of the PQ penny flip game,” Mathematics, vol. 6, p. 20, Feb

[26]
T. Andronikos and A. Sirokofskich, “The connection between the PQ penny flip
game and the dihedral groups,” Mathematics, vol. 9, no. 10, p. 1115,

[27]
T. Andronikos, “Conditions that enable a player to surely win in sequential
quantum games,” Quantum Information Processing, vol. 21, no. 7, 2022.

[28]
K. Kastampolidou and T. Andronikos, “Quantum tapsilou—a quantum game
inspired by the traditional greek coin tossing game tapsilou,” Games,
vol. 14, no. 6, p. 72, 2023.

[29]
K. Giannakis, G. Theocharopoulou, C. Papalitsas, S. Fanarioti, and
T. Andronikos, “Quantum conditional strategies and automata for prisoners'
dilemmata under the EWL scheme,” Applied Sciences, vol. 9, p. 2635,
Jun 2019.

[30]
T. Andronikos and M. Stefanidakis, “A two-party quantum parliament,” Algorithms, vol. 15, no. 2, p. 62, 2022.

[31]
M. Ampatzis and T. Andronikos, “QKD based on symmetric entangled
bernstein-vazirani,” Entropy, vol. 23, no. 7, p. 870, 2021.

[32]
M. Ampatzis and T. Andronikos, “A symmetric extensible protocol for quantum
secret sharing,” Symmetry, vol. 14, no. 8, p. 1692, 2022.

[33]
M. Ampatzis and T. Andronikos, “Quantum secret aggregation utilizing a network
of agents,” Cryptography, vol. 7, no. 1, p. 5, 2023.

[34]
T. Andronikos and A. Sirokofskich, “An entanglement-based protocol for
simultaneous reciprocal information exchange between 2 players,” Electronics, vol. 12, no. 11, p. 2506, 2023.

[35]
T. Andronikos and A. Sirokofskich, “One-to-many simultaneous secure quantum
information transmission,” Cryptography, vol. 7, no. 4, p. 64, 2023.

[36]
G. Theocharopoulou, K. Giannakis, C. Papalitsas, S. Fanarioti, and
T. Andronikos, “Elements of game theory in a bio-inspired model of
computation,” in 2019 10th International Conference on Information,
Intelligence, Systems and Applications (IISA), pp. 1–4, IEEE, jul 2019.

[37]
K. Kastampolidou, M. N. Nikiforos, and T. Andronikos, “A brief survey of the
prisoners' dilemma game and its potential use in biology,” in Advances
in Experimental Medicine and Biology, pp. 315–322, Springer International
Publishing, 2020.

[38]
D. Kostadimas, K. Kastampolidou, and T. Andronikos, “Correlation of biological
and computer viruses through evolutionary game theory,” in 2021 16th
International Workshop on Semantic and Social Media Adaptation &
Personalization (SMAP), IEEE, 2021.

[39]
K. Kastampolidou and T. Andronikos, “A survey of evolutionary games in
biology,” in Advances in Experimental Medicine and Biology,
pp. 253–261, Springer International Publishing, 2020.

[40]
K. Kastampolidou and T. Andronikos, “Microbes and the games they play,” in
GeNeDis 2020, pp. 265–271, Springer International Publishing, 2021.

[41]
K. Kastampolidou and T. Andronikos, “Game theory and other unconventional
approaches to biological systems,” in Handbook of Computational
Neurodegeneration, pp. 163–180, Springer International Publishing, 2023.

[42]
C. Papalitsas, K. Kastampolidou, and T. Andronikos, “Nature and
quantum-inspired procedures – a short literature review,” in
GeNeDis 2020, pp. 129–133, Springer International Publishing, 2021.

[43]
S. Adam, P. Karastathis, D. Kostadimas, K. Kastampolidou, and T. Andronikos,
“Protein misfolding and neurodegenerative diseases: A game theory
perspective,” in Handbook of Computational Neurodegeneration,
pp. 863–874, Springer International Publishing, 2023.

[44]
M. A. Nielsen and I. L. Chuang, Quantum computation and quantum
Cambridge University Press, 2010.

[45]
R. Neigovzen, C. Rodó, G. Adesso, and A. Sanpera, “Multipartite
continuous-variable solution for the byzantine agreement problem,” Physical Review A, vol. 77, no. 6, p. 062307, 2008.

[46]
Y. Feng, R. Shi, J. Zhou, Q. Liao, and Y. Guo, “Quantum byzantine agreement
with tripartite entangled states,” International Journal of Theoretical
Physics, vol. 58, no. 5, pp. 1482–1498, 2019.

[47]
W. Wang, Y. Yu, and L. Du, “Quantum blockchain based on asymmetric quantum
encryption and a stake vote consensus algorithm,” Scientific Reports,
vol. 12, no. 1, 2022.

[48]
Z. Yang, T. Salman, R. Jain, and R. D. Pietro, “Decentralization using quantum
blockchain: A theoretical analysis,” IEEE Transactions on Quantum
Engineering, vol. 3, pp. 1–16, 2022.

[49]
Z. Qu, Z. Zhang, B. Liu, P. Tiwari, X. Ning, and K. Muhammad, “Quantum
detectable byzantine agreement for distributed data trust management in
blockchain,” Information Sciences, vol. 637, p. 118909, 2023.

[50]
K. Ikeda and A. Lowe, “Quantum protocol for decision making and verifying
truthfulness among n‐quantum parties: Solution and extension of the quantum
coin flipping game,” IET Quantum Communication, vol. 4, no. 4,
pp. 218–227, 2023.