Is there any method of adding two operators in a circuit?





.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ margin-bottom:0;
}







5












$begingroup$


I am trying to reconstruct the time evolution of a Hamiltonian on the quantum computing simulator, quirk. Ideally I would like to generalise this to any simulator. The unitary matrix is



$$U(t)=e^{-iHt}$$



and I've found a way to decompose the Hamiltonian into the following form:



$$U(t)=A+B(t)$$



Both $A$ and $B(t)$ can be implemented individually. (Although A is a non-unitary diagonal matrix consisting of 0s and 1s) One with a static, custom matrix gate and the other using a series of time dependent and standard gates.



Is there a systematic way to reconstruct $U(t)$ generally? There is no limit on the number of ancillary gates










share|improve this question











$endgroup$












  • $begingroup$
    is it the Hamiltonian or the unitary that is of the form $A+B(t)$?
    $endgroup$
    – DaftWullie
    Jan 30 at 13:30










  • $begingroup$
    @DaftWullie it is the unitary, after taylor expanding
    $endgroup$
    – James
    Jan 30 at 13:32










  • $begingroup$
    Are $A$ and $B(t)$ both unitaries?
    $endgroup$
    – DaftWullie
    Jan 30 at 16:57










  • $begingroup$
    @DaftWullie B is unitary for all t, but A is non unitary. It is a diagonal matrix consisting of just 0s and 1s
    $endgroup$
    – James
    Jan 30 at 20:12






  • 2




    $begingroup$
    Decompose A as the sum of two unitaries ($pm 1$ on the diagonal). Then look at Nelimee's answer
    $endgroup$
    – DaftWullie
    Jan 31 at 12:21


















5












$begingroup$


I am trying to reconstruct the time evolution of a Hamiltonian on the quantum computing simulator, quirk. Ideally I would like to generalise this to any simulator. The unitary matrix is



$$U(t)=e^{-iHt}$$



and I've found a way to decompose the Hamiltonian into the following form:



$$U(t)=A+B(t)$$



Both $A$ and $B(t)$ can be implemented individually. (Although A is a non-unitary diagonal matrix consisting of 0s and 1s) One with a static, custom matrix gate and the other using a series of time dependent and standard gates.



Is there a systematic way to reconstruct $U(t)$ generally? There is no limit on the number of ancillary gates










share|improve this question











$endgroup$












  • $begingroup$
    is it the Hamiltonian or the unitary that is of the form $A+B(t)$?
    $endgroup$
    – DaftWullie
    Jan 30 at 13:30










  • $begingroup$
    @DaftWullie it is the unitary, after taylor expanding
    $endgroup$
    – James
    Jan 30 at 13:32










  • $begingroup$
    Are $A$ and $B(t)$ both unitaries?
    $endgroup$
    – DaftWullie
    Jan 30 at 16:57










  • $begingroup$
    @DaftWullie B is unitary for all t, but A is non unitary. It is a diagonal matrix consisting of just 0s and 1s
    $endgroup$
    – James
    Jan 30 at 20:12






  • 2




    $begingroup$
    Decompose A as the sum of two unitaries ($pm 1$ on the diagonal). Then look at Nelimee's answer
    $endgroup$
    – DaftWullie
    Jan 31 at 12:21














5












5








5





$begingroup$


I am trying to reconstruct the time evolution of a Hamiltonian on the quantum computing simulator, quirk. Ideally I would like to generalise this to any simulator. The unitary matrix is



$$U(t)=e^{-iHt}$$



and I've found a way to decompose the Hamiltonian into the following form:



$$U(t)=A+B(t)$$



Both $A$ and $B(t)$ can be implemented individually. (Although A is a non-unitary diagonal matrix consisting of 0s and 1s) One with a static, custom matrix gate and the other using a series of time dependent and standard gates.



Is there a systematic way to reconstruct $U(t)$ generally? There is no limit on the number of ancillary gates










share|improve this question











$endgroup$




I am trying to reconstruct the time evolution of a Hamiltonian on the quantum computing simulator, quirk. Ideally I would like to generalise this to any simulator. The unitary matrix is



$$U(t)=e^{-iHt}$$



and I've found a way to decompose the Hamiltonian into the following form:



$$U(t)=A+B(t)$$



Both $A$ and $B(t)$ can be implemented individually. (Although A is a non-unitary diagonal matrix consisting of 0s and 1s) One with a static, custom matrix gate and the other using a series of time dependent and standard gates.



