Copy
!pip install tensornetwork

Copy
import numpy as np
import tensornetwork as tn

a = tn.Node(np.ones((10,))) 
b = tn.Node(np.ones((10,)))

Copy
edge = a[0] ^ b[0]

Copy
final_node = tn.contract(edge)
print(final_node.tensor)

Copy
a = tn.Node(np.ones((5))) 
b = tn.Node(np.ones((5,5)))
edge = a[0] ^ b[0]
final_node = tn.contract(edge)
print(final_node.tensor)

Copy
a = tn.Node(np.ones((5,3))) 
b = tn.Node(np.ones((5,2)))
edge = a[0] ^ b[0]
final_node = tn.contract(edge)
print(final_node.tensor)

Copy
!pip install quimb

Copy
#%config InlineBackend.figure_formats = ['svg']
import quimb as qu
import quimb.tensor as qtn

from collections import Counter

Copy
#number of qubits
N = 80

#initialization of circuit
circ = qtn.Circuit(N)

#apply Hgate to the first qubit
circ.h(0)

# making GHZ using CX chain
for i in range(N-1):
  circ.cx(i, i+1)

# get sampling from quantum state
Counter(circ.sample(1))

Copy
%%time

# get 100samples
Counter(circ.sample(100))

Copy
circ = qtn.Circuit(10)

for i in range(10):
  circ.apply_gate('H', i, gate_round=0)

for r in range(1, 9):
  # even pairs
  for i in range(0, 10, 2):
    circ.apply_gate('CNOT', i, i + 1, gate_round=r)
  # Y-rotations
  for i in range(10):
    circ.apply_gate('RZ', 1.234, i, gate_round=r)
  # odd pairs
  for i in range(1, 9, 2):
    circ.apply_gate('CZ', i, i + 1, gate_round=r)
  # X-rotations
  for i in range(10):
    circ.apply_gate('RX', 1.234, i, gate_round=r)

# h gate
for i in range(10):
  circ.apply_gate('H', i, gate_round=r + 1)
circ

Copy
circ.psi.draw(color=['PSI0', 'H', 'CNOT', 'RZ', 'RX', 'CZ'])

Copy
circ.to_dense()

Copy
circ.amplitude('0000011111')

Copy
circ.local_expectation(qu.pauli('X') & qu.pauli('Z'), (4, 5))

Copy
for item in circ.sample(1):
    print(item)

Copy
!pip install tensorflow

Copy
import tensorflow as tf
import tensornetwork as tn
import matplotlib.pyplot as plt

tn.set_default_backend("tensorflow")

Copy
class TNLayer(tf.keras.layers.Layer):
 
  def __init__(self):
    super(TNLayer, self).__init__()
    # Create the variables for the layer.
    self.a_var = tf.Variable(tf.random.normal(
            shape=(32, 32, 2), stddev=1.0/32.0),
             name="a", trainable=True)
    self.b_var = tf.Variable(tf.random.normal(shape=(32, 32, 2), stddev=1.0/32.0),
                             name="b", trainable=True)
    self.bias = tf.Variable(tf.zeros(shape=(32, 32)), name="bias", trainable=True)
 
  def call(self, inputs):
    # Define the contraction.
    # We break it out so we can parallelize a batch using
    # tf.vectorized_map (see below).
    def f(input_vec, a_var, b_var, bias_var):
      # Reshape to a matrix instead of a vector.
      input_vec = tf.reshape(input_vec, (32,32))
 
      # Now we create the network.
      a = tn.Node(a_var, backend="tensorflow")
      b = tn.Node(b_var, backend="tensorflow")
      x_node = tn.Node(input_vec, backend="tensorflow")
      a[1] ^ x_node[0]
      b[1] ^ x_node[1]
      a[2] ^ b[2]
 
      # The TN should now look like this
      #   |     |
      #   a --- b
      #    \   /
      #      x
 
      # Now we begin the contraction.
      c = a @ x_node
      result = (c @ b).tensor
 
      # To make the code shorter, we also could've used Ncon.
      # The above few lines of code is the same as this:
      # result = tn.ncon([x, a_var, b_var], [[1, 2], [-1, 1, 3], [-2, 2, 3]])
 
      # Finally, add bias.
      return result + bias_var
  
    # To deal with a batch of items, we can use the tf.vectorized_map
    # function.
    # https://www.tensorflow.org/api_docs/python/tf/vectorized_map
    result = tf.vectorized_map(
        lambda vec: f(vec, self.a_var, self.b_var, self.bias), inputs)
    return tf.nn.relu(tf.reshape(result, (-1, 1024)))

Copy
Dense = tf.keras.layers.Dense
fc_model = tf.keras.Sequential(
    [
     tf.keras.Input(shape=(2,)),
     Dense(1024, activation=tf.nn.swish),
     Dense(1024, activation=tf.nn.swish),
     Dense(1, activation=None)])
