В общем, пробовал Azure и пробовал Google notebook. Azure не дает даже симулятор, только подсчет стоимости. У Гугла не работают даже их же примеры — на этапе подготовки пакетов ошибка версий.

Заработало у Amazon AWS. Код на Python.

Вроде пока читал — мистика мистикой. Как потыкал — то чуть проясняется, но еще не все прояснилось.

# general imports
import matplotlib.pyplot as plt
%matplotlib inline

# AWS imports: Import Braket SDK modules
from braket.circuits import Circuit
from braket.devices import LocalSimulator

def deutsch_oracle(f_type):
    """Create an oracle based on the function type."""
    oracle = Circuit()
    if f_type == "constant_0":
        pass  # Do nothing for f(x) = 0
    elif f_type == "constant_1":
        oracle.x(1)
    elif f_type == "balanced_identity":
        oracle.cnot(0, 1)
    elif f_type == "balanced_invert":
        oracle.x(1).cnot(0, 1)
    else:
        raise ValueError("Unknown function type")
    return oracle

def deutsch_algorithm(oracle):
    """Construct the Deutsch algorithm circuit."""
    circuit = Circuit()
    circuit.x(1).h(0).h(1)  # Initial state preparation
    circuit.add_circuit(oracle)  # Add the oracle
    circuit.h(0)  # Apply Hadamard to the first qubit
    return circuit

# Choose your function type from: constant_0, constant_1, balanced_identity, balanced_invert
f_type = "balanced_identity"
oracle = deutsch_oracle(f_type)
deutsch_circuit = deutsch_algorithm(oracle)
print(deutsch_circuit)

# Set up device
device = LocalSimulator()

# Run the circuit
result = device.run(deutsch_circuit, shots=1).result()
counts = result.measurement_counts
print(counts)

Тут есть функция deutsch_oracle, которая в зависимости от передаваемого значения f_type (можно передать строку "constant_0", "constant_1", "balanced_identity", "balanced_invert") по-разному себя ведет. Либо применяет операцию if на основе значения 0-го бита к 1-му, либо не применяет.

Тут задействовано 2 бита — 0 и 1. 1 бит — это результат работы функции. Результат либо основан на значении 0 бита либо ни на чем не основан. Вот это якобы и можно определить с помощью квантовых операций за 1 вызов вместо двух.

pass — ничего не меняет.
x(1) — инвертирует таки 1 бит.
oracle.cnot(0, 1) — на основе 0 бита переворачиваем или нет значение 1 бита.
oracle.x(1).cnot(0, 1) — инвертирует 1 бит и потом переворачиваем его на основе 0 бита.

Далее. Сами квантовые фишки.

circuit.x(1).h(0).h(1) — кубит 1 устанавливаем в 1 (инвертируем, изначально было 0), затем независимо (не спутанно) кубит 0 и 1 переводим в суперпозицию, мать ее. Но знак этой суперпозиции будет разный, т.к. если изначально было 1 — то как бы с отрицательным знаком берем, епта.

circuit.add_circuit(oracle) — туточки к нашим кубитам применяем операции из функции deutsch_oracle. Смотря как инициализировали эту функцию. Либо значение 1 кубита будет зависеть от 0-го кубита либо нет.

circuit.h(0) — тут опять суперпозицию 0 кубит.

И оно по итогу дает результат — какой тип функции применен.

С одной стороны вроде чудо, с другой стороны надувательство. Еще думаю над этим, нужно с этой мыслью переспать.

Ваши идеи?