How to use the cirq.LineQubit.range function in cirq

def _generate_qubits(self) -> Sequence[cirq.Qid]:
        return cirq.LineQubit.range(2)

def main():
    print("Length 10 line on Bristlecone:")
    line = cirq.google.line_on_device(cirq.google.Bristlecone, length=10)
    print(line)

    print("Initial circuit:")
    n = 10
    depth = 2
    circuit = cirq.Circuit.from_ops(
        cirq.SWAP(cirq.LineQubit(j), cirq.LineQubit(j + 1))
        for i in range(depth)
        for j in range(i % 2, n - 1, 2)
    )
    circuit.append(cirq.measure(*cirq.LineQubit.range(n), key='all'))
    print(circuit)

    print()
    print("Xmon circuit:")
    translated = cirq.google.optimized_for_xmon(
        circuit=circuit,
        new_device=cirq.google.Bristlecone,
        qubit_map=lambda q: line[q.x])
    print(translated)

# Print it to the console
print("Unitary:")
print(unitary)

# Diagonalize it classically
evals, evecs = np.linalg.eig(unitary)

# =============================================================================
# Building the circuit for QPE
# =============================================================================

# Number of qubits in the readout/answer register (# bits of precision)
n = 8

# Readout register
regA = cirq.LineQubit.range(n)

# Register for the eigenstate
regB = cirq.LineQubit.range(n, n + m)

# Get a circuit
circ = cirq.Circuit()

# Hadamard all qubits in the readout register
circ.append(cirq.H.on_each(regA))

# Hadamard all qubits in the second register
#circ.append(cirq.H.on_each(regB))

# Get a Cirq gate for the unitary matrix
ugate = cirq.ops.matrix_gates.TwoQubitMatrixGate(unitary)

def make_quantum_teleportation_circuit(ranX, ranY):
    """Returns a quantum teleportation circuit."""
    circuit = cirq.Circuit()
    msg, alice, bob = cirq.LineQubit.range(3)

    # Creates Bell state to be shared between Alice and Bob
    circuit.append([cirq.H(alice), cirq.CNOT(alice, bob)])

    # Creates a random state for the Message
    circuit.append([cirq.X(msg)**ranX, cirq.Y(msg)**ranY])

    # Bell measurement of the Message and Alice's entangled qubit
    circuit.append([cirq.CNOT(msg, alice), cirq.H(msg)])
    circuit.append(cirq.measure(msg, alice))

    # Uses the two classical bits from the Bell measurement to recover the
    # original quantum Message on Bob's entangled qubit
    circuit.append([cirq.CNOT(alice, bob), cirq.CZ(msg, bob)])

    return msg, circuit

Returns:
        A circuit implementing a single round of QAOA with the specified
        angles.

    """

    assert all(set(edge) <= set(vertices) for edge in edges)
    assert all(len(edge) == 2 for edge in edges)
    n_vertices = len(vertices)

    # G_{i,j} ∝ exp(i gamma (|01><01| + |10><10|))
    phase_sep_gates = {edge: cirq.ZZ**gamma for edge in edges
                      }  # type: LogicalMapping

    # Physical qubits
    qubits = cirq.LineQubit.range(n_vertices)

    # Mapping from qubits to vertices.
    initial_mapping = {q: i for i, q in enumerate(qubits)
                      }  # type: LogicalMapping

    if use_logical_qubits:
        initial_mapping = {
            q: cirq.LineQubit(i) for q, i in initial_mapping.items()
        }
        phase_sep_gates = {
            tuple(cirq.LineQubit(i)
                  for i in e): g
            for e, g in phase_sep_gates.items()
        }

    phase_sep_circuit = get_phase_sep_circuit(phase_sep_gates, qubits,

# Diagonalize it classically
evals, _ = np.linalg.eig(unitary)

# =============================================================================
# Building the circuit for QPE
# =============================================================================

# Number of qubits in the readout/answer register (# bits of precision)
n = 2

# Readout register
regA = cirq.LineQubit.range(n)

# Register for the eigenstate
regB = cirq.LineQubit.range(n, n + m)

# Get a circuit
circ = cirq.Circuit()

# Hadamard all qubits in the readout register
circ.append(cirq.H.on_each(regA))

# Get a Cirq gate for the unitary matrix
ugate = cirq.ops.matrix_gates.TwoQubitMatrixGate(unitary)

# Controlled version of the gate
cugate = cirq.ops.ControlledGate(ugate)

# Do the controlled U^{2^k} operations
for k in range(n):
    circ.append(cugate(regA[k], *regB)**(2**k))

"""Measures the QAOA circuit in the computational basis to get bit strings."""
    circ = qaoa(gammas, betas)
    circ.append(cirq.measure(*[qubit for row in qreg for qubit in row], key='m'))
    
    # Simulate the circuit
    sim = cirq.Simulator()
    res = sim.run(circ, repetitions=nreps)
    
    return res

if __name__ == "__main__":
    # =================================================
    # Make sure the ZZ circuit gives the correct matrix
    # =================================================
    
    qreg = cirq.LineQubit.range(2)
    zzcirc = ZZ(qreg[0], qreg[1], 0.5)
    print("Circuit for ZZ gate:", zzcirc, sep="\n")
    print("\nUnitary of circuit:", zzcirc.to_unitary_matrix().round(2), sep="\n")
    
    # ==========================
    # Grid of qubits for problem
    # ==========================
    
    ncols = 3
    nrows = 3
    nsites = nrows * ncols
    qreg = [[cirq.GridQubit(i,j) for j in range(ncols)] for i in range(nrows)]
    
    # =======================================
    # Do a grid search over many param values
    # =======================================

def main(repetitions=1000, maxiter=50):
    # Set problem parameters
    n = 6
    p = 2

    # Generate a random 3-regular graph on n nodes
    graph = networkx.random_regular_graph(3, n)

    # Make qubits
    qubits = cirq.LineQubit.range(n)

    # Print an example circuit
    betas = np.random.uniform(-np.pi, np.pi, size=p)
    gammas = np.random.uniform(-np.pi, np.pi, size=p)
    circuit = qaoa_max_cut_circuit(qubits, betas, gammas, graph)
    print('Example QAOA circuit:')
    print(circuit.to_text_diagram(transpose=True))

    # Create variables to store the largest cut and cut value found
    largest_cut_found = None
    largest_cut_value_found = 0

    # Initialize simulator
    simulator = cirq.Simulator()

    # Define objective function (we'll use the negative expected cut value)

def make_quantum_teleportation_circuit(ranX, ranY):
    circuit = cirq.Circuit()
    msg, alice, bob = cirq.LineQubit.range(3)

    # Creates Bell state to be shared between Alice and Bob
    circuit.append([cirq.H(alice), cirq.CNOT(alice, bob)])
    # Creates a random state for the Message
    circuit.append([cirq.X(msg)**ranX, cirq.Y(msg)**ranY])
    # Bell measurement of the Message and Alice's entangled qubit
    circuit.append([cirq.CNOT(msg, alice), cirq.H(msg)])
    circuit.append(cirq.measure(msg, alice))
    # Uses the two classical bits from the Bell measurement to recover the
    # original quantum Message on Bob's entangled qubit
    circuit.append([cirq.CNOT(alice, bob), cirq.CZ(msg, bob)])

    return circuit