Duplicate from RituJim/QNim

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: QNim
+emoji: 🦀
+colorFrom: purple
+colorTo: purple
+sdk: gradio
+sdk_version: 3.16.0
+app_file: app.py
+pinned: false
+duplicated_from: RituJim/QNim
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,154 @@
+import gradio as gr
+import datetime
+from nim_game_env import NimGameEnv
+from nim_gpt_functions import plan_gpt_move, plan_qc_move, execute_move
+
+TEMPERATURE_DEFAULT = 0.5
+PILES_DEFAULT = [3, 5, 7]
+HUMAN_STR = "Human"
+PLAY_AGAINST_QC = "QC"
+PLAY_AGAINST_GPT = "AI"
+
+
+def reset_game(chat_history, nim_game_env):
+    chat_history = []
+    nim_game_env = NimGameEnv(PILES_DEFAULT)
+    game_state_text, game_state_piles = nim_game_env.reset()
+    ascii_art = generate_game_state_ascii_art(game_state_piles, False, 0, "")
+    message_str = ""
+    return chat_history, chat_history, message_str, ascii_art, nim_game_env
+
+
+def generate_game_state_ascii_art(piles, done, reward, player):
+    ascii_art = "Game Over, " + player + " wins!"
+    if not done:
+        pile_a = piles[0]
+        pile_b = piles[1]
+        pile_c = piles[2]
+        ascii_art = f"Pile A: {'|' * pile_a} \nPile B: {'|' * pile_b} \nPile C: {'|' * pile_c}"
+    return "<pre>" + ascii_art + "</pre>"
+
+
+def send_chat_msg(inp, chat_history, nim_game_env, temperature, openai_api_key, play_against):
+    if not openai_api_key or openai_api_key == "":
+        warning_msg = "<pre>Please paste your OpenAI API key (see https://beta.openai.com)</pre>"
+        return chat_history, chat_history, warning_msg
+
+    if not inp or inp == "":
+        warning_msg = "<pre>Please enter a move</pre>"
+        return chat_history, chat_history, warning_msg
+
+    inp = inp.strip()
+    output = None
+    chat_history = chat_history or []
+
+    text_obs, observation, reward, done, info = execute_move(inp, nim_game_env, openai_api_key)
+    ascii_art = generate_game_state_ascii_art(observation, done, reward, HUMAN_STR)
+
+    if done:
+        if reward == 1:
+            output = "Good game!"
+            ascii_art = generate_game_state_ascii_art(observation, done, reward, HUMAN_STR)
+        else:
+            output = text_obs
+            ascii_art = generate_game_state_ascii_art(observation, done, reward, play_against)
+    else:
+        if play_against == PLAY_AGAINST_QC:
+            output = plan_qc_move(text_obs)
+        else:
+            output = plan_gpt_move(text_obs, temperature, openai_api_key)
+
+        text_obs, observation, reward, done, info = execute_move(output, nim_game_env, openai_api_key)
+        ascii_art = generate_game_state_ascii_art(observation, done, reward, play_against)
+
+    print("\n==== date/time: " + str(datetime.datetime.now() - datetime.timedelta(hours=5)) + " ====")
+    print("inp: " + inp, ", output: ", output, ", observation: ", observation)
+
+    chat_history.append((HUMAN_STR + ": " + inp, play_against + ": " + output))
+    return chat_history, chat_history, ascii_art
+
+
+def update_foo(widget, state):
+    if widget:
+        state = widget
+        return state
+
+
+def update_opponent(widget, state):
+    if widget:
+        state = widget
+        return state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+with block as nim_game:
+    temperature_state = gr.State(TEMPERATURE_DEFAULT)
+    openai_api_key_state = gr.State()
+    history_state = gr.State()
+    nim_game_env_state = gr.State(NimGameEnv(PILES_DEFAULT))
+    play_against_state = gr.State(PLAY_AGAINST_QC)
+
+    with gr.Row():
+        game_state_html = gr.Markdown()
+
+        with gr.Column():
+            title = gr.Markdown("""<h3><center>QNimGPT</center></h3>""")
+            subtitle = gr.Markdown("""<i><center>Play Nim against an IBM Quantum Computer simulator or OpenAI 
+            GPT-3.5 AI. By <a href="https://github.com/ritu-thombre99">Ritu Thombre</a> and <a 
+            href="https://github.com/JavaFXpert">James Weaver</a></center></i>""")
+
+        with gr.Column():
+            openai_api_key_textbox = gr.Textbox(placeholder="Paste your OpenAI API key",
+                                                show_label=False, lines=1, type='password')
+            play_against_radio = gr.Radio(label="Play against:", choices=[
+                PLAY_AGAINST_QC, PLAY_AGAINST_GPT], value=PLAY_AGAINST_QC)
+            play_against_radio.change(update_foo,
+                                      inputs=[play_against_radio, play_against_state],
+                                      outputs=[play_against_state])
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message_tb = gr.Textbox(label="What's your move?",
+                                placeholder="I'll take 2 sticks from pile A")
+        send_btn = gr.Button(value="Send", variant="secondary").style(full_width=False)
+
+    with gr.Row():
+        gr.Examples(
+            examples=["I'll take two sticks from pile A",
+                      "Three sticks from the second pile",
+                      "From pile C remove 2 sticks"],
+            inputs=message_tb
+        )
+        reset_btn = gr.Button(value="Reset Game", variant="secondary").style(full_width=False)
+        temperature_slider = gr.Slider(label="GPT Temperature", value=TEMPERATURE_DEFAULT, minimum=0.0, maximum=1.0,
+                                       step=0.1)
+
+    send_btn.click(send_chat_msg, inputs=[message_tb, history_state, nim_game_env_state, temperature_state,
+                                          openai_api_key_state, play_against_state],
+                   outputs=[chatbot, history_state, game_state_html])
+    message_tb.submit(send_chat_msg, inputs=[message_tb, history_state, nim_game_env_state, temperature_state,
+                                             openai_api_key_state, play_against_state],
+                      outputs=[chatbot, history_state, game_state_html])
+    reset_btn.click(reset_game, inputs=[history_state, nim_game_env_state],
+                    outputs=[chatbot, history_state, message_tb, game_state_html, nim_game_env_state])
+    nim_game.load(reset_game, inputs=[history_state, nim_game_env_state],
+                  outputs=[chatbot, history_state, message_tb, game_state_html, nim_game_env_state])
+
+    gr.Markdown("""<center>Each player may remove sticks from a pile on their turn. 
+    Player to remove the last stick wins.
+    <a href="https://en.wikipedia.org/wiki/Nim" target="new">
+    Nim is one of the first-ever electronic computerized games</a>
+    </center>""")
+
+    gr.HTML("<center>Powered by <a href='https://github.com/hwchase17/langchain'>LangChain 🦜️🔗</a></center>")
+
+    openai_api_key_textbox.change(update_foo,
+                                  inputs=[openai_api_key_textbox, openai_api_key_state],
+                                  outputs=[openai_api_key_state])
+
+    temperature_slider.change(update_foo,
+                              inputs=[temperature_slider, temperature_state],
+                              outputs=[temperature_state])
+
+block.launch(debug=False)

