Quantum Game Theory-Based Cloud Resource Allocation: A Novel Approach

Abstract

This paper explores the application of quantum game theory to optimize cloud resource allocation. By leveraging the principles of quantum mechanics, the proposed framework aims to enhance efficiency, reduce costs, and improve scalability in cloud computing environments. The study introduces a quantum-based game-theoretic model and compares its performance with classical approaches. The results demonstrate significant improvements in resource utilization and decision-making efficiency. While prior works have explored classical game theory and auction-based methods, this study is among the first to implement quantum game theory in a practical cloud computing context, propose a resource allocation mechanism that incorporates both fairness and efficiency while leveraging the computational advantages of quantum systems, and highlight the strategic benefits of quantum entanglement in fostering collaboration between competing entities in cloud environments. This work not only addresses the current limitations of resource allocation but also redefines the possibilities for optimization in complex systems, making a substantial contribution to both quantum computing and cloud resource management domains.

1. Introduction

1.1. Background on Cloud Resource Allocation

In the era of rapid technological advancements, cloud computing has emerged as a cornerstone of modern IT infrastructure [1]. It offers scalable, on-demand access to computing resources, enabling businesses to operate with flexibility and efficiency. Cloud service providers (CSPs) manage vast pools of computational resources, which are dynamically allocated to meet the varying demands of users. Efficient resource allocation is crucial to ensuring optimal performance, cost-effectiveness, and user satisfaction in cloud environments [2,3].

Traditionally, resource allocation in the cloud has been addressed using various approaches, including heuristic-based methods, auction models, and machine learning algorithms. These methods aim to allocate resources such as processing power, memory, and storage to users in a way that maximizes resource utilization while minimizing costs. However, as cloud computing environments grow in complexity and scale, traditional resource allocation methods face significant challenges [4]. These include handling large-scale data, managing multi-tenancy, dealing with the variability of demand, and ensuring fairness and efficiency. In  [5,6], the authors conducted an experimental analysis using quantum key distribution (QKD) [6] to enhance the security of mobile ad hoc networks (MANETs), demonstrating significant improvements in securing dynamic, decentralized networks.

1.2. Challenges in Classical Resource Allocation

One of the key challenges in classical resource allocation lies in the inherent trade-offs between conflicting objectives. For instance, optimizing resource allocation for cost efficiency may compromise performance, while prioritizing performance could lead to underutilization of resources. Moreover, the dynamic and unpredictable nature of cloud workloads makes it difficult to maintain an optimal balance. The complexity of managing these trade-offs is exacerbated by the increasing heterogeneity of cloud environments, where diverse applications with varying requirements compete for shared resources.

Game theory, a mathematical framework for modeling strategic interactions among rational agents, has been used to address some of these challenges. In cloud computing, game theory models can be used to predict and optimize the behavior of different stakeholders, such as cloud providers and users, in resource allocation scenarios. By treating resource allocation as a game, in which each participant aims to maximize their utility, game theory provides a structured approach to finding equilibrium solutions that balance competing interests. However, classical game theory has limitations when applied to large-scale, complex systems such as cloud computing. Ref. [7] explored the integration of large language models in quantum architecture design, demonstrating how these models can optimize the development of quantum algorithms through advanced computational strategies.

1.3. Introduction to Quantum Game Theory

Quantum computing, an emerging paradigm that utilizes the principles of quantum mechanics, promises to revolutionize the field of computation. Unlike classical computers, which process information using bits that represent either 0 or 1, quantum computers use quantum bits, or qubits, which can represent and process a combination of states simultaneously due to superposition. This allows quantum computers to perform certain types of calculations exponentially faster than their classical counterparts [8].

Quantum game theory is a novel extension of classical game theory that incorporates the principles of quantum mechanics. In quantum game theory, players can make use of quantum strategies, which involve entangled states and superposition, to achieve outcomes that are impossible or inefficient in classical settings. This adds a new dimension to strategic interactions, enabling more efficient exploration of the solution space and potentially leading to better equilibria [9,10].

In the context of cloud resource allocation, quantum game theory offers a promising approach to overcoming the limitations of classical methods [11]. Using quantum strategies, it is possible to optimize resource allocation in a way that balances conflicting objectives more effectively and adapts to the dynamic nature of cloud environments.

1.4. Motivation

The motivation for this study comes from the need to address the growing challenges of resource allocation in cloud computing. As cloud environments become more complex, there is a pressing need for innovative solutions that can manage resources more efficiently and equitably. Traditional resource allocation methods often struggle with scalability, fairness, and adaptability in dynamic environments. Quantum game theory, with its potential to improve decision-making processes and optimize complex systems, represents a promising avenue for research [6]. By leveraging quantum strategies, it becomes feasible to navigate the intricate trade-offs between performance, cost-efficiency, and fairness, making it an ideal tool for modern cloud computing challenges.

1.5. Addressing Current Research Gaps

Addressing Gaps in Current Research:

• Scalability: While classical models often struggle with scalability issues, this work lays the groundwork for quantum-based scalable solutions.
• Novel Application of Quantum Auctions: Building on quantum auction theory, this paper proposes innovative mechanisms for faster, fairer resource allocation.
• Dynamic Strategy Evolution: The iterative adjustment of quantum strategies introduces a level of adaptability previously unexplored in cloud computing.
• Interdisciplinary Innovation: By merging quantum computing and cloud resource management, the study opens up a new interdisciplinary research avenue, setting a precedent for future work in utilizing emerging quantum paradigms to solve complex resource allocation problems.

1.6. Key Contributions

This paper makes several significant contributions:

• Development of a Quantum Game Theory-based Cloud Resource Allocation (QGT-CRA): Presents an innovative model that utilizes quantum strategies (e.g., superposition, entanglement) to efficiently allocate cloud resources. Specifically tailored to solve scalability, fairness, and efficiency challenges in intricate, dynamic cloud scenarios.
• Performance Advantages Over Classical Approaches: Exhibits rapid convergence to equilibrium (12 iterations vs. 25+ in classical models). Registers improved resource utilization (93.7%) and cost savings (27.5%). Outperforms cooperative and auction-based models in fairness (Jain’s Index 0.94).
• Quantum-Integrated Nash Equilibrium (QiNE): Introduces a quantum-enhanced Nash equilibrium with time-evolving strategies within an entangled environment. Enables improved decision-making by considering multiple strategy outcomes concurrently.
• Dynamic Strategy Evolution: Facilitates adaptive action through repeated updates of quantum strategies to enhance responsiveness to evolving cloud environments.
• Quantum Auction Integration: Expands quantum auction concepts to enhance fairness and efficiency in allocation processes without a central auctioneer.
• Practical Quantum Implementation Using Qiskit (Software Version: 0.39.0): Exceeds theory by executing the model on actual quantum circuits and unitary strategy operations, presenting practical real-world applicability.
• Entanglement-Driven Collaboration: Utilizes quantum entanglement to enable implicit coordination among cloud service providers and users, minimizing wastage of resources and enhancing overall system fairness.
• Benchmarking Against New Algorithms: In comparison with next-generation models such as deep Q-network (DQN), particle swarm optimization (PSO), and genetic algorithm (GA), QGT-CRA outperforms consistently across service level agreement (SLA) compliance, energy efficiency, and user satisfaction.
• Scalable and Hybrid-Friendly Design: Suggests a modular deployment model that is compatible with existing cloud platforms (e.g., Kubernetes, OpenFaaS), available for phased adoption as quantum hardware evolves.

1.7. Structure of the Paper

This paper is organized to provide a clear and comprehensive understanding of quantum game theory applied to cloud resource allocation. The Introduction outlines the challenges in traditional cloud resource allocation and introduces the motivation behind leveraging quantum game theory for optimization. The Literature Review surveys existing methods, including classical and quantum approaches, and highlights research gaps that this study addresses.

In the Proposed Architecture section, we present a quantum game-theoretic framework tailored for efficient and fair cloud resource allocation, along with its theoretical underpinnings. The System Model explains the mathematical formulation and the dynamics of quantum strategies used by cloud service providers and users.

The Time Complexity, Theorems, and Proofs section provides preliminary details regarding the theoretical framework and usability of the developed algorithm. The Qiskit-based Implementation section then provides details on the implementation of the algorithm in real life using Qiskit, including quantum circuit creation and measurement methods. The Results and Performance Analysis section provides a comparison of the performance of the developed framework with conventional methods with its advantages and computational efficiency. Furthermore, the Deployment Strategy and Implementation Feasibility addresses the deployability of the framework and its current constraints and potential lines of future research. Lastly, the Conclusion overviews the key contributions of the study, states its limitations, and lays out promising areas of future work, highlighting the cross-disciplinary use case and disruptive capability of the proposed methodology.

This structure ensures a logical flow from theoretical foundations to practical implications, offering valuable insights into the integration of quantum computing in cloud environments.

1.8. Novelty of the Paper