Is there a systematic way to reconstruct $U(t)$ generally? There is no limit on the number of ancillary gates







quantum-gate circuit-construction gate-synthesis quirk






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited Jan 31 at 14:29







James

















asked Jan 30 at 13:21









JamesJames

1454




1454












  • $begingroup$
    is it the Hamiltonian or the unitary that is of the form $A+B(t)$?
    $endgroup$
    – DaftWullie
    Jan 30 at 13:30










  • $begingroup$
    @DaftWullie it is the unitary, after taylor expanding
    $endgroup$
    – James
    Jan 30 at 13:32










  • $begingroup$
    Are $A$ and $B(t)$ both unitaries?
    $endgroup$
    – DaftWullie
    Jan 30 at 16:57










  • $begingroup$
    @DaftWullie B is unitary for all t, but A is non unitary. It is a diagonal matrix consisting of just 0s and 1s
    $endgroup$
    – James
    Jan 30 at 20:12






  • 2




    $begingroup$
    Decompose A as the sum of two unitaries ($pm 1$ on the diagonal). Then look at Nelimee's answer
    $endgroup$
    – DaftWullie
    Jan 31 at 12:21


















  • $begingroup$
    is it the Hamiltonian or the unitary that is of the form $A+B(t)$?
    $endgroup$
    – DaftWullie
    Jan 30 at 13:30










  • $begingroup$
    @DaftWullie it is the unitary, after taylor expanding
    $endgroup$
    – James
    Jan 30 at 13:32










  • $begingroup$
    Are $A$ and $B(t)$ both unitaries?
    $endgroup$
    – DaftWullie
    Jan 30 at 16:57










  • $begingroup$
    @DaftWullie B is unitary for all t, but A is non unitary. It is a diagonal matrix consisting of just 0s and 1s
    $endgroup$
    – James
    Jan 30 at 20:12






  • 2




    $begingroup$
    Decompose A as the sum of two unitaries ($pm 1$ on the diagonal). Then look at Nelimee's answer
    $endgroup$
    – DaftWullie
    Jan 31 at 12:21
















$begingroup$
is it the Hamiltonian or the unitary that is of the form $A+B(t)$?
$endgroup$
– DaftWullie
Jan 30 at 13:30




$begingroup$
is it the Hamiltonian or the unitary that is of the form $A+B(t)$?
$endgroup$
– DaftWullie
Jan 30 at 13:30












$begingroup$
@DaftWullie it is the unitary, after taylor expanding
$endgroup$
– James
Jan 30 at 13:32




$begingroup$
@DaftWullie it is the unitary, after taylor expanding
$endgroup$
– James
Jan 30 at 13:32












$begingroup$
Are $A$ and $B(t)$ both unitaries?
$endgroup$
– DaftWullie
Jan 30 at 16:57




$begingroup$
Are $A$ and $B(t)$ both unitaries?
$endgroup$
– DaftWullie
Jan 30 at 16:57












$begingroup$
@DaftWullie B is unitary for all t, but A is non unitary. It is a diagonal matrix consisting of just 0s and 1s
$endgroup$
– James
Jan 30 at 20:12




$begingroup$
@DaftWullie B is unitary for all t, but A is non unitary. It is a diagonal matrix consisting of just 0s and 1s
$endgroup$
– James
Jan 30 at 20:12




2




2




$begingroup$
Decompose A as the sum of two unitaries ($pm 1$ on the diagonal). Then look at Nelimee's answer
$endgroup$
– DaftWullie
Jan 31 at 12:21




$begingroup$
Decompose A as the sum of two unitaries ($pm 1$ on the diagonal). Then look at Nelimee's answer
$endgroup$
– DaftWullie
Jan 31 at 12:21










3 Answers
3






active

oldest

votes


















6












$begingroup$

What you are trying to do is called Hamiltonian Simulation.



If your exponential can be split in a sum of unitary matrices, @smapers' answer guide you to a good algorithm: the Linear Combination of Unitary (LCU) algorithm.