nim_game_env.py

@@ -0,0 +1,91 @@
+from abc import ABC
+
+import gymnasium as gym
+from gymnasium import spaces
+import numpy as np
+
+
+class NimGameEnv(gym.Env, ABC):
+    """Custom environment for a simple Nim game.
+
+    In this game, there are two players and a number of piles of stones.
+    Each turn, a player can choose a pile and remove any number of stones from it.
+    The player who takes the last stone loses.
+
+    The observation space is a tuple of integers representing the number of stones in each pile.
+    The action space is a tuple of two integers, representing the chosen pile and the number of stones to remove.
+    """
+
+    def __init__(self, starting_stick_piles=[3, 5, 7]):
+        self.starting_stick_piles = starting_stick_piles
+        self.num_piles = len(starting_stick_piles)
+        self.max_stones = max(starting_stick_piles)
+        self.piles = self._init_piles()
+        self.current_player = 0
+        self.action_space = spaces.MultiDiscrete([self.num_piles, self.max_stones + 1])
+        self.observation_space = spaces.MultiDiscrete([self.max_stones + 1] * self.num_piles)
+
+    def step(self, action):
+        """Take a step in the environment.
+
+        Parameters
+        ----------
+        action: tuple
+            The action taken by the player, represented as a tuple of the chosen pile and the number of stones to remove.
+
+        Returns
+        -------
+        observation: tuple
+            The current number of stones in each pile.
+        reward: float
+            The reward for the current step.
+        done: bool
+            Whether the game has ended.
+        info: dict
+            Additional information about the step.
+        """
+        # Validate the action
+        if not self._is_valid_action(action):
+            raise ValueError("Invalid action")
+
+        # Update the piles
+        pile, num_stones = action
+        self.piles[pile] -= num_stones
+
+        # Determine if the game has ended
+        done = self._is_game_over()
+
+        # Calculate the reward
+        reward = self._calculate_reward()
+
+        # Switch the current player
+        self.current_player = (self.current_player + 1) % 2
+        return self.piles, reward, done, {}
+
+    def reset(self):
+        """Reset the environment to the initial state."""
+        self.piles = self._init_piles()
+        self.current_player = 0
+        text_observation = "The piles contain " + ", ".join(str(x) for x in self.piles) + " sticks."
+        return text_observation, self.piles
+
+    def _init_piles(self):
+        """Initialize the stick piles."""
+        return [3, 5, 7]
+
+    def _generate_random_stones(self):
+        """Generate a random number of stones (between 1 and max_stones inclusive)."""
+        return np.random.randint(1, self.max_stones + 1)
+
+    def _is_valid_action(self, action):
+        """Determine if an action is valid."""
+        pile, num_stones = action
+        return 0 <= pile < self.num_piles and 0 < num_stones <= self.max_stones and num_stones <= self.piles[pile]
+
+    def _is_game_over(self):
+        """Determine if the game has ended."""
+        return all(pile == 0 for pile in self.piles)
+
+    def _calculate_reward(self):
+        """Calculate the reward for the current step."""
+        return 1 if self._is_game_over() else 0

