TensorNetworks/Factory.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef __TENSORS_FACTORY_H_
#define __TENSORS_FACTORY_H_ 1
 
#include "../Utils/Tensors/Tensor.h"
#include "QubitRegister.h"
 
namespace TensorNetworks
{

class Factory
{
  public:
    using MatrixClass = Eigen::MatrixXcd;
 
    static std::shared_ptr<Utils::Tensor<>> CreateTensorFromGate(const QC::Gates::QuantumGateWithOp<MatrixClass> &gate)
    {
        if (gate.getQubitsNumber() > 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.");
 
        if (gate.getQubitsNumber() == 1)
            return CreateTensorFromGateOnOneQubit(gate);
 
        return CreateTensorFromGateOnTwoQubits(gate);
    }
 
    static std::shared_ptr<Utils::Tensor<>> CreateProjectionTensor(bool onZero = true)
    {
        static const std::vector<size_t> dims{2, 2};
        auto tensor = std::make_shared<Utils::Tensor<>>(dims);
 
        std::vector<size_t> indices{0, 0};
        (*tensor)(indices) = onZero ? 1. : 0.;
        indices[1] = 1;
        (*tensor)(indices) = 0;
        indices[0] = 1;
        (*tensor)(indices) = onZero ? 0. : 1.;
        indices[1] = 0;
        (*tensor)(indices) = 0;
 
        return tensor;
    }
 
    static std::shared_ptr<Utils::Tensor<>> CreateQubit0Tensor()
    {
        static const std::vector<size_t> dims{2};
        auto tensor = std::make_shared<Utils::Tensor<>>(dims);
 
        std::vector<size_t> indices{0};
        (*tensor)(indices) = 1.0;
        indices[0] = 1;
        (*tensor)(indices) = 0.0;
 
        return tensor;
    }
 
    static std::shared_ptr<Utils::Tensor<>> CreateQubit1Tensor()
    {
        static const std::vector<size_t> dims{2};
        auto tensor = std::make_shared<Utils::Tensor<>>(dims);
 
        std::vector<size_t> indices{0};
        (*tensor)(indices) = 0.0;
        indices[0] = 1;
        (*tensor)(indices) = 1.0;
 
        return tensor;
    }
 
    static std::shared_ptr<Utils::Tensor<>> CreateTensorFromGateOnOneQubit(const QC::Gates::QuantumGateWithOp<MatrixClass> &gate)
    {
        static const std::vector<size_t> dims{2, 2};
        auto tensor = std::make_shared<Utils::Tensor<>>(dims);
 
        const MatrixClass &mat = gate.getRawOperatorMatrix();
 
        std::vector<size_t> indices{0, 0};
        (*tensor)(indices) = mat(0, 0);
        indices[1] = 1;
        (*tensor)(indices) = mat(1, 0);
        indices[0] = 1;
        (*tensor)(indices) = mat(1, 1);
        indices[1] = 0;
        (*tensor)(indices) = mat(0, 1);
 
        return tensor;
    }
 
    static std::shared_ptr<Utils::Tensor<>> CreateTensorFromGateOnTwoQubits(const QC::Gates::QuantumGateWithOp<MatrixClass> &gate)
    {
        static const std::vector<size_t> dims{2, 2, 2, 2};
        auto tensor = std::make_shared<Utils::Tensor<>>(dims);
 
        const MatrixClass &mat = gate.getRawOperatorMatrix();
 
        std::vector<size_t> indices;
        indices.resize(4);
 
        // q1l, q0l, q1c, q0c
        for (int q0l = 0; q0l < 2; ++q0l) // ctrl qubit
        {
            const int l0 = q0l << 1;
            indices[2] = q0l;
            for (int q0c = 0; q0c < 2; ++q0c) // ctrl qubit
            {
                indices[0] = q0c;
                const int c0 = q0c << 1;
                for (int q1l = 0; q1l < 2; ++q1l)
                {
                    indices[3] = q1l;
                    for (int q1c = 0; q1c < 2; ++q1c)
                    {
                        indices[1] = q1c;
                        (*tensor)(indices) = mat(l0 | q1l, c0 | q1c);
                    }
                }
            }
        }
 
        return tensor;
    }
};
 
} // namespace TensorNetworks
 
#endif // ! __TENSORS_FACTORY_H_