The novelty lies in the following aspects:

• Integration of Quantum Strategies: Unlike traditional methods that rely on classical game theory or heuristic-based optimization, this work incorporates principles of quantum mechanics, such as superposition and entanglement. This allows for the simultaneous exploration of multiple allocation scenarios, achieving outcomes unattainable through classical models.
• Quantum-Integrated Nash Equilibria: The introduction of quantum-integrated Nash Equilibria in resource allocation provides a new framework for balancing competing objectives like cost efficiency, resource utilization, and fairness. This approach surpasses classical equilibrium models by exploring a broader solution space enabled by quantum strategies.
• Enhanced Resource Optimization: The proposed framework demonstrates significant improvements in efficiency, scalability, and decision-making compared to classical methods. This is achieved through the adoption of dynamic quantum entanglement to facilitate collaboration between CSPs and users.
• Practical Implementation Framework: Leveraging IBM Qiskit, the study moves beyond theoretical modeling to simulate quantum strategies in a real-world programming environment. This positions the work as a practical blueprint for future quantum computing applications in cloud systems.

2. Literature Review

Cloud computing has emerged as a pivotal technology in modern IT infrastructure, providing on-demand services to users. The resource allocation problem within cloud computing refers to the efficient and fair distribution of computational, storage, and network resources among users and service providers. Ref. [12] introduced a practical quantum sealed-bid auction scheme that removes the dependency on an auctioneer, enhancing the feasibility and security of quantum-based auction protocols in resource allocation scenarios. The dynamic nature of cloud environments, characterized by fluctuating workloads, heterogeneous resources, and varying user demands, makes this problem particularly challenging. In the context of auction-based resource allocation, ref. [13] proposed a quantum sealed-bid auction mechanism that eliminates the need for a trusted third party, leveraging quantum mechanics to enhance security and fairness in strategic interactions. In recent advancements, ref. [14] demonstrated significant improvements in quantum error decoding accuracy, highlighting the potential for enhanced fault tolerance in quantum processors.

Traditional resource allocation methods leverage optimization techniques, auction mechanisms, or game-theoretic models to achieve equitable distribution. However, these approaches face computational bottlenecks as the scale and complexity of cloud systems increase. The advent of quantum computing introduces novel paradigms, particularly quantum game theory, which holds promise for addressing these challenges more efficiently.

2.1. Game Theory in Cloud Resource Allocation

Game theory has been extensively used in cloud resource allocation to model the interaction between CSPs and users. Key game-theoretic approaches include the following:

1. Non-Cooperative Games: Users compete for resources, optimizing their strategies without collaborating. Examples include pricing strategies and load balancing models [15,16].

2. Cooperative Games: Users and CSPs collaborate to achieve mutual benefits, often resulting in higher efficiency and fairness [17,18].

3. Evolutionary Games: Dynamic strategies evolve over time, adapting to changes in user behavior and resource availability [19].

While effective in many scenarios, classical game-theoretic models often require significant computational resources, especially when modeling large-scale systems or incorporating real-time data.

2.2. Quantum Computing in Optimization Problems

Quantum computing leverages the principles of superposition, entanglement, and quantum interference to solve complex problems exponentially faster than classical methods. In optimization problems, quantum algorithms like Grover’s search [20] and the quantum approximate optimization algorithm (QAOA) have demonstrated significant potential [21,22].

Quantum game theory extends classical game theory into the quantum domain by representing strategies and payoffs using quantum states. This approach enables the exploration of novel equilibria and resource allocation strategies that are infeasible in classical settings.

2.3. Related Work on Quantum Game Theory

The application of quantum game theory (QGT) to cloud computing and resource allocation is a new confluence of quantum information science and strategic optimization. QGT builds upon classical game theory by adding quantum physics concepts—like superposition, entanglement, and unitary transformation—to represent strategic interactions between agents in complex, multi-agent systems. Although there is foundational literature on quantum game theory itself, its extension to dynamic cloud systems is largely underdeveloped.

One of the most basic ideas in QGT is the idea of quantum Nash equilibria. Eisert et al. [11] and Meyer et al. [23] were the first to demonstrate that quantum analogs of classical games, such as the Prisoner’s Dilemma, can yield results where players receive higher payoffs than in classical equilibrium situations. Based on this, Lowe et al. [24] generalized the Nash equilibrium framework to quantum settings based on Hilbert spaces for representing mixed and entangled strategies. Based on their results, they showed that quantum strategies not only expand the space of strategies but also allow convergence to socially more optimal equilibria. Yet, many of these are still in theoretical settings, without being applied to real-time scheduling or distributed cloud systems—a matter directly addressed by our QGT-CRA framework.

Quantum auction mechanisms have also been of interest for secure and efficient resource allocation in competitive settings. Han et al. [25] presented a quantum-sealed-bid auction protocol, leveraging quantum measurement properties to ward off bid tampering and protect privacy. Subsequent work by Li et al. [26] introduced an entanglement swapping-based quantum Vickrey auction protocol for resource sharing between decentralized nodes. Shi et al. [12] also introduced a quantum combinatorial auction for decentralized networks with emphasis on the advantages of quantum encoding for multi-item bidding. Although these are worthwhile contributions, they are primarily centered on security and auction fairness as opposed to systemic optimization or strategic adaptation—deficits our entanglement-based, Nash equilibrium-based QGT-CRA framework fills.

A second essential area is the application of quantum entanglement to facilitate implicit collaboration. Di Salvo et al. [21] and Blekos et al. [22] examined the use of entangled states in cooperative games and distributed systems. Their research proved that entangled quantum strategies shared by players can lead to globally optimal results without direct communication. Likewise, Piotrowski and Sładkowski [27] illustrated the potential of entanglement in enhancing efficiency and stability in models of financial decision-making. Iqbal et al. [28] investigated quantum Stackelberg duopoly games, where entanglement provided first-mover advantage mitigation and greater social utility. Our own work capitalizes on these principles by representing user and CSP strategies as entangled unitaries, enabling resource decisions based on global fairness instead of self-interest optima.

On the implementation front, more recent works have started investigating the possibility of applying quantum game strategies in the cloud. Mohammed et al. [20] introduced a quantum-secure model for cloud resource allocation, employing game-theoretic reasoning to enhance edge–cloud trust and cybersecurity. Hazarika et al. [29] showed quantum decision models in federated cloud environments, but without incorporating equilibrium computation or auction-based scheduling of resources. Our contribution improves upon this with the inclusion of quantum equilibrium search and entangled cooperation into a deployable Qiskit-based algorithm with simulation-supported performance benchmarking.

Though these are important contributions, none of the current models integrate all the aspects of quantum strategies, Nash equilibrium calculation, quantum auction reasoning, and dynamic entanglement in a scheduling and resource allocation setting for practical use. Our QGT-CRA model bridges this by merging all these aspects into one unified, actionable architecture and testing its performance via comparative analysis against both current and classical methods.

2.4. Proposed Approach

This paper proposes a quantum game-theoretic framework for cloud resource allocation that leverages dynamic entanglement and quantum algorithms for real-time strategy optimization (QGT-CRA). Ref. [30] demonstrated the potential of quantum computers in solving complex optimization problems such as routing, providing a foundation for applying quantum techniques to challenges like resource allocation in cloud environments. The framework aims to balance efficiency, fairness, and scalability, offering a practical solution for next-generation cloud systems.

This review highlights the current studies and transformative potential of quantum computing in cloud resource allocation, emphasizing the need for interdisciplinary research to realize its full capabilities.

3. System Model

We offer the mathematical formulation of the cloud resource allocation model based on quantum game theory. Distributed quantum computing frameworks provide the foundation for handling resource allocation across cloud systems, emphasizing modularity and scalability in quantum compiler design, as detailed by [31]. After describing the participants, resources, and strategies in the quantum game, we go on to discuss the theoretical underpinning of the quantum game and how it is utilized to allocate resources optimally. Ref. [32] provided an effective methodology for mapping nearest neighbor-based quantum circuits into 2D, which can enhance the spatial efficiency and performance of quantum computation frameworks.

3.1. Players and Resources

Consider a cloud computing environment consisting of the following:

• A set of CSPs denoted by

  $$P=\{P_1,P_2,\dots ,P_m\}$$

  (1)

  where each CSP $P_i$ offers a finite set of resources $R_i$, such that

  $$R_i=\{R_{i1},R_{i2},\dots ,R_{i{k}_i}\}$$

  (2)

  where $R_{ij}$ represents the j-th resource provided by $P_i$.
• A set of users or applications denoted by

  $$U=\{U_1,U_2,\dots ,U_n\}$$

  (3)

  where each user $U_j$ has specific resource requirements represented by a demand vector

  $$d_j=(d_{j1},d_{j2},\dots ,d_{j{k}_j})$$

  (4)

  where $d_{jl}$ denotes the amount of the l-th resource required by $U_j$. The goal is to allocate the available resources $R_i$ among the users U to maximize the overall utility, minimize costs, and ensure fairness.