In addition to the paper linked by @smapers, here are some other papers/videos explaining LCU:





  • Maybe the first paper to present LCU: Simulating Hamiltonian dynamics with a truncated Taylor series (Dominic W. Berry, Andrew M. Childs, Richard Cleve, Robin Kothari, Rolando D. Somma, 2015).



    The paper is quite concise but explains the idea behind this algorithm.



  • A presentation given by Nathan Wiebe at a conference. He explains quickly what is LCU and how it works.


  • A presentation given by Robin Kothari at the same conference. You should look the whole presentation from the beginning, but if you don't have the time I provided you a link directly to the part about LCU algorithm.



  • Finally, a paper explaining in details how LCU works and how they implemented LCU for a very specific kind of Hamiltonian: Toward the first quantum simulation with quantum speedup (Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su, 2017). The parts about LCU are spread in the whole article, look at all the parts dealing with the TS (Taylor Series) algorithm:




    1. Section 3.2 (page 4) for a 2-paragraph summary.

    2. Appendix C.2 (page 13) for an explanation of the TS/LCU algorithms.

    3. Appendix G (page 38) for an error analysis and for an explanation on how they implemented some sub-routines needed by the LCU algorithm.




PS: there are plenty of other algorithms to perform Hamiltonian simulation. If your exponential can be split into known unitary matrices, LCU is probably the best algorithm, but you should know that it is not the only algorithm capable of simulating Hamiltonian. You can find more links in one of my previous answers about Hamiltonian Simulation. If you think you need more links on Hamiltonian Simulation algorithms just let me know.






share|improve this answer









$endgroup$













  • $begingroup$
    my B(t) is unitary for all t, but the A is a constant non-unitary matrix consisting of 0s and 1s along the diagonal only
    $endgroup$
    – James
    Jan 30 at 22:10






  • 2




    $begingroup$
    Then you should write this in your question. The sentence Both A and B(t) can be implemented individually. is quite misleading as it implies (at least for me) that $A$ and $B(t)$ are unitary.
    $endgroup$
    – Nelimee
    Jan 31 at 8:35










  • $begingroup$
    sorry about that, I'll update the question. @Daft Wullie pointed out that we can decompose A into two unitary matrices A=A'+A'' and so your answer still holds
    $endgroup$
    – James
    Jan 31 at 14:28



















8












$begingroup$

Below is a recent paper by Gilyén et al on doing "quantum matrix arithmetics", allowing to implement linear combinations of unitary operators. They consider the general case where the linear combination in itself might not be unitary. Since the linear combination in your case is unitary, maybe there's a more efficient way.



[1]: Gilyén, András, et al. "Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics." arXiv preprint arXiv:1806.01838 (2018).






share|improve this answer