nim_gpt_functions.py

@@ -0,0 +1,88 @@
+from langchain import OpenAI
+from langchain.prompts import PromptTemplate, FewShotPromptTemplate
+from langchain.chains import LLMChain
+from qnim import get_quantum_move
+import re
+import inflect
+p = inflect.engine()
+EXAMPLES_PROMPT_TEMPLATE = PromptTemplate(
+    input_variables=["input", "output"],
+    template="Input: {input}\nOutput: {output}"
+)
+
+PLAN_MOVE_PROMPT_EXAMPLES = [
+    {"input": "The piles contain 3, 5, 7 sticks", "output": "I'll take one stick from pile A"},
+    {"input": "The piles contain 2, 5, 7 sticks", "output": "I'll take one stick from pile B"},
+    {"input": "The piles contain 2, 5, 7 sticks", "output": "I'll take five stick from pile B"},
+    {"input": "The piles contain 1, 2, 3 sticks", "output": "I'll take two sticks from pile C"},
+    {"input": "The piles contain 0, 2, 3 sticks", "output": "I'll take one stick from pile C"},
+    {"input": "The piles contain 0, 2, 0 sticks", "output": "I'll take two sticks from pile B"},
+]
+
+PLAN_MOVE_PROMPT_FROM_STRING_EXAMPLES = FewShotPromptTemplate(
+    examples=PLAN_MOVE_PROMPT_EXAMPLES,
+    example_prompt=EXAMPLES_PROMPT_TEMPLATE,
+    prefix="Nim is a two-player game of strategy in which players take turns removing objects from separate piles. "
+           "The goal of the game is to remove the last sticks from a pile when the other piles contain 0 sticks. Each "
+           "of these inputs represent a game state. For each of these game states please express a logical move that "
+           "consists of taking some number of sticks from a pile. "
+           "You may not take any sticks from a pile that contains 0 sticks. "
+           "You may not take more sticks from a pile than it contains. "
+           "You may only take sticks from one pile. ",
+    suffix="Input: {text_game_state}\nOutput:",
+    input_variables=["text_game_state"],
+    example_separator="\n\n"
+)
+
+EXEC_MOVE_PROMPT_EXAMPLES = [
+    {"input": "I'll take two sticks from pile A", "output": "0,2"},
+    {"input": "I'll take 3 sticks from the first pile", "output": "0,3"},
+    {"input": "I'll take two sticks from pile C", "output": "2,2"},
+    {"input": "I'll take one stick from the third pile", "output": "2,1"},
+    {"input": "From pile B remove 2 sticks", "output": "1,2"},
+    {"input": "I'll take the last stick from pile C", "output": "2,1"},
+]
+
+EXEC_MOVE_PROMPT_FROM_STRING_EXAMPLES = FewShotPromptTemplate(
+    examples=EXEC_MOVE_PROMPT_EXAMPLES,
+    example_prompt=EXAMPLES_PROMPT_TEMPLATE,
+    prefix="Express every input as two numbers separated by a comma, where the first number is the zero index pile "
+           "number and the second number is the number of sticks to remove.",
+    suffix="Input: {move_to_express}\nOutput:",
+    input_variables=["move_to_express"],
+    example_separator="\n\n"
+)
+
+
+def plan_gpt_move(text_game_state, temperature, api_key):
+    llm = OpenAI(model_name='text-davinci-003', temperature=temperature, max_tokens=100,
+                 openai_api_key=api_key)
+    llm_chain = LLMChain(llm=llm, prompt=PLAN_MOVE_PROMPT_FROM_STRING_EXAMPLES, verbose=False)
+    planned_move = llm_chain.run({'text_game_state': text_game_state}).strip()
+    return planned_move
+
+
+def plan_qc_move(text_game_state):
+    board_state = [int(s) for s in re.findall(r'\b\d+\b',text_game_state)]
+    board_state.append(0)
+    pile_choice, amount = get_quantum_move(board_state)
+    if amount > 1:
+        planned_move = "I'll take " + p.number_to_words(amount) + " sticks from pile " + chr(pile_choice+65) + "."
+    else:
+        planned_move = "I'll take " + p.number_to_words(amount) + " stick from pile " + chr(pile_choice+65) + "."
+    return planned_move
+
+
+def execute_move(move_to_express, nim_game_env, api_key):
+    llm = OpenAI(model_name='text-davinci-003', temperature=0.0, max_tokens=10,
+                 openai_api_key=api_key)
+    llm_chain = LLMChain(llm=llm, prompt=EXEC_MOVE_PROMPT_FROM_STRING_EXAMPLES, verbose=False)
+    step_tuple_str = llm_chain.run({'move_to_express': move_to_express})
+    step_tuple = tuple(int(x) for x in step_tuple_str.split(','))
+    try:
+        step_result = nim_game_env.step(step_tuple)
+    except ValueError:
+        return "Invalid move!", [0, 0, 0], 0, True, None
+
+    text_observation = "The piles contain " + ", ".join(str(x) for x in step_result[0]) + " sticks."
+    return text_observation, step_result[0], step_result[1], step_result[2], step_result[3]

