Quantum Algorithm

Quantum Algorithm Practice

from spinqlablink import SpinQLabLink, ExperimentType, Gate, Circuit
from spinqlablink import print_graph

def main():
    # Create connection
    spinqlablink = SpinQLabLink("192.168.15.4", 8181, "anyword", "anyword")
    spinqlablink.connect()

    if not spinqlablink.wait_for_login():
        print("Login failed")
        return

    # Register a quantum algorithm experiment
    _, exp_algorithm_para = spinqlablink.register_experiment(ExperimentType.QUANTUM_ALGORITHM)

    # Available quantum algorithm types:
    # - INTRODUCTION_TO_QUANTUM_COMPUTING: Basic introduction to quantum computing concepts
    # - DEUTSCH_ALGORITHM: Demonstrates quantum parallelism with a single function evaluation
    # - BERNSTEIN_VARIRANI_ALGORITHM: Finds a hidden bit string with a single query
    # - GROVER_ALGORITHM: Searches an unstructured database with quadratic speedup
    # - QFT_ALGORITHM: Quantum Fourier Transform, the foundation for many quantum algorithms
    # - HHL_ALGORITHM: Harrow-Hassidim-Lloyd algorithm for solving linear systems
    # - VQE_ALGORITHM: Variational Quantum Eigensolver for chemistry problems
    # - QAOA_ALGORITHM: Quantum Approximate Optimization Algorithm for combinatorial problems

    # Select the algorithm type to run
    exp_algorithm_para.algorithm_type = ExperimentType.INTRODUCTION_TO_QUANTUM_COMPUTING

    # Set the sampling path: -1 for all channels, 0 for hydrogen channel, 1 for phosphorus channel
    exp_algorithm_para.samplePath = -1

    # Special parameters for specific algorithms
    if exp_algorithm_para.algorithm_type == ExperimentType.GROVER_ALGORITHM:
        # For Grover's algorithm, specify which element to mark as the search target
        # 0 = |00⟩, 1 = |01⟩, 2 = |10⟩, 3 = |11⟩
        exp_algorithm_para.grover_bin = 2

    # Create a quantum circuit for the algorithm
    # This example creates a Bell state circuit: |00⟩ → (|00⟩ + |11⟩)/√2
    circuit = Circuit(2)
    circuit << Gate(type='H', qubitIndex=0)  # Apply Hadamard to first qubit
    circuit << Gate(type='CNOT', qubitIndex=1, controlQubit=0)  # CNOT with control=qubit 0, target=qubit 1

    # Print the circuit structure to console
    circuit.print_circuit()

    # Set the circuit for the experiment
    exp_algorithm_para.set_circuit(circuit)

    # Run the experiment
    spinqlablink.run_experiment()
    print("Waiting for experiment completion")
    spinqlablink.wait_for_experiment_completion()

    # Get the experiment results
    exp_info = spinqlablink.get_experiment_result()

    # Clean up and disconnect
    spinqlablink.deregister_experiment()
    spinqlablink.disconnect()

    # Process and display the results
    if "result" in exp_info:
        exp_result = exp_info["result"]
        for key, value in exp_result.items():
            if key != "graph":
                print(f"{key}: {value}")

        print_graph(exp_info["result"])
    else:
        print("Experiment failed")

if __name__ == "__main__":
    main()

Experimental Parameters Analysis

• ExperimentType: Experiment type, set the experiment type (for details, see:class:spinqlablink.ExperimentType class)

• algorithm_type: Algorithm Type

• grover_bin: In the Grover algorithm, specify elements to be marked as search targets should be specifically specified, 0 = |00>, 1 = |01>, 2 = |10>, 3 = |11>[0,1,2,3]

  attribute	described
  INTRODUCTION_TO_QUANTUM_COMPUTING	Basic Experiments of Quantum Computing
  DEUTSCH_ALGORITHM	Deutsch algorithm experiment
  BERNSTEIN_VARIRANI_ALGORITHM	Bernstein-Vazirani algorithm experiment
  GROVER_ALGORITHM	Grover algorithm experiment
  QFT_ALGORITHM	QFT algorithm experiment
  HHL_ALGORITHM	HHL algorithm experiment
  VQE_ALGORITHM	VQE algorithm experiment
  QAOA_ALGORITHM	QAOA algorithm experiment

• Gate: Defines the quantum gate operation, specifies the gate type and the qubit used (see:class:spinqlablink.Gate class for details)

• Circuit: Build a quantum circuit and add quantum gate operations (see:class:spinqlablink.Circuit class for details)

• samplePath: Sampling path,-1= all channels, 0= hydrogen channel, 1= phosphorus channel [-1,0,1]

Analysis of experimental results

{
    "result":{
        "graph":[
            { # step 0
                "fidRe": [[x,y],...],
                "fidIm":[[x,y],...],
                "fftRe":[[x,y],...],
                "fftIm":[[x,y],...],
                "lorenz":[[x,y],...],
                "fftMod":[[x,y],...]
            }
        ],
        "matrix": {  # Quantum state density matrix, containing real and imaginary parts
            "real": [[0.25, 0.25, 0.25, 0.25], [0.25, 0.25, 0.25, 0.25], [0.25, 0.25, 0.25, 0.25], [0.25, 0.25, 0.25, 0.25]],
            "imag": [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
        },
        "probability": [0.25, 0.25, 0.25, 0.25],  # Probability distribution of measurement results
    }
}

• graph: Chart data, including experimental steps

• matrix: Density Matrix of the quantum state, including Real and Imaginary components

• probability: Probability Distribution of measurement results