fc_model.summary()

Copy
tn_model = tf.keras.Sequential(
  [
    tf.keras.Input(shape=(2,)),
    Dense(1024, activation=tf.nn.relu),
    # Here use a TN layer instead of the dense layer.
    TNLayer(),
    Dense(1, activation=None)
  ]
)
tn_model.summary()

Copy
X = np.concatenate([np.random.randn(20, 2) + np.array([3, 3]), 
             np.random.randn(20, 2) + np.array([-3, -3]), 
             np.random.randn(20, 2) + np.array([-3, 3]), 
             np.random.randn(20, 2) + np.array([3, -3]),])

Y = np.concatenate([np.ones((40)), -np.ones((40))])

Copy
fc_model.compile(optimizer="adam", loss="mean_squared_error")
fc_model.fit(X, Y, epochs=300, verbose=1)

Copy
tn_model.compile(optimizer="adam", loss="mean_squared_error")
tn_model.fit(X, Y, epochs=300, verbose=1)

Copy
h = 1.0
x_min, x_max = X[:, 0].min() - 5, X[:, 0].max() + 5
y_min, y_max = X[:, 1].min() - 5, X[:, 1].max() + 5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

# here "model" is your model's prediction (classification) function
Z = fc_model.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z)
plt.axis('off')

# Plot also the training points
plt.scatter(X[:, 0], X[:, 1], c=Y, cmap=plt.cm.Paired)

Copy
h = 1.0
x_min, x_max = X[:, 0].min() - 5, X[:, 0].max() + 5
y_min, y_max = X[:, 1].min() - 5, X[:, 1].max() + 5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

# here "model" is your model's prediction (classification) function
Z = tn_model.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z)
plt.axis('off')

# Plot also the training points
plt.scatter(X[:, 0], X[:, 1], c=Y, cmap=plt.cm.Paired)

Copy
!pip install torch

Copy
import matplotlib.pyplot as plt
import torch.optim as optim
import torch
import numpy as np
%matplotlib inline

#qubit
x = torch.tensor([1., 0.])

#variational parameter
a = torch.tensor([0.2], requires_grad=True)

#list for result
arr = []

#the first variable is list of paramters.
op = optim.Adam([a],lr=0.05)
for _ in range(100):
    y = [[torch.cos(a/2),-torch.sin(a/2)], [torch.sin(a/2),torch.cos(a/2)]]
    z = [x[0]*y[0][0]+x[1]*y[0][1], x[0]*y[1][0]+x[1]*y[1][1]]
    expt = torch.abs(z[0])**2 - torch.abs(z[1])**2

    arr.append(expt.item())  # Add the item to the arr list

    op.zero_grad()
    expt.backward()
    op.step()

plt.plot(arr)
plt.show()

Copy
import itertools

import cupy as cp
import numpy as np
import qiskit
from qiskit.circuit.random import random_circuit

from cuquantum import contract
from cuquantum import CircuitToEinsum

Copy
num_qubits = 7
depth = 6

circuit = random_circuit(num_qubits, depth, seed=3)
circuit.draw(output='mpl')

Copy
myconverter = CircuitToEinsum(circuit, dtype='complex128', backend=cp)

Copy
expression, operands = myconverter.state_vector()
sv = contract(expression, *operands)
print(f'wavefunction coefficient shape: {sv.shape}')
print(type(operands[0]))
print(type(sv))

Copy
bitstring = '0000000'

expression, operands = myconverter.amplitude(bitstring)
print(f'einsum expression:\n{expression} \n')

amplitude = contract(expression, *operands)
probability = abs(amplitude) ** 2
print(f'for bitstring {bitstring}, amplitude: {amplitude}, probability: {probability}\n')

amplitude_from_sv = sv[0,0,0,0,0,0,0]
amp_diff = abs(amplitude-amplitude_from_sv)
print(f'difference from state vector {amp_diff}')

Copy
pauli_string = 'IXXZZII'
expression, operands = myconverter.expectation(pauli_string, lightcone=True)
expec = contract(expression, *operands)
print(f'expectation value for {pauli_string}: {expec}')

# expectation value from reduced density matrix
qubits = myconverter.qubits
where = qubits[1:5]
rdm_expression, rdm_operands = myconverter.reduced_density_matrix(where, lightcone=True)
rdm = contract(rdm_expression, *rdm_operands)

pauli_x = cp.asarray([[0,1],[1,0]], dtype=myconverter.dtype)
pauli_z = cp.asarray([[1,0],[0,-1]], dtype=myconverter.dtype)
expec_from_rdm = cp.einsum('abcdABCD,aA,bB,cC,dD->', rdm, pauli_x, pauli_x, pauli_z, pauli_z)

print(f"is expectation value in agreement?", cp.allclose(expec, expec_from_rdm))