oracle.hpp

Go to the documentation of this file.

 //# Phase oracle acts on n, boolean oracle acts on n+1; https://arxiv.org/pdf/1703.10535.pdf for examples

#ifndef QNLP_ORACLE
#define QNLP_ORACLE

#include <complex>
#include <cassert>
#include <vector>
#include <iostream>

namespace QNLP{
    template <class SimulatorType>
    class Oracle{
        private:
        //Take the 2x2 matrix type from the template SimulatorType
        using Mat2x2Type = decltype(std::declval<SimulatorType>().getGateX());

        public:
        Oracle(){};

        ~Oracle(){};

        static void bitStringNCU(SimulatorType& s, std::size_t bitstring, const std::vector<std::size_t>& ctrl_indices, const std::size_t target, const Mat2x2Type& U, std::string gateLabel){
            std::size_t bitmask = 0b1;
            std::vector<std::size_t> reverse_pattern;
            for(std::size_t i = 0; i < ctrl_indices.size() + 1; ++i){
                //If the bitstring contains a 1 at desired index, will be true;
                //We wish to apply X to any state that is false, then undo
                if( ! (bitstring & (bitmask<<i) ) ){
                    reverse_pattern.push_back(i);
                    if( i < ctrl_indices.size())
                        s.applyGateX(ctrl_indices[i]);
                    else
                        s.applyGateX(target);
                }
            }
            s.applyGateNCU(U, ctrl_indices, target, gateLabel);
            //Undo PauliX ops
            for(auto& revIdx : reverse_pattern){
                if( revIdx < ctrl_indices.size()){
                    s.applyGateX(ctrl_indices[revIdx]);
                }
                else{
                    s.applyGateX(target);
                }
            }
        }


        static void bitStringNCU(SimulatorType& s, std::size_t bitstring, const std::vector<std::size_t>& ctrl_indices, const std::vector<std::size_t>& aux_indices, const std::size_t target, const Mat2x2Type& U, std::string gateLabel){
            std::size_t bitmask = 0b1;
            std::vector<std::size_t> reverse_pattern;
            for(std::size_t i = 0; i < ctrl_indices.size() + 1; ++i){
                //If the bitstring contains a 1 at desired index, will be true;
                //We wish to apply X to any state that is false, then undo
                if( ! (bitstring & (bitmask<<i) ) ){
                    reverse_pattern.push_back(i);
                    if( i < ctrl_indices.size())
                        s.applyGateX(ctrl_indices[i]);
                    else
                        s.applyGateX(target);
                }
            }
            s.applyGateNCU(U, ctrl_indices, aux_indices, target, gateLabel);
            //Undo PauliX ops
            for(auto& revIdx : reverse_pattern){
                if( revIdx < ctrl_indices.size()){
                    s.applyGateX(ctrl_indices[revIdx]);
                }
                else{
                    s.applyGateX(target);
                }
            }
        }

        static void bitStringPhaseOracle(SimulatorType& s, std::size_t bitstring, const std::vector<std::size_t>&ctrlIndices, std::size_t target ){
            std::size_t num_qubits = s.getNumQubits();
            assert ( (1<<num_qubits) < bitstring );
            bitStringNCU(s, bitstring, ctrlIndices, target, s.getGateZ(), "Z");
        }
    };
};
#endif