qnim.py

@@ -0,0 +1,239 @@
+import numpy as np
+from qiskit import BasicAer, QuantumCircuit, QuantumRegister, ClassicalRegister, execute
+from qiskit import IBMQ
+# provider = IBMQ.load_account()
+
+
+# def misere_step(ones,piles):
+#     # even number of piles of 1 eg (1,1,3,0) or (0,0,3,0)
+#     if ones%2 == 0:
+#         objects_to_remove = []
+#         removable_amount = 1
+#         for i in range(len(piles)):
+#             if piles[i] > 1:
+#                 objects_to_remove.append(piles[i]-1)
+#             else:
+#                 objects_to_remove.append(0)
+#     # odd number of piles of 1 eg (1,1,3,1)
+#     else:
+#         objects_to_remove = []
+#         removable_amount = 1
+#         for i in range(len(piles)):
+#             if piles[i] > 1:
+#                 objects_to_remove.append(piles[i])
+#             else:
+#                 objects_to_remove.append(0)
+#     return objects_to_remove, removable_amount
+
+def get_piles_to_remove(piles):
+    nim_sum = 0
+    for p in piles:
+        nim_sum = nim_sum ^ p
+    objects_to_remove = []
+    removable_amount = 0
+    for p in piles:
+        new_p = p^nim_sum
+        if new_p < p:
+            objects_to_remove.append(p-new_p)
+            removable_amount = removable_amount + 1
+        else:
+            objects_to_remove.append(0)
+    return objects_to_remove, removable_amount
+
+    
+def custom_qft(data_qubits):
+    qr_data = QuantumRegister(data_qubits)
+    qc = QuantumCircuit(qr_data)
+    i = data_qubits
+    while i>=1:
+        n = i - 1
+        qc.h(qr_data[n]) 
+        for qubit in range(n):
+            qc.cp(np.pi/2**(n-qubit), qr_data[qubit], qr_data[n])
+        i = i-1
+    return qc
+
+def subroutine_add_const(data_qubits: int, const: int, to_gate=True):
+    qc = QuantumCircuit(data_qubits)
+    for i in range(data_qubits):
+        angle = const*np.pi/(2**i)
+        qc.p(angle,i)
+    return qc.to_gate(label=" ["+str(const)+"] ") if to_gate else qc
+
+def diffusion_operation(qc, address, flag, removable_pile):
+    def nim_oracle(qc,address,flag,removable_pile):
+
+        # 0001 -> 001
+        if removable_pile[0] != 0:
+            qc.x(address[1])
+            qc.x(address[2])
+            qc.mct(address[:],flag)
+            qc.x(address[2])
+            qc.x(address[1])
+        
+        # 0010 -> 010
+        if removable_pile[1] != 0:
+            qc.x(address[0])
+            qc.x(address[2])
+            qc.mct(address[:],flag)
+            qc.x(address[2])
+            qc.x(address[0])
+    
+        # 0100 -> 011
+        if removable_pile[2] != 0:
+            qc.x(address[2])
+            qc.mct(address[:],flag)
+            qc.x(address[2])
+        
+        # 1000 -> 100
+        if removable_pile[3] != 0:
+            qc.x(address[0])
+            qc.x(address[1])
+            qc.mct(address[:],flag)
+            qc.x(address[1])
+            qc.x(address[0])
+
+
+    qc.x(flag)
+    qc.h(flag)
+
+    qc.h(address[:])
+    nim_oracle(qc,address,flag,removable_pile)
+    qc.h(address[:])
+    qc.x(address[:])
+    qc.h(address[2])
+    qc.mct(address[0:2], address[2])
+    qc.h(address[2])
+    qc.x(address[:])
+    qc.h(address[:])
+
+    
+def qc_process(qc,objects_to_remove,address,flag,piles,removable_pile,removable_count):
+
+    if removable_count == 0:
+        for i in range(len(removable_pile)):
+            if piles[i] > 0:
+                removable_pile[i] = 1
+                removable_count += 1
+
+    if removable_count == 4:
+        removable_pile[removable_pile.index(min(removable_pile))] = 0
+        removable_count = removable_count - 1
+
+
+    qft_gate = custom_qft(3).to_gate()
+    inverse_qft_gate = custom_qft(3).inverse().to_gate()
+
+    if removable_count == 1:
+        qc.swap(objects_to_remove[0],objects_to_remove[2])
+        qc.append(qft_gate,objects_to_remove[:])
+        # 0001 -> 001
+        if removable_pile[0] != 0:
+            add_gate = subroutine_add_const(3,removable_pile[0])
+            qc.x(address[0])
+        # 0010 -> 010
+        elif removable_pile[1] != 0:
+            add_gate = subroutine_add_const(3,removable_pile[1])
+            qc.x(address[1])
+        # 0100 -> 011
+        elif removable_pile[2] != 0:
+            add_gate = subroutine_add_const(3,removable_pile[2])
+            qc.x(address[0])
+            qc.x(address[1])
+        # 1000 -> 100
+        elif removable_pile[3] != 0:
+            add_gate = subroutine_add_const(3,removable_pile[3])
+            qc.x(address[2])
+
+        qc.append(add_gate,objects_to_remove[:])
+        qc.append(inverse_qft_gate,objects_to_remove[:])
+        qc.swap(objects_to_remove[0],objects_to_remove[2])
+
+    else:
+        diffusion_operation(qc,address, flag, removable_pile)
+        qc.swap(objects_to_remove[0],objects_to_remove[2])
+        qc.append(qft_gate,objects_to_remove[:])
+        for i,remove_amount in enumerate(removable_pile):
+            if remove_amount != 0:
+
+                bin_i = list(bin(i+1)[2:])
+                while len(bin_i) != 3:
+                    bin_i.insert(0,'0')
+                bin_i = bin_i[::-1]
+                for j in range(len(bin_i)):
+                    if bin_i[j] == '0':
+                        qc.x(address[j])
+
+                controlled_add_gate = subroutine_add_const(3,remove_amount).control(3)    
+                qc.append(controlled_add_gate,address[:]+objects_to_remove[:])
+
+                for j in range(len(bin_i)):
+                    if bin_i[j] == '0':
+                        qc.x(address[j])
+
+        qc.append(inverse_qft_gate,objects_to_remove[:])
+        qc.swap(objects_to_remove[0],objects_to_remove[2])
+
+def get_quantum_move(piles, backend=None):
+
+    # REMOVE MISERE STEP
+    # ones = piles.count(1)
+    # zeros = piles.count(0)
+    # non_zeros = 4 - (ones+zeros)
+
+    # # all zeros except one eg (0,0,0,7) OR some zeros some ones some non_zeros
+    # # leave odd piles of 1s
+    # if non_zeros == 1: 
+    #     removable_pile, removable_count = misere_step(ones, piles) 
+    # else:
+    #     removable_pile, removable_count = get_piles_to_remove(piles)
+
+
+    removable_pile, removable_count = get_piles_to_remove(piles)
+    objects_to_remove = QuantumRegister(3,'piles')
+    flag = QuantumRegister(1,'flag')
+    output_piles = ClassicalRegister(3,'final_piles')
+    address = QuantumRegister(3,'address')
+    pick_pile = ClassicalRegister(3,'choose_pile')
+    qc = QuantumCircuit(objects_to_remove,address,flag,output_piles,pick_pile)
+    qc_process(qc,objects_to_remove,address,flag,piles,removable_pile,removable_count)
+
+    qc.measure(address[:],pick_pile[:])
+    qc.measure(objects_to_remove[:],output_piles[:])
+    
+    if backend == None:
+        backend = BasicAer.get_backend('qasm_simulator')
+        # backend = provider.backends.ibmq_qasm_simulator
+    job = execute(qc,backend,shots=500)
+    result = job.result()
+    counts = result.get_counts()
+
+    try:
+        qc_move = (counts.most_frequent())    
+    except Exception as e:
+        print(e)
+        vals = list(dict(counts).values())
+        max_count = max(vals,key=vals.count)
+        for key in counts:
+            if counts[key] == max_count:
+                qc_move = key
+                break
+    
+    board_choice = qc_move.split(' ')[0]
+    board_choice = int(board_choice,2) - 1
+
+    print("Pick from:",board_choice+1)
+
+    board_state = qc_move.split(' ')[1]
+    board_state = board_state[::-1]
+    amount = int(board_state,2)
+    print("Amount:", amount)
+    return board_choice,amount
+
+
+
+
+
+
+
+

requirements.txt

@@ -0,0 +1,7 @@
+openai
+gradio
+numpy
+langchain
+gymnasium
+qiskit
+inflect