@classmethod
def from_string(cls, string: str, density_fitting: bool = False) -> Ansatz:
    """Build an `Ansatz` from a string for the default ansatzes.

    Args:
        string: Input string.
        density_fitting: Use density fitting.

    Returns:
        Ansatz object.
    """
    if string not in named_ansatzes:
        raise util.ModelNotImplemented(string)
    return cls(*named_ansatzes[string], density_fitting=density_fitting)

def __repr__(self) -> str:
    """Get a string with the name of the method."""
    name = ""
    if self.density_fitting:
        name += "DF"
    name += self.fermion_ansatz
    if self.boson_ansatz:
        name += "-%s" % self.boson_ansatz
    if self.fermion_coupling_rank or self.boson_coupling_rank:
        name += "-%d" % self.fermion_coupling_rank
        name += "-%d" % self.boson_coupling_rank
    return name

def fermionic_cluster_ranks(
    self,
    spin_type: str = "G",
    which: Literal["t", "l", "ip", "ea", "ee"] = "t",
) -> list[tuple[str, str, int]]:
    """Get a list of cluster operator ranks for the fermionic space.

    Args:
        spin_type: Spin type of the cluster operator.
        which: Type of cluster operator to return.

    Returns:
        List of cluster operator ranks, each element is a tuple containing the name, the slices
        and the rank.
    """
    ranks: list[tuple[str, str, int]] = []
    if not self.fermion_ansatz:
        return ranks

    def _adapt_key(key: str) -> str:
        """Adapt the key to the `which` argument."""
        if which == "ip":
            return key[:-1]
        if which == "ea":
            n = len(key) // 2
            key = key[n:] + key[: n - 1]
        if which == "l":
            n = len(key) // 2
            key = key[n:] + key[:n]
        return key

    symbol = which if which in ("t", "l") else "r"
    notations = {
        "S": [(f"{symbol}1", _adapt_key("ov"), 1)],
        "D": [(f"{symbol}2", _adapt_key("oovv"), 2)],
        "T": [(f"{symbol}3", _adapt_key("ooovvv"), 3)],
        "t": [(f"{symbol}3", _adapt_key("ooOvvV"), 3)],
        "t'": [(f"{symbol}3", _adapt_key("OOOVVV"), 3)],
    }
    if spin_type == "R":
        notations["Q"] = [(f"{symbol}4a", "oooovvvv", 4), (f"{symbol}4b", "oooovvvv", 4)]
    else:
        notations["Q"] = [(f"{symbol}4", "oooovvvv", 4)]
    notations["2"] = notations["S"] + notations["D"]
    notations["3"] = notations["2"] + notations["T"]
    notations["4"] = notations["3"] + notations["Q"]

    # Remove any perturbative corrections
    op = self.fermion_ansatz
    while "(" in op:
        start = op.index("(")
        end = op.index(")")
        op = op[:start]
        if (end + 1) < len(op):
            op += op[end + 1 :]

    # Check in order of longest to shortest string in case one
    # method name starts with a substring equal to the name of
    # another method
    for method_type in sorted(METHOD_TYPES, key=len)[::-1]:
        if op.startswith(method_type):
            op = op.replace(method_type, "", 1)
            break

    # If it's MP we only ever need to initialise second-order
    # amplitudes
    if method_type == "MP" and which in ("t", "l"):
        op = "D"

    # If it's for EOM-CCD we still need the singles
    if self.fermion_ansatz == "CCD" and which in ("ip", "ea", "ee"):
        op = "SD"

    # Determine the ranks
    for key in sorted(notations.keys(), key=len)[::-1]:
        if key in op:
            ranks += notations[key]
            op = op.replace(key, "")

    # Check there are no duplicates
    if len(ranks) != len(set(ranks)):
        raise util.ModelNotImplemented("Duplicate ranks in %s" % self.fermion_ansatz)

    # Sort the ranks by the cluster operator dimension
    ranks = sorted(ranks, key=lambda x: x[2])

    return ranks

def bosonic_cluster_ranks(
    self,
    spin_type: str = "G",
    which: Literal["t", "l", "ip", "ea", "ee"] = "t",
) -> list[tuple[str, str, int]]:
    """Get a list of cluster operator ranks for the bosonic space.

    Args:
        spin_type: Spin type of the cluster operator.
        which: Type of cluster operator.

    Returns:
        List of cluster operator ranks, each element is a tuple containing the name, the slices
        and the rank.
    """
    ranks: list[tuple[str, str, int]] = []
    if not self.boson_ansatz:
        return ranks

    symbol = "s" if which == "t" else "ls"
    notations = {
        "S": [(f"{symbol}1", "b", 1)],
        "D": [(f"{symbol}2", "bb", 2)],
        "T": [(f"{symbol}3", "bbb", 3)],
    }
    notations["2"] = notations["S"] + notations["D"]
    notations["3"] = notations["2"] + notations["T"]

    # Remove any perturbative corrections
    op = self.boson_ansatz
    while "(" in op:
        start = op.index("(")
        end = op.index(")")
        op = op[:start]
        if (end + 1) < len(op):
            op += op[end + 1 :]

    # Determine the ranks
    for key in sorted(notations.keys(), key=len)[::-1]:
        if key in op:
            ranks += notations[key]
            op = op.replace(key, "")

    # Check there are no duplicates
    if len(ranks) != len(set(ranks)):
        raise util.ModelNotImplemented("Duplicate ranks in %s" % self.boson_ansatz)

    # Sort the ranks by the cluster operator dimension
    ranks = sorted(ranks, key=lambda x: x[2])

    return ranks

def coupling_cluster_ranks(
    self,
    spin_type: str = "G",
    which: Literal["t", "l", "ip", "ea", "ee"] = "t",
) -> list[tuple[str, str, int, int]]:
    """Get a list of cluster operator ranks for the coupling between fermions and bosons.

    Args:
        spin_type: Spin type of the cluster operator.
        which: Type of cluster operator to return.

    Returns:
        List of cluster operator ranks, each element is a tuple containing the name, the slices
        and the rank.
    """

    def _adapt_key(key: str, fermion_rank: int, boson_rank: int) -> str:
        """Adapt the key to the `which` argument."""
        if which in ("ip", "ea", "ee"):
            raise util.ModelNotImplemented(
                "Cluster ranks for coupling space not implemented for %s" % which
            )
        if which == "l":
            nf = fermion_rank
            nb = boson_rank
            key = key[:nb] + key[nb + nf :] + key[nb : nb + nf]
        return key

    symbol = "u" if which == "t" else "lu"

    ranks = []
    for fermion_rank in range(1, self.fermion_coupling_rank + 1):
        for boson_rank in range(1, self.boson_coupling_rank + 1):
            name = f"{symbol}{fermion_rank}{boson_rank}"
            key = _adapt_key(
                "b" * boson_rank + "o" * fermion_rank + "v" * fermion_rank,
                fermion_rank,
                boson_rank,
            )
            ranks.append((name, key, fermion_rank, boson_rank))

    return ranks