TensorNode.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef __TENSOR_NODE_H_
#define __TENSOR_NODE_H_ 1
 
#include "../Types.h"
#include "../Utils/Tensors/Tensor.h"
#include "Factory.h"
#include <Eigen/Eigen>
#include <memory>
 
namespace TensorNetworks
{
 
class TensorNode
{
  public:
    using Index = Eigen::Index;
    using MatrixClass = Eigen::MatrixXcd;
 
    void SetGate(const QC::Gates::QuantumGateWithOp<MatrixClass> &gate, Types::qubit_t q1, Types::qubit_t q2 = 0)
    {
        const size_t qubitsNumber = gate.getQubitsNumber();
 
        Clear();
 
        if (qubitsNumber > 2)
            throw std::invalid_argument("The gate has more than 2 qubits. Decompose gates on a higher number "
                                        "of qubits in gates on 1 and 2 qubits only.");
 
        qubits.push_back(q1);
 
        if (qubitsNumber > 1)
            qubits.push_back(q2);
 
        qubits.push_back(q1);
        if (qubitsNumber > 1)
            qubits.push_back(q2);
 
        tensor = Factory::CreateTensorFromGate(gate);
 
        connections.resize(qubitsNumber * 2, NotConnected);
        connectionsIndices.resize(qubitsNumber * 2, NotConnected);
    }
 
    void SetQubit(Types::qubit_t q, bool zero = true)
    {
        Clear();
 
        qubits.push_back(q);
 
        if (zero)
            tensor = Factory::CreateQubit0Tensor();
        else
            tensor = Factory::CreateQubit1Tensor();
 
        connections.push_back(NotConnected);
        connectionsIndices.push_back(NotConnected);
    }
 
    void SetProjector(Types::qubit_t q, bool zero = true)
    {
        Clear();
 
        qubits.push_back(q);
        qubits.push_back(q);
 
        tensor = Factory::CreateProjectionTensor(zero);
 
        connections.resize(2, NotConnected);
        connectionsIndices.resize(2, NotConnected);
    }
 
    void SetSuper()
    {
        if (tensor)
            tensor->Conj();
    }
 
    void SetId(Index Id)
    {
        id = Id;
    }
 
    Index GetId() const
    {
        return id;
    }
 
    size_t GetQubitsNumber() const
    {
        return qubits.size();
    }
 
    size_t GetRank() const
    {
        if (!tensor)
            return 0;
 
        return tensor->GetRank();
    }
 
    void Clear()
    {
        id = 0;
 
        tensor.reset();
        qubits.clear();
        connections.clear();
        connectionsIndices.clear();
    }
 
    // this is needed for tensor contraction, since connections are modified in
    // the process
    std::shared_ptr<TensorNode> CloneWithoutTensorCopy() const
    {
        auto cloned = std::make_shared<TensorNode>();
        cloned->id = id;
        cloned->qubits = qubits;
        cloned->connections = connections;
        cloned->connectionsIndices = connectionsIndices;
        cloned->tensor = tensor;
 
        // cloned->contractsTheNeededQubit = contractsTheNeededQubit;
 
        return cloned;
    }
 
    // Useful for contracting the tensor network without actually contracting the
    // tensors can be used in algorithms that find an (sub)optimal contraction
    // order
    std::shared_ptr<TensorNode> CloneWithADummyTensor() const
    {
        auto cloned = std::make_shared<TensorNode>();
        cloned->id = id;
        cloned->qubits = qubits;
        cloned->connections = connections;
        cloned->connectionsIndices = connectionsIndices;
        cloned->tensor = std::make_shared<Utils::Tensor<>>(tensor->GetDims(), true);
 
        // cloned->contractsTheNeededQubit = contractsTheNeededQubit;
 
        return cloned;
    }
 
    std::shared_ptr<TensorNode> Clone() const
    {
        auto cloned = std::make_shared<TensorNode>();
        cloned->id = id;
        cloned->qubits = qubits;
        cloned->connections = connections;
        cloned->connectionsIndices = connectionsIndices;
        cloned->tensor = std::make_shared<Utils::Tensor<>>(*tensor);
 
        // cloned->contractsTheNeededQubit = contractsTheNeededQubit;
 
        return cloned;
    }
 
    constexpr static Index NotConnected = -1;
 
    Index id = 0;
 
    std::vector<Types::qubit_t> qubits;      // each dimension/index of the tensor corresponds to a qubit
    std::vector<Index> connections;          // the ids of the connected tensors in the network (equal
                                             // with the index in the tensors vector)
    std::vector<Index> connectionsIndices;   // the indices of the connected indices in the
                                             // connected tensor on that position
    std::shared_ptr<Utils::Tensor<>> tensor; // the actual tensor
 
    // this is only needed for contraction algorithm
    // it will be set to true only on contraction result nodes, not on the
    // original tensor nodes
    bool contractsTheNeededQubit = false;
};
 
} // namespace TensorNetworks
 
#endif // __TENSOR_NODE_H_