Не работает программа предназначенная для использования квантового алгоритма Гровера в цифровых сигналах на Python

Написал программу для модуляции цифрового сигнала и последующей демодуляции с использованием квантового алгоритма Гровера. Программа работает, но результатов нет и я не могу понять, что нужно сделать

import tkinter as tk
from tkinter import messagebox
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, 
transpile
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram


   class ModulationApp(tk.Tk):
       def __init__(self):
           super().__init__()
           self.title("Модуляция")
           self.geometry("500x300")

           self.input_label = tk.Label(self, text="Введите цифровой сигнал (0 и 1):")
           self.input_entry = tk.Entry(self)
           self.process_button = tk.Button(self, text="Начать обработку", command=self.start_processing)

           self.input_label.pack(pady=10)
           self.input_entry.pack(pady=10)
           self.process_button.pack(pady=10)

def start_processing(self):
    try:
        digital_signal = self.validate_input(self.input_entry.get())
        self.run_modulation(digital_signal)
    except ValueError as e:
        messagebox.showerror("Ошибка ввода", str(e))

def validate_input(self, input_str):
    """Проверяет ввод пользователя на корректность."""
    if not all(char in '01' for char in input_str):
        raise ValueError("Пожалуйста, введите последовательность из 0 и 1.")
    return list(map(int, input_str))

def run_modulation(self, digital_signal):
    sampling_rate = 1000  # Частота дискретизации
    carrier_freq = 50  # Частота несущего сигнала
    signal_freq = 10  # Частота информационного сигнала
    time = np.arange(0, 1, 1 / sampling_rate)  # Время

    # Преобразование цифрового сигнала в аналоговый
    analog_info_signal = np.repeat(digital_signal, len(time) // len(digital_signal)) * np.sin(
        2 * np.pi * signal_freq * time)

    # Генерация несущего сигнала
    carrier_signal = np.sin(2 * np.pi * carrier_freq * time)

    # Амплитудная модуляция
    modulated_signal = analog_info_signal * carrier_signal

    # Добавление шума
    noise = np.random.normal(0, 0.05, len(modulated_signal))
    noisy_modulated_signal = modulated_signal + noise

    # Квантовая часть
    n_qubits = int(np.log2(len(digital_signal))) + 1  # добавляем еще один кубит для оракула
    qr = QuantumRegister(n_qubits)
    cr = ClassicalRegister(n_qubits - 1)
    circuit = QuantumCircuit(qr, cr)

    # Решение, которое мы ищем (например, последнее состояние)
    solution_state = format((1 << (n_qubits - 1)) - 1, f'0{(n_qubits - 1)}b')  # Это будет строка вида "111...1"

    # Запускаем алгоритм Гровера
    self.run_grovers_algorithm(circuit, lambda c: self.oracle_for_demodulation(c, solution_state), 1)

    # Выполняем схему на симуляторе
    simulator = AerSimulator()
    circuit_transpiled = transpile(circuit, backend=simulator)
    job = simulator.run(circuit_transpiled)
    result = job.result()
    counts = result.get_counts()

    # Визуализируем результат
    plot_histogram(counts)

    # Визуализация сигналов
    plt.figure(figsize=(12, 8))
    plt.subplot(511)
    plt.step(np.linspace(0, 1, len(digital_signal)), digital_signal, where='post',
             label='Цифровой входной сигнал')
    plt.legend()
    plt.title('Цифровой входной сигнал')

    plt.subplot(512)
    plt.plot(time, analog_info_signal, label='Аналоговый информационный сигнал')
    plt.legend()
    plt.title('Аналоговый информационный сигнал')

    plt.subplot(513)
    plt.plot(time, modulated_signal, label='Модулированный сигнал')
    plt.legend()
    plt.title('Модулированный сигнал')

    plt.subplot(514)
    plt.plot(time, noisy_modulated_signal, label='Шумный модулированный сигнал')
    plt.legend()
    plt.title('Шумный модулированный сигнал')

    plt.tight_layout()

    # Вместо plt.show():
    plt.draw()
    

def run_grovers_algorithm(self, circuit, oracle, iterations):
    """Запускает алгоритм Гровера для нахождения решения."""
    n_qubits = circuit.num_qubits
    # Начальная подготовка всех кубитов к суперпозиции состояний
    circuit.h(range(n_qubits))

    # Цикл для выполнения итераций алгоритма Гровера
    for _ in range(iterations):
        # Применение оракула
        oracle(circuit)

        # Инверсия относительно среднего значения
        self.grovers_diffusion_operator(circuit, n_qubits)

    # Измеряем все кубиты
    circuit.measure(range(n_qubits - 1), range(n_qubits - 1))

def grovers_diffusion_operator(self, circuit, n_qubits):
    """Реализация оператора диффузии для алгоритма Гровера."""
    circuit.h(range(n_qubits))
    circuit.x(range(n_qubits))

    # Применяем mcx ко всем кубитам, кроме последнего
    circuit.mcx(list(range(n_qubits - 1)), n_qubits - 1)

    circuit.x(range(n_qubits))
    circuit.h(range(n_qubits))

def oracle_for_demodulation(self, circuit, solution_state):
    """Оракул для отметки конкретного состояния."""
    n_qubits = circuit.num_qubits

    # Переводим решение в целое число
    target_value = int(solution_state, 2)

    # Применяем операцию CNOT для каждого кубита, который равен 1 в решении
    for i in range(n_qubits - 1):
        if solution_state[i] == '1':
            circuit.cx(i, n_qubits - 1)

    # Применяем NOT ко всем вспомогательным кубитам
    circuit.x(n_qubits - 1)

    # Применяем многоразрядную операцию NOT
    circuit.mcx(list(range(n_qubits - 1)), n_qubits - 1)

    # Возвращаемся обратно
    circuit.x(n_qubits - 1)

    # Отменяем CNOT операции
    for i in range(n_qubits - 1):
        if solution_state[i] == '1':
            circuit.cx(i, n_qubits - 1)


  if __name__ == "__main__":
      app = ModulationApp()
      app.mainloop()