Operator overloads for QuantumSystem

[cahitkargi]

Here we will discuss the ideas on what operators should we overload and their behaviours.

What we currently have

• + operator

  • between two single quantum systems (say qs1 and qs2) --> combines them into a composite system (say compSys), ie creates a composite system (compSys) that contains qs1 and qs2 as its subsystems (in compSys.subSys)
  • between two composite quantum systems (say comp1 and comp2) --> combines them into a composite system (say compSys, ie creates a composite system (compSys) that contains comp1 and comp2 as its subsystems (in compSys.subSys)
  • between a composite system (say comp1) and single system (say qs1) --> adds qs1 as a subsystem to comp1, ie adds qs1 into comp1.subSys

• - operator is more complicated because of nested cases. When I say "X is a part of the composite system Y" in below explanations, I don't necessarily mean the composite system that is the immediate parent of X, but I mean the outer most composite. For example, if a single system (qs1) is inside a composite system (comp1), and comp1 is a subsystem of another composite system (comp2), and this goes up to a degree N ( (compN). With "part of a composite system", I refer to compN.

  • between two single quantum systems (say qs1 and qs2) and the operation is qs1 - qs2.
    • if qs1 is part of a composite system compN, and qs2 is also a part of compN (qs1 and qs2 might be in different subsystems of compN), --> this operation finds and removes qs2 from the composite that it is stored (which might be compN or any of its subsystems)
    • if qs1 is part of a composite system compN, but qs2 is NOT a part of compN --> this is currently undefined.
  • between two composite quantum systems (say comp1 and comp2) and the operation is comp1 - comp2
    • first of all, if comp2 is a subsystem of comp1 & comp1 is a subsystem of comp2--> this is a bug (see addSubSys allows circular subsystem creation #78) and this case should not be allowed to exist
    • if comp2 is a subsystem of comp1 (ie it is either directly in comp1.subSys or in subsystem of any of comp1.subSys) --> this operation removes comp2 from comp1.subSys or from composite that stores it.
    • if comp2 is NOT a subsystem of comp1
      • if comp1 is part of a composite system compN, and comp2 is NOT a part of compN --> this is undefined
      • if comp1 is part of a composite system compN, and comp2 is also a part of compN --> this operation finds and removes comp2 from the composite that it is stored (which might be compN or any of its subsystems)

• * operator, ie someNumber * aQuantumSystem. It always creates a composite system (say comp1) that contains someNumber of copies of aQuantumSystem in comp1.subSys (regardless whether aQuantumSystem is single or composite`

What are the issues and suggested solutions

For all the above operators, we are not sure if they are the most suitable/intuitive/rigorous operators for the purposes described above. So, here we also discuss the alternative operators for each.
Further problems are discussed below:

+ operator

Problem : it does not define a consistent behaviour for different input cases (third case is different than first two)
Suggested solutions :

• overload two different operators for the different behaviours
• before overloading the operators, define functions for:
  • compose : first two behaviours of +
  • append : third behaviour of +
  • extend : third behaviour of + on multiple inputs
  • flatten : to remove all the nesting and reduce a single layer composite system

* operator

Suggestion : it can be used to create a copy of a quantum system where the frequencies are scaled with someNumber