Refactor UCCSD

What is the expected enhancement?

UCCSD needs to be refactored for several reasons:

• it is incompatible with the VQE implementation provided by Qiskit Terra
• it uses the (soon-to-be-removed) FermionicOperator class
• it uses the legacy WeightedPauliOperator

The following requirements should be met by the new implementation:

• it should derive BlueprintCircuit and, thus, be compatible with Terra
• the hopping operator factory logic should be moved to an external place as it can also be of use elsewhere (currently FermionicTransformation actually uses the logic inside of UCCSD)
• it should make use of the new FermionicOp and opflow operators
• ideally, the hopping operator factory should be generalized to work for any kind of exctitation (S, D, T, Q, …)
• ideally, we would have a UCC class in which the user can freely specify the types of excitations he would like to have
• (we may provide ease-of-use subclasses like UCCSD, UCCD, etc.)

Once UCCSD has been refactored we should also be able to replace all qiskit.aqua imports with their new counterparts. Thus, the critical status of this issue.

[woodsp-ibm]

This refactor should also include the UVCC var form too right that was done for Bosonic Problems. I think the same EvolvedOp base class should be usable for this, but it needs bosonic hopping operators; so maybe we need to be careful about naming of the excitation and hopping logic above to differentiate things.

[Cryoris]

Summarizing use cases from the discussion we had (modulo correct class and argument names):

# case 1
gse = GroundStateEigensolver(UCCSDVQEFactory(), mapper)
gse.solve(molecular_problem)

# case 2
h2 = (I ^ I) + (Z ^ Z) + ...  # copy my hamiltonian from somewhere or construct it manually

uccsd = UCCSD(4, 2, mapper, symmetry_info)  # put in proper mapper and symmetry info
vqe = VQE(uccsd, optimizer)
vqe.compute_min_eigenvalue(h2)


# case 3
class MyFactory():
    # uccsd = UCCSD()
    # vqe = VQE(uccsd, optimizer)

gse = GroundStateEigensolver(MyFactory(), mapper)
gse.solve(molecular_problem)

and the proposed circuit structure:

class EvolvedOperatorAnsatz(BlueprintCircuit):
    """
    Examples:
        excitations = build_excitation_ops(num_part, num_orb)
        mapper = Mapper()
        mapped_excitations = mapper.map(excitations)
        # and other postproc

        ucc = EvolvedOperatorAnsatz(mapped_excitations)
    """
    def __init__(self, ops=None, evolution=None):
        pass

class UCC(EvolvedOperatorAnsatz):
    """
    Examples:
        ucc = UCC('sdt', num_part, num_orb, mapper)

        excitations = build_excitation_ops(num_part, num_orb, 'sdt')
        ucc = UCC(excitations, mapper)
    """
    def __init__(self, excitations=None, num_part=None, num_orb=None, mapper=None):
        pass

class UCCSD(UCC):
    def __init__(self, num_part=None, num_orb=None, mapper=None):
        super().__init__('sd', num_part, num_orb, mapper)