3.2. Objectives

The goal is to allocate the available resources $R_i$ among the users U to:

(i)

Maximize overall utility:

$$max\sum _j{U}_j\left(d_j\right)$$

(5)

where $U_j\left(d_j\right)$ is the utility function for user $U_j$.

(ii)

Minimize costs:

$$min\sum _i\sum _j{C}_{ij}$$

(6)

where $C_{ij}$ is the cost of allocating resources from $P_i$ to $U_j$.

(iii)

Ensure fairness: This can involve proportional fairness or max–min fairness.

3.3. Constraints

The allocation is subject to the following constraints:

• Resource constraints: Each CSP has a finite amount of resources:

  $$\sum _{j=1}^n{x}_{ji}\le R_i,\forall i\in \{1,\dots ,m\}$$

  (7)

  where $x_{ji}$ is the allocation of resource $R_i$ to user $U_i$.

3.4. Quantum Game Theory Approach

To model the interaction between CSPs and users as a game, we adopt a quantum game theory approach. Unlike classical game theory, where strategies are deterministic, quantum game theory allows for quantum superposition of strategies, which can lead to more optimal outcomes [33,34].

3.4.1. Quantum States and Strategies

In a quantum game, the strategy space is expanded by allowing players to choose quantum states as strategies. Let $H_P$ and $H_U$ denote the Hilbert spaces associated with the CSPs and users, respectively. The quantum state of the game can be described as a vector

$$|\psi \rangle \in H_P\otimes H_U$$

(8)

where ⊗ represents the tensor product of the individual Hilbert spaces.

Each player’s strategy is represented by a quantum operation (unitary transformation) $U_P$ for CSPs and $U_U$ for users, acting on their respective Hilbert spaces. The overall state of the system after the application of these strategies can be written as:

$$|{\psi }^{\prime }\rangle =(U_P\otimes U_U)|\psi \rangle$$

(9)

where $U_P$ and $U_U$ are unitary operators corresponding to the strategies chosen by the CSPs and users, respectively.

3.4.2. Payoff Function

The payoff function in a quantum game determines the utility that each player receives based on the strategies employed by all players. For each user $U_j$, the utility function $u_j$ is defined as:

$$u_j\left(r_j\right)=\sum _{l=1}^{k_j}{w}_{jl}{f}_{jl}(r_{jl},d_{jl})$$

(10)

where $r_j=(r_{j1},r_{j2},\dots ,r_{j{k}_j})$ is the vector of resources allocated to $U_j$, $w_{jl}$ is the weight representing the importance of resource $R_{jl}$ to user $U_j$, and $f_{jl}$ is a utility function that measures the satisfaction of user $U_j$ with the allocation $r_{jl}$. A typical form of $f_{jl}$ could be:

$$f_{jl}(r_{jl},d_{jl})=1-exp\left(-{\displaystyle \frac{r_{jl}}{d_{jl}}}\right)$$

(11)

This function reflects the principle of diminishing returns, where the utility increases as the allocated resources approach the demand but at a decreasing rate.

For the CSPs, the utility function $u_i$ depends on the revenue generated from resource allocation minus the cost of providing those resources. Let $c_{ij}$ represent the cost of allocating resource $R_{ij}$ to user $U_j$, and $p_{ij}$ denote the price charged by CSP $P_i$ for resource $R_{ij}$. The utility function for CSP $P_i$ is given by:

$$u_i\left(r_i\right)=\sum _{j=1}^n\sum _{l=1}^{k_j}\left(p_{ij}{r}_{jl}-c_{ij}{r}_{jl}\right)$$

(12)

where $r_i=(r_{i1},r_{i2},\dots ,r_{i{k}_i})$ is the vector of resources allocated by CSP $P_i$ to all users.

3.4.3. Nash Equilibrium in Quantum Games

The concept of Nash equilibrium is central to game theory, including quantum game theory. A Nash equilibrium is a state in which no player can improve their payoff by unilaterally changing their strategy. In the context of quantum game theory, the Nash equilibrium can be defined as a quantum state $|{\psi }^{*}\rangle$ such that:

$$\forall U_P,U_U:u_i(U_P,U_U\mid |\psi \rangle )\le u_i(U_P^{*},U_U\mid |{\psi }^{*}\rangle )$$

(13)

and

$$u_j(U_P,U_U\mid |\psi \rangle )\le u_j(U_P,U_U^{*}\mid |{\psi }^{*}\rangle )$$

(14)

For all CSPs $P_i$ and users $U_j$, where $U_P^{*}$ and $U_U^{*}$ represent the equilibrium strategies of the CSPs and users, respectively.

The Nash equilibrium can be computed by solving the following optimization problem:

$$\underset{U_P,U_U}{max}\left[\sum _{i=1}^m{u}_i\left(r_i\right)+\sum _{j=1}^n{u}_j\left(r_j\right)\right]$$

(15)

subject to the constraints:

$$\sum _{j=1}^n{r}_{jl}\le R_{il},\forall l,\forall i$$

(16)

where $R_{il}$ represents the total amount of resource $R_{il}$ available to CSP $P_i$.

Efficiency of QiNE: The QiNE used in the suggested algorithm generalizes the traditional concept of a Nash equilibrium by including time-evolving quantum strategies in an entangled state space. In traditional games, a Nash equilibrium is a stable strategy profile ${\left\{s_i^{*}\right\}}_{i=1}^N$ where no player i can increase their utility by unilaterally deviating:

$$u_i(s_i^{*},s_{-i}^{*})\ge u_i(s_i,s_{-i}^{*})\forall s_i\in S_i$$

(17)

In contrast, a QiNE features a coincidence of player strategies written as local unitary operations to be implemented on a common entangled quantum state:

$$|{\psi }_f\left(t\right)\rangle =J^{†}\left(\underset{i=1}{\overset{N}{⨂}}{U}_i({\theta }_i\left(t\right),{\varphi }_i\left(t\right))\right)J|{\psi }_0\rangle$$

(18)

where J is the entanglement operator, $U_i({\theta }_i,{\varphi }_i)$ are time-evolving unitary strategy operators, and $|{\psi }_0\rangle$ is the initial state.

The dynamic arises from iterative optimization of $({\theta }_i,{\varphi }_i)$ to maximize expected utility over the measurement outcomes of the quantum:

$${\theta }_i^{(t+1)}=arg\underset{\theta }{max}\mathbb{E}[u_i(\theta ,{\varphi }_i^{\left(t\right)}),{\varphi }_i^{(t+1)}=arg\underset{\varphi }{max}\mathbb{E}\left[u_i({\theta }_i^{(t+1)},\varphi )\right]$$

(19)

The results from Section 9’s experiments reveal that QGT-CRA converges in 12 iterations to the classical 25+ while providing a satisfactory boost to total utility. Such advantages arise from quantum parallelism and entanglement of payoffs to globally optimal equilibria out of reach within classical systems.

3.4.4. Quantum Superposition of Strategies

Quantum game theory allows the use of superposition to explore multiple strategies simultaneously. Let $|S\rangle$ represent the superposition of different strategies:

$$|S\rangle =\sum _{k=1}^K{\alpha }_k|S_k\rangle$$

(20)

where $|S_k\rangle$ represents the k-th strategy combination of the CSPs and users, and ${\alpha }_k$ are complex coefficients such that:

$$\sum _{k=1}^K{\left|{\alpha }_k\right|}^2=1$$

(21)

The expected payoff for a player using the superposition of strategies is:

$$\langle u_i\rangle =\sum _{k=1}^K|{\alpha }_k{|}^2{u}_i\left(\right|S_k\rangle )$$

(22)

where $u_i\left(\right|S_k\rangle )$ is the payoff associated with strategy $|S_k\rangle$. Players aim to maximize their expected payoff by adjusting the coefficients ${\alpha }_k$.

3.5. Resource Allocation Mechanism: The Algorithm Outline

Efficient request scheduling is critical in quantum networks to ensure optimal resource utilization and minimize latency, as explored by [35]. The quantum game theory-based resource allocation mechanism operates as follows:

• Initialization: The cloud system initializes the quantum state $|\psi \rangle$, representing the initial allocation of resources among the users.
• Strategy Selection: Each CSP and user selects their quantum strategies $U_P$ and $U_U$.
• Quantum Operations: The selected strategies are applied to $|\psi \rangle$ to generate a new state $|{\psi }^{\prime }\rangle$.
• Payoff Calculation: The payoff functions $u_i$ and $u_j$ are calculated based on $|{\psi }^{\prime }\rangle$.
• Equilibrium Search: Players adjust their strategies iteratively to reach a Nash equilibrium.
• Final Allocation: The resource allocation corresponding to the equilibrium state is implemented.

4. Proposed Architecture of the QGT-CRA Algorithm

In this section, we present a proposed QGT-CRA mechanism, formulated in a pseudo-code algorithm. As demonstrated by [36], quantum strategies leverage unitary transformations and entangled states, which are instrumental in achieving error correction below the surface code threshold [37]. The algorithm is designed to optimize the allocation of cloud resources by leveraging the principles of quantum game theory. These strategies allow simultaneous exploration of multiple allocation scenarios, reducing convergence time [38]. Following the algorithm, we discuss the time complexity and provide some theorems with corresponding proofs to establish the correctness and efficiency of the proposed mechanism (Algorithm 1).

Algorithm 1 QGT-CRA

Require:  Set of cloud service providers $\mathcal{P}=\{P_1,P_2,\dots ,P_m\}$   1: Set of users $\mathcal{U}=\{U_1,U_2,\dots ,U_n\}$   2: Resource vectors $R_i$ for each $P_i$   3: Demand vectors $d_j$ for each $U_j$   4: Initial quantum state $|\psi \rangle$ Ensure:  Optimal resource allocation $R^{*}$ for each user $U_j$   5: Initialize quantum state $|\psi \rangle$ to represent initial resource allocation   6: for each CSP $P_i\in \mathcal{P}$ do   7:     Initialize unitary strategy operator $U_i^P$   8: end for   9: for each user $U_j\in \mathcal{U}$ do 10:     Initialize unitary strategy operator $U_j^U$ 11: end for 12: repeat 13:     for each CSP $P_i\in \mathcal{P}$ do 14:         Apply quantum operation $U_i^P$ to $|\psi \rangle$ 15:     end for 16:     for each user $U_j\in \mathcal{U}$ do 17:         Apply quantum operation $U_j^U$ to $|\psi \rangle$ 18:     end for 19:     Compute payoff $u_i$ and $u_j$ for each CSP $P_i$ and user $U_j$ 20:     Update strategies $U_i^P$ and $U_j^U$ based on payoff 21: until Nash equilibrium is reached 22: Compute final resource allocation $R^{*}$ based on $|\psi \rangle$ 23: return $R^{*}$

4.1. Explanation of the Algorithm

The algorithm is designed to allocate cloud resources efficiently using quantum game theory. It involves multiple CSPs and users, where each participant (CSP and user) uses quantum strategies to maximize their utility. The steps of the algorithm are as follows:

4.1.1. Initialization (Lines 5–11)

The quantum state $|\psi \rangle$ is initialized to represent the initial allocation of resources. This state evolves as the game progresses. Each CSP $P_i$ and user $U_j$ initializes their quantum strategies, represented by unitary operators $U_i^P$ and $U_j^U$, respectively.

4.1.2. Quantum Strategy Application (Lines 12–18)

Quantum operations are applied sequentially by each CSP and user to the quantum state $|\psi \rangle$. This modifies the state according to the chosen strategies.

4.1.3. Payoff Calculation and Strategy Update (Lines 19–20)

The payoffs for each CSP and user are calculated based on the current quantum state. These payoffs are used to update the strategies of both the CSPs and users.

4.1.4. Nash Equilibrium Check (Line 21)

The algorithm checks if a Nash equilibrium has been reached. At Nash equilibrium, no player can unilaterally improve their payoff. If equilibrium is reached, the loop exits [39].

4.1.5. Final Allocation (Line 22)

The final resource allocation is computed based on the equilibrium quantum state, and the optimal resource allocation is returned.

5. Time Complexity Analysis

The time complexity of the proposed algorithm depends on several factors, including the number of CSPs (m), the number of users (n), and the complexity of quantum operations. Below is the breakdown of the time complexity for each step:

5.1. Initialization

Initializing the quantum state and strategy operators for each CSP and user takes $O(m+n)$ time.

5.2. Quantum Operations

Applying quantum operations (unitary transformations) to the quantum state takes $O\left(q\right)$ time, where q is the complexity of the quantum operation. Since this operation is performed for each CSP and user in each iteration, the total time complexity is $O\left(\right(m+n)·q)$.

5.3. Payoff Calculation

Calculating the payoff for each CSP and user is an $O(m+n)$ operation.

5.4. Strategy Update

Updating the strategies based on the payoffs also takes $O(m+n)$ time.

5.5. Convergence to Nash Equilibrium

Let k be the number of iterations required to reach Nash equilibrium. The total time complexity of the algorithm is $O(k·(m+n)·q)$.

Thus, the overall time complexity of the proposed algorithm is $O(k·(m+n)·q)$, where k is the number of iterations required to reach equilibrium, m is the number of CSPs, n is the number of users, and q is the complexity of the quantum operations.

6. Theorems and Proofs

6.1. Theorem 1: Convergence to Nash Equilibrium

Statement: The proposed quantum game theory-based resource allocation algorithm converges to a Nash equilibrium in a finite number of iterations.

Proof. 

  

• Existence of Nash Equilibrium: By Nash’s theorem, every finite game with mixed strategies has at least one Nash equilibrium. The quantum game defined in our model is a finite game, as there is a finite number of strategies available to each player (CSPs and users). Therefore, a Nash equilibrium exists.
• Convergence: The algorithm iteratively updates the strategies of CSPs and users based on the payoffs calculated from the quantum state $|{\psi }^{\prime }\rangle$. Since the strategy space is finite and each update is based on maximizing the payoff, the algorithm makes progress toward equilibrium in each iteration. Once a Nash equilibrium is reached, no player can improve their payoff by unilaterally changing their strategy, thus leading to the termination of the loop.
• Finiteness: The number of possible strategy combinations is finite, and the game is played with discrete updates. Therefore, the algorithm must converge to a Nash equilibrium in a finite number of steps.

Thus, the proposed algorithm converges to a Nash equilibrium in a finite number of iterations.    □

6.2. Theorem 2: Optimal Resource Allocation

Statement: The resource allocation $R^{*}$ achieved at the Nash equilibrium of the quantum game is optimal in the sense that it maximizes the overall utility of the cloud system while ensuring fairness among users.

Proof. 

  

• Utility Maximization: At Nash equilibrium, the payoffs $u_i$ for CSPs and $u_j$ for users are maximized given the strategies of the other players. Since the payoff functions represent the utility of resource allocation for CSPs and users, the equilibrium state $|{\psi }^{*}\rangle$ corresponds to an allocation $R^{*}$ that maximizes the overall utility of the system.
• Fairness: The quantum strategies in the game allow for the exploration of multiple allocation scenarios simultaneously, helping to achieve a balance between competing objectives, such as maximizing CSP revenue and ensuring user satisfaction. This balance is reflected in the Nash equilibrium, where no player can unilaterally improve their payoff, indicating a fair allocation.
• Efficiency: The use of quantum operations and superposition enables efficient exploration of the solution space, leading to a more optimal resource allocation compared to classical methods.

Therefore, the resource allocation $R^{*}$ at Nash equilibrium is optimal, maximizing overall utility and ensuring fairness.   □

6.3. Theorem 3: Time Complexity Bound

Statement: The time complexity of the proposed quantum game theory-based resource allocation algorithm is bounded by $O(k·(m+n)·q)$.

Proof. 

  

• Initialization: As established earlier, the initialization step takes $O(m+n)$ time.
• Quantum Operations: The complexity of applying quantum operations is $O\left(q\right)$, and this is repeated for each player (CSPs and users) in each iteration, leading to a complexity of $O\left(\right(m+n)·q)$ per iteration.
• Total Complexity: The algorithm continues to iterate until it converges to Nash equilibrium, requiring k iterations. Therefore, the total time complexity is $O(k·(m+n)·q)$.
• Bound: Since k, m, n, and q are finite, the time complexity is bounded by $O(k·(m+n)·q)$.

Thus, the time complexity of the algorithm is bounded as stated.   □

7. Qiskit-Based Implementation Strategy

The quantum implementation for resource allocation uses the Qiskit framework, which is used to create and simulate quantum circuits. The implementation includes the initialization of quantum states, application of dynamic strategies, and the measurement of quantum states after applying various quantum operations. This section outlines the code used for the simulation, from circuit creation to result visualization.

7.1. Code Overview

Community code sharing and reproducibility: We provide a set of processing scripts QGT-CRA Code: accessed on 23 April 2025 https://github.com/KAUSHTAB/Quantum-Game-Theory-Based-Cloud-Resource-Allocation, aiming to facilitate future research and familiarize researchers and practitioners who can largely exploit and use our work on quantum game theory-based cloud resource allocation.

7.2. Quantum Circuit Initialization

The quantum circuit starts by initializing qubits to a uniform superposition using Hadamard gates, ensuring all quantum states are equally probable and preparing the system for further strategy application. The algorithmic depiction (Algorithm 2) of the implemented code is given below:

Algorithm 2 Quantum State Initialization

Require:  Number of qubits n Ensure:  Quantum circuit $qc$ with qubits initialized in superposition state $|\psi \rangle$   1: for $i=0$ to $n-1$ do   2:     Apply Hadamard gate H to qubit $q_i$    ▷ Creates superposition   3: end for   4: Resulting state: $|\psi \rangle ={\displaystyle \frac{1}{\sqrt{2^n}}}{\sum }_{x=0}^{2^n-1}|x\rangle$

This step ensures that the quantum system is in an unbiased state, ready for applying different strategies.

Key Observations:

• Uniform Superposition: All qubits are initialized to equal probabilities using Hadamard gates.
• Quantum Circuit Design: The initial circuit contains only Hadamard gates applied to all qubits.
• Significance: The uniform state supports unbiased strategic decision-making in the quantum game.

Visualization:Figure 1 shows the quantum circuit after applying Hadamard gates to all qubits.

After initialization, measurements of the quantum states were performed on the simulator. The distribution of quantum states is shown in a histogram, highlighting the counts for each measured state.

Key Observations:

• Measurement Counts: Each quantum state was observed multiple times across 1000 shots, demonstrating the superposition principle.
• Probabilities: Each state had approximately equal probabilities, as shown in Figure 2.

7.3. Entanglement and Measurement

7.3.1. Role of Quantum Entanglement in Cloud Resource Optimization

Quantum entanglement is central to the QGT-CRA model. It is the distinguishing factor in quantum mechanics suited for quantum-based resource allocation over classical resource allocation paradigms. Entanglement allows for interdependent decision-making, whereby the state of one agent (e.g., user or provider in the cloud) is instantaneously correlated with others, resulting in global optimization strategies unavailable under classical, isolated reason.

Conceptual Overview of Entangled Strategies: In traditional game theory, strategies are independently chosen by each player. In QGT-CRA, strategy profiles are represented on a quantum Hilbert space, with players’ states entangled to capture strategic interdependence. Consider a 2-player quantum game with strategies over qubit states $|0\rangle$ and $|1\rangle$. A classical strategy is a tensor product:

$$|{\psi }_{\mathrm{classical}}\rangle =|s_1\rangle \otimes |s_2\rangle$$

(23)

A quantum entangled strategy is:

$$|{\psi }_{\mathrm{entangled}}{\rangle =\alpha |00\rangle +\beta |11\rangle ,\mathrm{with}\left|\alpha \right|}^2+{\left|\beta \right|}^2=1$$

(24)

This entangled state guarantees correlated measurement results, i.e., if one player chooses strategy $|0\rangle$, the other will do so as well, depending on the phase of entanglement. In resource allocation, this enables cloud providers and users to implicitly coordinate without explicit communication, essentially reaching a distributed equilibrium.

Mathematical Model with Entanglement Operator: We add entanglement to the QGT-CRA formalism through a global entangling operator J, given by:

$$J\left(\gamma \right)=exp\left(i\gamma {\sigma }_x\otimes {\sigma }_x\right)$$

(25)

where $\gamma \in [0,{\displaystyle \frac{\pi }{2}}]$ determines the amount of entanglement, and ${\sigma }_x$ is the Pauli-X gate. The joint initial state is acted upon by J prior to players applying local strategy operators $U_i({\theta }_i,{\varphi }_i)$:

$$|{\psi }_f\rangle =J^{†}(U_1\otimes U_2)J|{\psi }_0\rangle$$

(26)

Payoffs are subsequently calculated by observing $|{\psi }_f\rangle$ in the computational basis and using the formula for expected utility.

Impact on Optimization Dynamics: Entanglement facilitates the existence of quantum Nash equilibria, wherein players make better decisions more quickly because of strategic symmetry. In real life, we have the following:

• Wastage of resources is reduced through concerted action.
• Fairness improves, as entangled strategies allocate surplus and scarcity more evenly.
• Convergence is quicker, as players tend to “agree” through entanglement instead of iterating over opposing classical responses.

This results in the optimization of cloud measurements such as efficiency of allocation, load balancing, and cost-cutting.

Simulation-Based Comparison: To measure the entanglement benefit quantitatively, we simulated QGT-CRA with and without the entangling operator $J\left(\gamma \right)$. The system consisted of 10 users and 5 CSPs for 100 allocation cycles. The findings are as follows:

Interpretation: The simulation verifies that entanglement increases system-level coordination, with a faster and more equitable equilibrium than in separable (non-entangled) quantum methods. Although both versions utilize quantum benefits such as parallelism and unitary updates of strategies, only the entangled version makes use of correlated utility topologies, enabling the agents to adapt together cost-effectively.

These results confirm entanglement as an essential design element in quantum-enhanced cloud scheduling systems. Future research can explore entanglement control mechanisms, multi-player generalizations, and hybrid schemes with classical game strategies incorporated in entangled qubit systems (

Table 1. Performance comparison of QGT-CRA with and without quantum entanglement.

Metric	QGT-CRA (Entangled)	QGT-CRA (Unentangled)
Resource Utilization (%)	93.7	86.2
Fairness (Jain’s Index)	0.94	0.81
Convergence Time (Iterations)	12	21
Cost Reduction (%)	27.5	17.3

).

7.3.2. Illustrative Scenario

There are two cloud service providers (CSPs)—CSP1 and CSP2—and two users—UserA and UserB. Both users make requests for compute resources, and CSPs have to determine how to allocate them efficiently and equitably.

Classical Case (Without Entanglement):

• CSP1 and CSP2 make their allocations independently.
• UserA and UserB react to proposals and can compete for the identical resource.
• Both CSPs, without coordination, would favor high-paying UserA, and thus, UserB is treated unfairly.
• Outcome: Overloaded CSP1, starved UserB, and underloaded CSP2.

Quantum Entangled Case (With Entanglement):

• Step 1: CSPs’ and users’ strategies are entangled, i.e., their decisions are correlated.
• Step 2: When CSP1 decides to give more to UserA, the entangled state naturally corrects CSP2’s choice to offset this by leaning towards UserB.
• Step 3: The system converges through repeated updates until a balanced and optimal distribution is achieved (quantum Nash equilibrium).
• Step 4: The resultant quantum state is measured, and a resource allocation plan is derived wherein both users receive equitable access without conflict.

Interpretation:

• Entanglement enables implicit cooperation: the providers do not have to actually communicate—the coordination occurs through quantum correlations.
• Reduces conflict of allocation and prevents redundant work.
• Enhances fairness: Proportionate access is provided to all users.
• Accelerates convergence: Optimum state is attained in fewer steps than in classical feedback loops.

7.3.3. Code-Based Implementation of Quantum Entanglement

The code also introduces controlled entanglement between the CSPs and users using CNOT gates, ensuring collaboration between the two groups. After applying the strategies, measurements are added to the quantum circuit Figure 3 to record the state of the system. The algorithmic (Algorithm 3) depiction of the code is given below.

Algorithm 3 Dynamic Entanglement Between CSPs and Users

Require:  Number of CSPs m, Number of Users n Ensure:  Entangled quantum state between CSPs and Users   1: for $i=0$ to $m-1$ do   2:     for $j=0$ to $n-1$ do   3:         Apply CNOT gate: control $q_i$, target $q_{m+j}$    ▷ Entangles CSP $P_i$ with User $U_j$   4:     end for   5: end for

The measurements are then recorded, and the results are displayed using both histograms and bar charts to visualize the distribution of quantum states.

7.4. Dynamic Strategy Application

The strategy unitary operations are defined for both the CSPs and the users, with specific angles for the rotation gates. The algorithmic depiction (Algorithm 4) of the code for applying the rotation gates to the CSP and user qubits is given below.

Algorithm 4 Strategy Initialization using Rotation Gates

Require:  Number of CSPs m, Number of Users n   1: Strategy angles ${\theta }^{CSP}=[{\theta }_1^P,{\theta }_2^P,\dots ]$   2: Strategy angles ${\theta }^{User}=[{\theta }_1^U,{\theta }_2^U,\dots ]$ Ensure:  Quantum circuit $qc$ with initialized strategies   3: for $i=0$ to $m-1$ do   4:     Apply $R_y\left({\theta }_i^P\right)$ to qubit $q_i$    ▷ Strategy unitary for CSP $P_i$   5: end for   6: for $j=0$ to $n-1$ do   7:     Apply $R_y\left({\theta }_j^U\right)$ to qubit $q_{m+j}$    ▷ Strategy unitary for User $U_j$   8: end for

Dynamic strategies were applied to the qubits using rotational gates ($R_y$) with specific angles. Controlled entanglement was introduced between the CSP and user qubits.

Key Observations:

• Strategy Angles: CSPs and users adopted specific angles for their $R_y$ rotations: ${\theta }_{CSP}=\pi /4$ and ${\theta }_{User}=\pi /3$.
• Entanglement: CNOT gates created quantum entanglement, enabling collaborative decision-making.

Measurement Results: The measurement results, after applying the strategies and entanglement, are shown in Figure 4. The results demonstrate the influence of strategy evolution on quantum state probabilities.

Statistics:

• Total Shots: 2048;
• Unique States: $2^4=16$;

Probabilities: 

Table 2. Quantum state probabilities.

State	Count	Probability (%)
|0000⟩	128	6.25%
|0001⟩	132	6.44%
⋮	⋮	⋮
|1111⟩	120	5.86%

summarizes the probabilities for each quantum state.

Over 10 iterations, the strategy angles evolved dynamically, as illustrated in Figure 5. The average angles for CSP and user qubits converged to optimal values for resource allocation.

8. Computational Cost and Scalable Quantum Design

The computational complexity of running QGT-CRA on quantum simulators or hardware is a function of:

• Qubit Count $Q=m+n$, with m providers and n users.
• Gate Depth $G=O\left(Q^2\right)$ as a result of all-to-all entanglement.

For instance, for $Q=15$, the present IBM Q hardware accommodates shallow circuits ($G\le 100$ gates) with reasonable fidelity. On simulators (e.g., Qiskit Aer), this setting executes with higher latency but is still computationally viable.

To host millions of users, we suggest three approaches:

• Federated Quantum Scheduling: Divide users into small clusters and execute QGT-CRA in parallel.
• Approximate Quantum Modeling: Employ reduced density matrices or tensor networks to approximate entanglement in larger systems.
• Hybrid Quantum–Classical Cascades: Employ QGT-CRA for SLA-critical work while offloading background workloads to classical schedulers.

These methods capture the theoretical benefit of QGT-CRA but are still flexible to NISQ (Noisy Intermediate-Scale Quantum)-era hardware limitations.

9. Comparative Performance Evaluation with Classical Strategies

9.1. Classical Game Theory

To highlight the novelty and performance of the QGT-CRA framework, it is essential to compare its conceptual and performance differences with established classical resource allocation methods. This section provides a comprehensive comparison of three prominent classical paradigms: cooperative game theory (CGT), non-cooperative pricing models (NCPMs), and auction-based allocation (ABA), which assess each method on strategic modeling, scalability, computational overhead, fairness, convergence efficiency, and security.

9.1.1. CGT

Cooperative game theory frameworks are based on coalition formation between CSPs and users to achieve maximum joint utility [17,40]. The frameworks employ transferable utility notions and bargaining solutions (e.g., Nash bargaining or Shapley value) to obtain allocation decisions. Mathematically, cooperative games seek to maximize a group utility function:

$$U_{\mathrm{total}}=\sum _{i\in C}{u}_i\left(x_i\right)\mathrm{subject}\mathrm{to}\sum x_i\le R$$

(27)

where C represents the coalition set, $x_i$ represents the resource allocated to user i, and R represents the amount of available resource.

Whereas CGT is guaranteed to provide fair and Pareto-efficient allocations, it has the drawback of excessive computational complexity in large-scale systems because it requires considering all feasible coalition structures. In addition, CGT typically makes rational, cooperative behavior assumptions that do not necessarily apply in real-world, competitive multi-tenant cloud systems. In contrast, QGT-CRA enables the joint consideration of both cooperative and competitive behavior through entanglement-aided strategy modeling and superposition.

9.1.2. NCPM

NCPMs model CSPs and users as autonomous rational agents competing for resources through pricing and utility maximization [41,42]. The utility function of each user is given by:

$$u_j=v_j-p_j.x_j$$

(28)

where $v_j$ is valuation, $p_j$ is price per unit resource, and $x_j$ is the quantity of the resource purchased.

While NCPMs are easy to apply and computationally inexpensive, they inevitably benefit users with greater willingness or capacity to pay at the expense of others, leading to low fairness and likely resource monopolization. They are also non-agile to changes in system dynamics without regular price re-tuning. QGT-CRA integrates agility in the quantum strategy evolution process and attains fair allocations via probabilistic outcome modeling in superpositioned decision states.

9.1.3. ABA

Auction mechanisms (first-price, Vickrey, combinatorial) have been heavily employed in cloud resource markets. They work by requesting users place bids, and the allocation is made by the auction rules [43,44]. An ordinary sealed-bid auction can be represented as:

$$\underset{i\in N}{max}{b}_i\mathrm{subject}\mathrm{to}\sum _i{x}_i\le R$$

(29)

where $b_i$ is the bid submitted by user i, and $x_i$ is the allocation.

While auctions guarantee incentive compatibility and decentralized control, they are susceptible to strategic manipulation (e.g., collusion or false bidding) and tend to lead to non-optimal resource allocation due to bid volatility. ABA does not have the mechanism to guarantee fairness or cost minimization from a global system perspective. On the other hand, QGT-CRA obtains globally optimal equilibria through dynamic entangled strategies that balance utility, fairness, and cost.

9.2. Models Used to Advocate the Classical Game Theory-Based Comparison

9.2.1. CGT-SBCG

• Model Used: Shapley value-based coalition game (SVCG).
• Functioning: Users and CSPs create coalitions, and resources are allocated based on the Shapley value, providing equitable contribution-based rewards.

Limitations:

• Requires listing of all coalition structures—computationally intensive for large systems.
• Not real-time scalable.

QGT-CRA Advantage:

• Obtains coalition-like behavior through quantum entanglement, eliminating the necessity of explicit coalitions or intricate bargaining computations.
• Converges at a faster rate while being fair.

9.2.2. NCPM-SGPC

• Model Used: Stackelberg game-based pricing model (SGPC).
• Functioning: CSPs are leaders, determining prices; users are followers, deciding resource quantities to achieve maximum utility given those prices.

Limitations:

• Incentivizes monopolization of resources by high-budget users.
• Tends to have low fairness and wasteful outcomes.

QGT-CRA Advantage:

• Enables fair competition with balanced quantum strategies that bar dominance by one user.
• Provides better fairness (0.94 Jain’s Index compared to 0.76 in Stackelberg model).

9.2.3. ABA-FPSB

• Model Used: First-price sealed-bid auction (FPSB).
• Functioning: Hidden bids for resources are submitted by users; highest bidder pays their own bid and wins.

Limitations:

• Susceptible to strategic manipulation, e.g., underbidding or collusion.
• Does not necessarily guarantee efficient or fair resource allocation.

QGT-CRA Advantage:

• Enforces quantum auction mechanisms, e.g., quantum-sealed bids and superpositioned strategies, which provide improved security, fairness, and speed.
• Enables faster convergence and greater cost savings.

9.3. Comparitive Analysis

9.3.1. Resource Utilization (%)

Resource utilization indicates the extent to which the system can allocate available cloud resources (CPU, memory, storage) to users. The suggested QGT-CRA approach attains a resource utilization rate of 93.7%, much higher than the rates attained by CGT-SBCG (87.1%), ABA-FPSB (85.3%), and NCPM-SGPC (82.4%). This is because QGT-CRA can analyze various allocation strategies at the same time through the power of quantum superposition. The parallelism inherent in quantum computation enables the algorithm to skip suboptimal local maxima that classical algorithms tend to be stuck in. Although CGT-SBCG emphasizes group utility, even they are susceptible to negotiation overhead and delays in reaching decisions. NCPM-SGPC and ABA-FPSB, however, under-utilize resources when users bid inefficiently or hold back resources because of price dynamics. In contrast, QGT-CRA constantly adapts to world system conditions via entangled strategic decisions, with high degrees of resource saturation and little idle capacity.

Table 3. Benchmarking Results: Comparison of QGT-CRA with classical resource allocation methods.

Method	Resource Utilization (%)	Convergence Time (Iterations)	Fairness Index (Jain’s)	Cost Reduction (%)
QGT-CRA	93.7	12	0.94	27.5
CGT-SBCG	87.1	25	0.89	15.3
NCPM-SGPC	82.4	30	0.76	12.1
ABA-FPSB	85.3	22	0.81	18.7

and Figure 6 represent the resource utilization percentages via tabular and graphical representations.

9.3.2. Convergence Time (Iterations)

Convergence time assesses how efficiently a resource allocation algorithm converges to a final stable equilibrium with no additional improvement in strategy resulting in better utility. In terms of this metric, QGT-CRA substantially outperforms its traditional predecessors by converging within 12 iterations. CGT-SBCG converges in 25 iterations, ABA-FPSB in 22, and NCPM-SGPC in a whopping 30 iterations. This is made possible by the QGT-CRA harnessing the power of quantum entanglement and strategy superposition to explore the entire space of strategies simultaneously, as opposed to sequentially. All the classical approaches are based on iterative feedback loops—coalition formation in CGT-SBCG, multiple rounds of auctions in ABA-FPSB, and pricing equilibrium adjustments in NCPM-SGPC—and hence are slow. Conversely, quantum strategies achieve equilibrium more quickly because of the constructive interference of optimal states, lowering computational overhead along with allocation latency. Table 3 and Figure 7 represent the convergence time iterations via tabular and graphical representations.

9.3.3. Fairness Index (Jain’s Index)

Fairness is a vital measure in multi-tenant cloud environments where resource distribution equally is paramount. Calculated based on Jain’s Fairness Index (where 1 represents optimal fairness), QGT-CRA has a score of 0.94, which represents nearly even distribution across all users. CGT-SBCG is second at 0.89 since coalition-based decision-making tends to look at fairness but yet permits marginal imbalances. ABA-FPSB has a moderate rating of 0.81, as bidding mechanisms inherently benefit more powerful buyers. NCPM-SGPC is rated the lowest at 0.76, where great disparity occurs as aggressive buyers can dominate resources. QGT-CRA maintains high fairness due to the application of entangled strategies, which balance personal utility in accordance with system-wide optimization. This mechanism naturally allocates resources in a more equal manner since quantum superpositions take into account all possible allocations simultaneously, thereby minimizing bias toward any one stakeholder. Table 3 and Figure 8 represent the fairness index via tabular and graphical representations.

9.3.4. Cost Reduction (%)

Cost saving analyzes the effectiveness of the allocation strategy in optimizing the total system cost while fulfilling user requirements. QGT-CRA achieves a maximum cost saving of 27.5%, and then it is auction-based allocation at 18.7%, cooperative game theory at 15.3%, and non-cooperative pricing models with a mere 12.1%. All such savings in QGT-CRA are due to its adaptive updating of strategies and dynamic reallocation of idle resources, resulting in minimal redundancy and wastage. In contrast to traditional models wherein overprovisioning of resources or competitive inefficiencies add to the operational costs, QGT-CRA takes advantage of quantum computations in order to quickly determine optimal, cost-effective configurations. This not only lightens infrastructure load but also reduces power usage and virtual machine sprawl; therefore, the setup is especially suited for green cloud computing projects. Additionally, since it achieves equilibrium faster, QGT-CRA also minimizes the runtime and scheduling overhead generally associated with iterative allocation systems. Table 3 and Figure 9 represent the convergence time iterations via tabular and graphical representations.

9.3.5. Fairness-Efficiency (Resource Allocation) Trade-Off in QGT-CRA

One of the greatest strengths of QGT-CRA is its potential to reconcile fairness and efficiency, two goals that habitually confront each other in traditional models. In the traditional context, fairness prioritization tends to lead to inefficient use (underexploitation of resources), whereas efficiency maximization might translate to monopoly by high-paying or hostile users.

The trade-off in QGT-CRA is avoided by employing the quantum entangled strategies and superposition in order to make the system assess various resource allocation outcomes concurrently. Fairness is attained as the quantum state converges towards a common point that represents collective utility for all the users, while efficiency is maintained in order to avoid the maximum idle capacity and optimal allocation trajectories.

For example, if a high-demand user and a low-demand user are coupled, the choice made for one will automatically rescale the other’s allocation to ensure system-wide equilibrium. This eliminates the explicit requirement of centralized arbitration or iterative negotiation in CGT-SBCG and instead achieves an efficient and equitable equilibrium more quickly.

The results confirm this balance: QGT-CRA attains both the highest resource usage (93.7%) and the best fairness score (0.94 Jain’s Index), showing that it is able to optimize for both extremes of the spectrum without giving either up (Table 3).

10. Comparitive Analysis with Recent Optimization and Quantum-Inspired Techniques

10.1. Recent Optimization and Quantum-Inspired Techniques

• DQN-Based Allocator: A reinforcement learning agent is trained to acquire optimal resource allocation policies through experience. It learns to map states (e.g., current load, resource supply) to actions through a deep neural network. DQN performs well in adaptive environments but tends to need large datasets and precise reward tuning [45,46].
• GA-Based Scheduler: An evolutionary method where allocation strategy populations are evolved across generations through selection, crossover, and mutation. GA is strong in dealing with multi-objective constraints but tends to converge slowly and can result in inconsistent fairness results [47,48].
• PSO: A swarm intelligence method where particles (solutions) traverse the solution space based on their own and neighbors’ experiences. PSO is light and flexible but can be prone to local optima and does not enforce equilibrium [49,50].
• Quantum-Inspired Genetic Algorithm (QGA): A traditional simulation of quantum behavior with probabilistic bit representations (Q-bits). It emulates superposition but not genuine quantum entanglement. It strikes a balance between exploration and exploitation but is computationally more expensive than traditional GA [51,52].

10.2. Comparative Analysis

In order to further establish the attestations of improvement of the new QGT-CRA approach, we broadened the scope of our study to compare it with some of the most recently developed optimization methods and quantum-inspired algorithms that are commonly known to be highly responsive and perform well in dynamic conditions. Specifically, we compared QGT-CRA with a DQN-based resource allocator, a GA-based scheduler, and a PSO-based allocation model. These algorithms are recognized for their ability to resolve non-convex, multi-objective problems common in cloud environments.

The DQN-based method uses reinforcement learning to incrementally refine a policy that transforms system states (e.g., workload, availability of resources) into optimal allocation decisions. Although this algorithm scales well with varying demands, it needs extensive training time and is reward-sensitive. In our experiments, it showed good fairness and usage but fell behind in convergence time and suffered from sporadic instability at inference because of policy overfitting. On the other hand, QGT-CRA accomplishes stable, real-time convergence with entangled decision-making without episodic training or reward engineering.

The GA-based model, based on evolutionary computation, worked reasonably well in achieving near-optimal allocations in the long run but had the drawback of slow convergence (frequently more than 50 iterations) and unstable fairness because of its use of random mutation and crossover. PSO, though quicker than GA, still did not have the strategic equilibrium coordination that existed in QGT-CRA. Both algorithms could not compare with QGT-CRA in resource efficiency, SLA adherence, and energy-aware scheduling.

Quantum-inspired heuristics and quantum mechanics-inspired models (e.g., Q-bit-based genetic models) analyze quantum behavior with classical resources. They provide some probabilistic advantage over classical heuristics but do not have the real parallelism or entangled utility modeling of QGT-CRA. Our comparative simulations showed QGT-CRA with quantum entanglement always outperforming these models in key metrics—greater fairness (0.94 vs. 0.87), faster convergence (12 vs. 34+ iterations), and lower SLA violation rates (3.2% vs. 5–8%).

In summary, QGT-CRA not only outperforms traditional algorithms but also outperforms or is equal to state-of-the-art optimization methods and quantum-inspired models. Its capacity to utilize entangled strategies gives it a distinct and quantifiable edge in dynamic, multi-agent cloud resource allocation environments—attesting to the strength and originality of our proposed framework (

Table 4. Comparison of QGT-CRA with recent optimization and quantum-inspired models.

Method	Utilization (%)	Fairness (Jain’s)	Convergence (Iter)	Service Level Agreement (SLA) Violations (%)	Cost Reduction (%)	User Satisfaction	Energy Efficiency
QGT-CRA (Entangled)	93.7	0.94	12	3.2	27.5	0.92	4.1
QGT-CRA (Unentangled)	86.2	0.81	21	8.4	17.3	0.81	3.1
DQN-Based Allocator	88.6	0.87	34	5.5	19.2	0.88	3.5
GA-Based Scheduler	84.1	0.79	52	7.3	15.6	0.76	3.2
PSO Allocator	83.7	0.77	44	6.9	14.9	0.74	2.9
Quantum-Inspired GA (QGA)	85.9	0.84	36	6.1	18.1	0.83	3.4

).

11. Deployment Strategy and Real-World Integration of QGT-CRA: A Futuristic Approach

Although the theoretical basis and simulated behavior of the QGT-CRA framework have been soundly established, its instantiation in real-world, production-level cloud infrastructures requires a well-defined methodology. This section describes the end-to-end deployment structure, elaborates on integration points with current cloud platforms, and shows real-time usage scenarios that prove its viability.

11.1. Modular Hybrid Deployment Architecture

Considering the present constraints in quantum hardware, we suggest a hybrid cloud, modular design that gradually adds QGT-CRA as a strategic optimization module in conjunction with keeping classical components for operation control and orchestration.

Core Architectural Components:

• Classical Frontend Orchestrator (e.g., Kubernetes, OpenStack): Orchestrates resource provisioning, monitoring, and autoscaling. Connects with QGT-CRA through middleware.
• Quantum Optimization Module (QOM): Holds QGT-CRA logic executed on simulators or NISQ hardware through cloud APIs. Consumes system state inputs and generates optimal allocation vectors.
• Middleware Adapter: Maps classical inputs to quantum-ready encodings and handles data transfer to the QOM.
• Result Translator and Actuator: Maps quantum outputs into actionable resource decisions and returns them to the orchestrator.

This architecture causes minimal disruption to legacy cloud systems while increasingly adding quantum optimization capabilities (Figure 10).

11.2. Applicability to Real-Time Scenarios

In spite of current latency during the execution of quantum circuits, QGT-CRA can be employed for near real-time scenarios like the following:

• Scheduling Batch Jobs: Recalculating VM-job allocations on a periodic basis of every 15–30 min.
• Multi-Tenant Fair Scheduling: Proportionate allotment across organization partitions in federated clouds.
• Green Resource Utilization: Power-aware placement of tasks using optimized global strategies.
• Marketplace-Based Pricing: Dynamic pricing powered by quantum computing for edge-cloud and serverless environments.

11.3. Step-by-Step Adoption Plan for Industry

Table 5. Recommended phased strategy for deploying QGT-CRA in operational cloud environments.

Phase	Strategy	Tools/Platforms
Proof of Concept	Simulate batch allocation using QGT-CRA	IBM Qiskit, Rigetti Forest
Hybrid Simulation	Connect QGT to orchestration systems	REST/gRPC APIs, Docker, Kubernetes
Semi-Realtime Ops	Use QGT-CRA in idle system cycles	OpenFaaS, Apache Airflow, Qiskit Cloud
Quantum Transition	Shift QGT-CRA to real hardware gradually	IBM Quantum, AWS Braket

represents the Step-by-Step Adoption Plan for Industry.

11.4. Benefits of Incremental Deployment

• Scalability: Start with small workloads before large-scale deployment.
• Compatibility: QGT-CRA is a plugin to current schedulers.
• Explainability: Payoff results can be visualized and debugged.
• Future-Readiness: Built to scale from simulation to actual quantum systems.

By adopting a step-wise, modular hybrid deployment path, QGT-CRA can be seamlessly integrated into current cloud infrastructures. Although full real-time quantum operation might not currently be an immediate possibility, half-real-time integration already provides definite benefits and places cloud platforms ahead of the next breakthroughs in quantum computing.

12. Implementation Feasibility and Deployment Considerations

Although the QGT-CRA framework has shown promise in simulation, its real-world deployment within cloud environments has some practical implications. The section presents those practical implications under five technical pillars: hardware constraints, hybrid integration, scalability, cost of operation, and future readiness.

12.1. Quantum Hardware Constraints

The essential restriction of carrying out QGT-CRA stems from the potential of today’s quantum processors, which are mostly in the NISQ regime. Those machines are identified by a small number of qubits, limited coherence times, and high gate error rates. For example, an m cloud service provider versus n users quantum game needs a quantum state within a joint Hilbert space:

$${\mathcal{H}}_{\mathrm{total}}=\underset{i=1}{\overset{m+n}{⨂}}{\mathcal{H}}_i$$

(30)

where ${\mathcal{H}}_i$ denotes the state space of each participant. The dimensionality of this space is $2^{m+n}$, which implies exponential growth in required resources with the number of participants.

In addition, quantum circuits implementing QGT involve several layers of entangling gates (e.g., CNOTs) to represent strategy correlation. These gates are the most noise-prone, exacerbating the issue even further. On existing quantum hardware, this puts a practical constraint on problems with greater than 5 players, making the full version of QGT-CRA presently unscalable on hardware.

12.2. Integration with Classical Cloud Systems

A full deployment of QGT-CRA would require a hybrid quantum–classical architecture, where classical cloud infrastructure manages orchestration, billing, and real-time monitoring, and quantum processors address hard optimization sub-problems. This does add latency due to quantum circuit execution and readout.

Let $T_q$ be quantum runtime and $T_c$ be classical processing overhead. The overall decision-making time becomes:

$$T_{\mathrm{total}}=T_c+T_q+T_{\mathrm{transfer}}$$

(31)

where $T_{\mathrm{transfer}}$ includes serialization, deserialization, and data transfer. Even with optimistic assumptions, when $T_q$ is minimal, frequent transitions between classical and quantum systems add unacceptable latencies for real-time scheduling.

12.3. Scalability and Circuit Complexity

Quantum scalability is also limited not only by the total number of accessible qubits but also by how qubits interact. In a QGT-CRA protocol with m providers and n users, under the assumption of 2 strategy parameters per player (e.g., rotation parameters ${\theta }_i,{\varphi }_i$), the quantum circuit needs at least:

$$Q_{\min }=m+n\mathrm{qubits}$$

(32)

and at most:

$$G_{\mathrm{depth}}=O\left({(m+n)}^2\right)\mathrm{gates}$$

(33)

because of the requirement of pairwise entanglement and multi-layer unitary updates. This increase in gate depth results in higher decoherence probability $P_d$, lowering fidelity. Therefore, the model is still only suitable for small-scale problems.

12.4. Cost, Accessibility, and Workforce Readiness

Quantum computer access is also available only on cloud platforms, and the price can be exorbitant. Additionally, the execution of moderately sized QGT-CRA instances is very computationally expensive. The monetary cost, along with unavailability and scheduling latencies, poses a challenge to the deployment of quantum solutions in scale.

Moreover, the development and upkeep of quantum modules is specialized knowledge that most cloud engineers lack, having not been educated in quantum programming frameworks like Qiskit or Cirq. Closing this knowledge gap will need to be addressed through specialized training or the recruitment of interdisciplinary professionals.

Despite these limitations, the future of QGT-CRA is bright. In the near term, it can be embedded in hybrid workflows where quantum solvers serve as offline decision-making engines for batch optimization problems. Quantum-inspired algorithms can simulate quantum behavior and yield advantages without true quantum hardware. As quantum systems advance, complete integration of QGT-CRA will be possible.

Although the QGT-CRA approach has superior simulation theoretical abilities and performance benefits in simulation, its current limitations of hardware, latency, scalability, and cost will hold it back from real-world deployment. Nonetheless, the approach is forward-compatible and can possibly be incrementally embraced through quantum-inspired methods and offline quantum modules, as well as hybrid workflows. With continued hardware and compiler progress in quantum computers, QGT-CRA potentially has the future to transform the optimization of cloud resources in the near term.

Table 6. Practical feasibility comparison of classical and quantum resource allocation approaches.

Criterion	Cooperative GT	Auction-Based	NCPM	QGT-CRA
Hardware Availability	High	High	High	Low
Real-Time Responsiveness	Moderate	High	High	Low
Scalability	Medium	High	High	Low–Medium
Circuit Complexity	N/A	N/A	N/A	High
Implementation Cost	Low	Low	Medium	High
Fairness Potential	High	Medium	Low	High
Long-Term Potential	Medium	Low	Low	Very High

represents a practical feasibility comparison of classical and quantum resource allocation approaches.

13. Limitations of the Proposed QGT-CRA Algorithm

Despite its promising results, this study on quantum game theory-based cloud resource allocation has certain limitations:

• Scalability Constraints: The proposed framework has primarily been tested on simulated environments with limited scalability. Real-world cloud systems with large-scale users and providers may present unforeseen challenges.
• Quantum Hardware Availability: The reliance on advanced quantum hardware poses a significant limitation, as current quantum computers lack the capacity to execute large-scale quantum simulations effectively.
• User-Centric Considerations: While the model optimizes for system-wide efficiency, the specific preferences or satisfaction levels of individual users are not deeply addressed, potentially affecting adoption rates.
• Complexity of Implementation: The integration of quantum algorithms with classical systems may involve high computational and developmental overheads.

14. Future Work

Building on the insights from this study, future research can explore the following avenues:

• Scalability Enhancements: Developing algorithms that can seamlessly scale with the complexity of real-world cloud computing environments.
• Integration with Hybrid Systems: Exploring hybrid quantum–classical algorithms to leverage the strengths of both paradigms for enhanced resource allocation.
• Dynamic Adaptation: Introducing mechanisms for real-time adjustments to strategies based on continuously evolving workloads and user demands.
• User Satisfaction Models: Incorporating models that prioritize individual user satisfaction and fairness to ensure wider adoption and equity.
• Hardware Optimization: Collaborating with advancements in quantum hardware to test and refine the framework on practical, large-scale quantum systems.
• Energy Efficiency: Investigating the energy consumption of quantum strategies and developing sustainable allocation models for green cloud computing.

These directions aim to address the current limitations and expand the applicability of quantum game theory in cloud computing.

15. Conclusions

This paper proposed a new QGT-CRA model based on the principles of quantum mechanics, particularly entanglement and superposition, to better optimize resource distribution in cloud computing. By quantizing the user–CSP interaction as a quantum game, the new algorithm achieved far better resource utilization (93.7%), fairness (Jain’s Index = 0.94), cost-saving (27.5%), and speed of convergence (12 iterations) compared to traditional approaches. Employing QiNE allowed adaptive, equitable, and efficient allocation results that are impractical to compute in traditional domains. In addition, the deployment through Qiskit illustrates the pragmatic viability of quantum strategy simulation with existing tools.

Notwithstanding these developments, the real-world deployment of QGT-CRA is presently limited by the limited scalability of quantum hardware, the complexity of integration with classical systems, and real-time scheduling latency. Nevertheless, the hybrid simulation frameworks, modular deployment approaches, and cloud orchestration support provide a solid basis for real-world applicability as quantum hardware matures.