$endgroup$





















    4












    $begingroup$

    It seems that you need oblivious fixed point amplitude amplification. See Theorem 26-28 in the aforementioned paper: arXiv:1806.01838 [quant-ph].



    As a first step, you can implement $frac{A+B(t)}{2}$ as a block of a unitary. This is however not a unitary itself, but then you can turn it into a unitary using oblivious fixed point amplitude amplification. If you also happen to know the (spectral) norm of $A+B(t)$, then ordinary oblivious amplitude amplification suffices.






    share|improve this answer











    $endgroup$














      Your Answer





      StackExchange.ifUsing("editor", function () {
      return StackExchange.using("mathjaxEditing", function () {
      StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
      StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
      });
      });
      }, "mathjax-editing");

      StackExchange.ready(function() {
      var channelOptions = {
      tags: "".split(" "),
      id: "694"
      };
      initTagRenderer("".split(" "), "".split(" "), channelOptions);

      StackExchange.using("externalEditor", function() {
      // Have to fire editor after snippets, if snippets enabled
      if (StackExchange.settings.snippets.snippetsEnabled) {
      StackExchange.using("snippets", function() {
      createEditor();
      });
      }
      else {
      createEditor();
      }
      });

      function createEditor() {
      StackExchange.prepareEditor({
      heartbeatType: 'answer',
      autoActivateHeartbeat: false,
      convertImagesToLinks: false,
      noModals: true,
      showLowRepImageUploadWarning: true,
      reputationToPostImages: null,
      bindNavPrevention: true,
      postfix: "",
      imageUploader: {
      brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
      contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
      allowUrls: true
      },
      noCode: true, onDemand: true,
      discardSelector: ".discard-answer"
      ,immediatelyShowMarkdownHelp:true
      });


      }
      });














      draft saved

      draft discarded


















      StackExchange.ready(
      function () {
      StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fquantumcomputing.stackexchange.com%2fquestions%2f5315%2fis-there-any-method-of-adding-two-operators-in-a-circuit%23new-answer', 'question_page');
      }
      );

      Post as a guest















      Required, but never shown

























      3 Answers
      3






      active

      oldest

      votes








      3 Answers
      3






      active

      oldest

      votes









      active

      oldest

      votes






      active

      oldest

      votes









      6












      $begingroup$

      What you are trying to do is called Hamiltonian Simulation.



      If your exponential can be split in a sum of unitary matrices, @smapers' answer guide you to a good algorithm: the Linear Combination of Unitary (LCU) algorithm.



      In addition to the paper linked by @smapers, here are some other papers/videos explaining LCU:





      • Maybe the first paper to present LCU: Simulating Hamiltonian dynamics with a truncated Taylor series (Dominic W. Berry, Andrew M. Childs, Richard Cleve, Robin Kothari, Rolando D. Somma, 2015).



        The paper is quite concise but explains the idea behind this algorithm.



      • A presentation given by Nathan Wiebe at a conference. He explains quickly what is LCU and how it works.


      • A presentation given by Robin Kothari at the same conference. You should look the whole presentation from the beginning, but if you don't have the time I provided you a link directly to the part about LCU algorithm.



      • Finally, a paper explaining in details how LCU works and how they implemented LCU for a very specific kind of Hamiltonian: Toward the first quantum simulation with quantum speedup (Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su, 2017). The parts about LCU are spread in the whole article, look at all the parts dealing with the TS (Taylor Series) algorithm:




        1. Section 3.2 (page 4) for a 2-paragraph summary.

        2. Appendix C.2 (page 13) for an explanation of the TS/LCU algorithms.

        3. Appendix G (page 38) for an error analysis and for an explanation on how they implemented some sub-routines needed by the LCU algorithm.




      PS: there are plenty of other algorithms to perform Hamiltonian simulation. If your exponential can be split into known unitary matrices, LCU is probably the best algorithm, but you should know that it is not the only algorithm capable of simulating Hamiltonian. You can find more links in one of my previous answers about Hamiltonian Simulation. If you think you need more links on Hamiltonian Simulation algorithms just let me know.






      share|improve this answer









      $endgroup$













      • $begingroup$
        my B(t) is unitary for all t, but the A is a constant non-unitary matrix consisting of 0s and 1s along the diagonal only
        $endgroup$
        – James
        Jan 30 at 22:10






      • 2




        $begingroup$
        Then you should write this in your question. The sentence Both A and B(t) can be implemented individually. is quite misleading as it implies (at least for me) that $A$ and $B(t)$ are unitary.
        $endgroup$
        – Nelimee
        Jan 31 at 8:35










      • $begingroup$
        sorry about that, I'll update the question. @Daft Wullie pointed out that we can decompose A into two unitary matrices A=A'+A'' and so your answer still holds
        $endgroup$
        – James
        Jan 31 at 14:28
















      6












      $begingroup$

      What you are trying to do is called Hamiltonian Simulation.



      If your exponential can be split in a sum of unitary matrices, @smapers' answer guide you to a good algorithm: the Linear Combination of Unitary (LCU) algorithm.



      In addition to the paper linked by @smapers, here are some other papers/videos explaining LCU:





      • Maybe the first paper to present LCU: Simulating Hamiltonian dynamics with a truncated Taylor series (Dominic W. Berry, Andrew M. Childs, Richard Cleve, Robin Kothari, Rolando D. Somma, 2015).



        The paper is quite concise but explains the idea behind this algorithm.



      • A presentation given by Nathan Wiebe at a conference. He explains quickly what is LCU and how it works.


      • A presentation given by Robin Kothari at the same conference. You should look the whole presentation from the beginning, but if you don't have the time I provided you a link directly to the part about LCU algorithm.



      • Finally, a paper explaining in details how LCU works and how they implemented LCU for a very specific kind of Hamiltonian: Toward the first quantum simulation with quantum speedup (Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su, 2017). The parts about LCU are spread in the whole article, look at all the parts dealing with the TS (Taylor Series) algorithm:




        1. Section 3.2 (page 4) for a 2-paragraph summary.

        2. Appendix C.2 (page 13) for an explanation of the TS/LCU algorithms.

        3. Appendix G (page 38) for an error analysis and for an explanation on how they implemented some sub-routines needed by the LCU algorithm.




      PS: there are plenty of other algorithms to perform Hamiltonian simulation. If your exponential can be split into known unitary matrices, LCU is probably the best algorithm, but you should know that it is not the only algorithm capable of simulating Hamiltonian. You can find more links in one of my previous answers about Hamiltonian Simulation. If you think you need more links on Hamiltonian Simulation algorithms just let me know.






      share|improve this answer









      $endgroup$













      • $begingroup$
        my B(t) is unitary for all t, but the A is a constant non-unitary matrix consisting of 0s and 1s along the diagonal only
        $endgroup$
        – James
        Jan 30 at 22:10






      • 2




        $begingroup$
        Then you should write this in your question. The sentence Both A and B(t) can be implemented individually. is quite misleading as it implies (at least for me) that $A$ and $B(t)$ are unitary.
        $endgroup$
        – Nelimee
        Jan 31 at 8:35










      • $begingroup$
        sorry about that, I'll update the question. @Daft Wullie pointed out that we can decompose A into two unitary matrices A=A'+A'' and so your answer still holds
        $endgroup$
        – James
        Jan 31 at 14:28














      6












      6








      6





      $begingroup$

      What you are trying to do is called Hamiltonian Simulation.



      If your exponential can be split in a sum of unitary matrices, @smapers' answer guide you to a good algorithm: the Linear Combination of Unitary (LCU) algorithm.



      In addition to the paper linked by @smapers, here are some other papers/videos explaining LCU:





      • Maybe the first paper to present LCU: Simulating Hamiltonian dynamics with a truncated Taylor series (Dominic W. Berry, Andrew M. Childs, Richard Cleve, Robin Kothari, Rolando D. Somma, 2015).



        The paper is quite concise but explains the idea behind this algorithm.



      • A presentation given by Nathan Wiebe at a conference. He explains quickly what is LCU and how it works.


      • A presentation given by Robin Kothari at the same conference. You should look the whole presentation from the beginning, but if you don't have the time I provided you a link directly to the part about LCU algorithm.



      • Finally, a paper explaining in details how LCU works and how they implemented LCU for a very specific kind of Hamiltonian: Toward the first quantum simulation with quantum speedup (Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su, 2017). The parts about LCU are spread in the whole article, look at all the parts dealing with the TS (Taylor Series) algorithm:




        1. Section 3.2 (page 4) for a 2-paragraph summary.

        2. Appendix C.2 (page 13) for an explanation of the TS/LCU algorithms.

        3. Appendix G (page 38) for an error analysis and for an explanation on how they implemented some sub-routines needed by the LCU algorithm.




      PS: there are plenty of other algorithms to perform Hamiltonian simulation. If your exponential can be split into known unitary matrices, LCU is probably the best algorithm, but you should know that it is not the only algorithm capable of simulating Hamiltonian. You can find more links in one of my previous answers about Hamiltonian Simulation. If you think you need more links on Hamiltonian Simulation algorithms just let me know.






      share|improve this answer









      $endgroup$



      What you are trying to do is called Hamiltonian Simulation.



      If your exponential can be split in a sum of unitary matrices, @smapers' answer guide you to a good algorithm: the Linear Combination of Unitary (LCU) algorithm.



      In addition to the paper linked by @smapers, here are some other papers/videos explaining LCU:





      • Maybe the first paper to present LCU: Simulating Hamiltonian dynamics with a truncated Taylor series (Dominic W. Berry, Andrew M. Childs, Richard Cleve, Robin Kothari, Rolando D. Somma, 2015).



        The paper is quite concise but explains the idea behind this algorithm.



      • A presentation given by Nathan Wiebe at a conference. He explains quickly what is LCU and how it works.


      • A presentation given by Robin Kothari at the same conference. You should look the whole presentation from the beginning, but if you don't have the time I provided you a link directly to the part about LCU algorithm.



      • Finally, a paper explaining in details how LCU works and how they implemented LCU for a very specific kind of Hamiltonian: Toward the first quantum simulation with quantum speedup (Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su, 2017). The parts about LCU are spread in the whole article, look at all the parts dealing with the TS (Taylor Series) algorithm:




        1. Section 3.2 (page 4) for a 2-paragraph summary.

        2. Appendix C.2 (page 13) for an explanation of the TS/LCU algorithms.

        3. Appendix G (page 38) for an error analysis and for an explanation on how they implemented some sub-routines needed by the LCU algorithm.




      PS: there are plenty of other algorithms to perform Hamiltonian simulation. If your exponential can be split into known unitary matrices, LCU is probably the best algorithm, but you should know that it is not the only algorithm capable of simulating Hamiltonian. You can find more links in one of my previous answers about Hamiltonian Simulation. If you think you need more links on Hamiltonian Simulation algorithms just let me know.







      share|improve this answer












      share|improve this answer



      share|improve this answer










      answered Jan 30 at 16:59









      NelimeeNelimee

      1,720428




      1,720428












      • $begingroup$
        my B(t) is unitary for all t, but the A is a constant non-unitary matrix consisting of 0s and 1s along the diagonal only
        $endgroup$
        – James
        Jan 30 at 22:10






      • 2




        $begingroup$
        Then you should write this in your question. The sentence Both A and B(t) can be implemented individually. is quite misleading as it implies (at least for me) that $A$ and $B(t)$ are unitary.
        $endgroup$
        – Nelimee
        Jan 31 at 8:35










      • $begingroup$
        sorry about that, I'll update the question. @Daft Wullie pointed out that we can decompose A into two unitary matrices A=A'+A'' and so your answer still holds
        $endgroup$
        – James
        Jan 31 at 14:28


















      • $begingroup$
        my B(t) is unitary for all t, but the A is a constant non-unitary matrix consisting of 0s and 1s along the diagonal only
        $endgroup$
        – James
        Jan 30 at 22:10






      • 2




        $begingroup$
        Then you should write this in your question. The sentence Both A and B(t) can be implemented individually. is quite misleading as it implies (at least for me) that $A$ and $B(t)$ are unitary.
        $endgroup$
        – Nelimee
        Jan 31 at 8:35










      • $begingroup$
        sorry about that, I'll update the question. @Daft Wullie pointed out that we can decompose A into two unitary matrices A=A'+A'' and so your answer still holds
        $endgroup$
        – James
        Jan 31 at 14:28
















      $begingroup$
      my B(t) is unitary for all t, but the A is a constant non-unitary matrix consisting of 0s and 1s along the diagonal only
      $endgroup$
      – James
      Jan 30 at 22:10




      $begingroup$
      my B(t) is unitary for all t, but the A is a constant non-unitary matrix consisting of 0s and 1s along the diagonal only
      $endgroup$
      – James
      Jan 30 at 22:10




      2




      2




      $begingroup$
      Then you should write this in your question. The sentence Both A and B(t) can be implemented individually. is quite misleading as it implies (at least for me) that $A$ and $B(t)$ are unitary.
      $endgroup$
      – Nelimee
      Jan 31 at 8:35




      $begingroup$
      Then you should write this in your question. The sentence Both A and B(t) can be implemented individually. is quite misleading as it implies (at least for me) that $A$ and $B(t)$ are unitary.
      $endgroup$
      – Nelimee
      Jan 31 at 8:35












      $begingroup$
      sorry about that, I'll update the question. @Daft Wullie pointed out that we can decompose A into two unitary matrices A=A'+A'' and so your answer still holds
      $endgroup$
      – James
      Jan 31 at 14:28




      $begingroup$
      sorry about that, I'll update the question. @Daft Wullie pointed out that we can decompose A into two unitary matrices A=A'+A'' and so your answer still holds
      $endgroup$
      – James
      Jan 31 at 14:28













      8












      $begingroup$

      Below is a recent paper by Gilyén et al on doing "quantum matrix arithmetics", allowing to implement linear combinations of unitary operators. They consider the general case where the linear combination in itself might not be unitary. Since the linear combination in your case is unitary, maybe there's a more efficient way.



      [1]: Gilyén, András, et al. "Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics." arXiv preprint arXiv:1806.01838 (2018).






      share|improve this answer











      $endgroup$


















        8












        $begingroup$

        Below is a recent paper by Gilyén et al on doing "quantum matrix arithmetics", allowing to implement linear combinations of unitary operators. They consider the general case where the linear combination in itself might not be unitary. Since the linear combination in your case is unitary, maybe there's a more efficient way.



        [1]: Gilyén, András, et al. "Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics." arXiv preprint arXiv:1806.01838 (2018).






        share|improve this answer











        $endgroup$
















          8












          8








          8





          $begingroup$

          Below is a recent paper by Gilyén et al on doing "quantum matrix arithmetics", allowing to implement linear combinations of unitary operators. They consider the general case where the linear combination in itself might not be unitary. Since the linear combination in your case is unitary, maybe there's a more efficient way.



          [1]: Gilyén, András, et al. "Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics." arXiv preprint arXiv:1806.01838 (2018).






          share|improve this answer











          $endgroup$



          Below is a recent paper by Gilyén et al on doing "quantum matrix arithmetics", allowing to implement linear combinations of unitary operators. They consider the general case where the linear combination in itself might not be unitary. Since the linear combination in your case is unitary, maybe there's a more efficient way.



          [1]: Gilyén, András, et al. "Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics." arXiv preprint arXiv:1806.01838 (2018).







          share|improve this answer














          share|improve this answer



          share|improve this answer








          edited Jan 30 at 16:45









          Blue

          6,63141556




          6,63141556










          answered Jan 30 at 13:51









          smaperssmapers

          813




          813























              4












              $begingroup$

              It seems that you need oblivious fixed point amplitude amplification. See Theorem 26-28 in the aforementioned paper: arXiv:1806.01838 [quant-ph].



              As a first step, you can implement $frac{A+B(t)}{2}$ as a block of a unitary. This is however not a unitary itself, but then you can turn it into a unitary using oblivious fixed point amplitude amplification. If you also happen to know the (spectral) norm of $A+B(t)$, then ordinary oblivious amplitude amplification suffices.






              share|improve this answer











              $endgroup$


















                4












                $begingroup$

                It seems that you need oblivious fixed point amplitude amplification. See Theorem 26-28 in the aforementioned paper: arXiv:1806.01838 [quant-ph].



                As a first step, you can implement $frac{A+B(t)}{2}$ as a block of a unitary. This is however not a unitary itself, but then you can turn it into a unitary using oblivious fixed point amplitude amplification. If you also happen to know the (spectral) norm of $A+B(t)$, then ordinary oblivious amplitude amplification suffices.






                share|improve this answer











                $endgroup$
















                  4












                  4








                  4





                  $begingroup$

                  It seems that you need oblivious fixed point amplitude amplification. See Theorem 26-28 in the aforementioned paper: arXiv:1806.01838 [quant-ph].



                  As a first step, you can implement $frac{A+B(t)}{2}$ as a block of a unitary. This is however not a unitary itself, but then you can turn it into a unitary using oblivious fixed point amplitude amplification. If you also happen to know the (spectral) norm of $A+B(t)$, then ordinary oblivious amplitude amplification suffices.






                  share|improve this answer











                  $endgroup$



                  It seems that you need oblivious fixed point amplitude amplification. See Theorem 26-28 in the aforementioned paper: arXiv:1806.01838 [quant-ph].



                  As a first step, you can implement $frac{A+B(t)}{2}$ as a block of a unitary. This is however not a unitary itself, but then you can turn it into a unitary using oblivious fixed point amplitude amplification. If you also happen to know the (spectral) norm of $A+B(t)$, then ordinary oblivious amplitude amplification suffices.







                  share|improve this answer














                  share|improve this answer



                  share|improve this answer








                  edited Mar 9 at 9:16









                  Blue

                  6,63141556




                  6,63141556










                  answered Jan 31 at 12:17









                  AndrásAndrás

                  411




                  411






























                      draft saved

                      draft discarded




















































                      Thanks for contributing an answer to Quantum Computing Stack Exchange!


                      • Please be sure to answer the question. Provide details and share your research!

                      But avoid



                      • Asking for help, clarification, or responding to other answers.

                      • Making statements based on opinion; back them up with references or personal experience.


                      Use MathJax to format equations. MathJax reference.


                      To learn more, see our tips on writing great answers.




                      draft saved


                      draft discarded














                      StackExchange.ready(
                      function () {
                      StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fquantumcomputing.stackexchange.com%2fquestions%2f5315%2fis-there-any-method-of-adding-two-operators-in-a-circuit%23new-answer', 'question_page');
                      }
                      );

                      Post as a guest















                      Required, but never shown





















































                      Required, but never shown














                      Required, but never shown












                      Required, but never shown







                      Required, but never shown

































                      Required, but never shown














                      Required, but never shown












                      Required, but never shown







                      Required, but never shown







                      Popular posts from this blog

                      'app-layout' is not a known element: how to share Component with different Modules

                      android studio warns about leanback feature tag usage required on manifest while using Unity exported app?

                      WPF add header to Image with URL pettitions [duplicate]