docs: def downpass(tree, feature, states):
      """
      DOWNPASS traverses the tree starting from the root and going down till the tips,
      and for each node combines the state information from its supertree and its subtree (calculated at UPPASS).
      As the root state was already the most parsimonious after the UPPASS,
      we skip it and start directly with the root children.
  
      if N is not a tip:
          L, R <- left and right children of N
          if N is root:
              UP_S(N) <- union of all states
          else:
              P <- parent of N
              B <- brother of N
              UP_S(N) <- most_common_states(UP_S(P), S(B))
          S(N) <- most_common_states(UP_S(N), S(L), S(R))
          DOWNPASS(L)
          DOWNPASS(R)
  
      :param tree: ete3.Tree, the tree of interest
      :param feature: str, character for which the parsimonious states are reconstructed
      :return: void, adds get_personalized_feature_name(feature, PARS_STATES) feature to the tree nodes
      """
  
      ps_feature_down = get_personalized_feature_name(feature, BU_PARS_STATES)
      ps_feature_up = get_personalized_feature_name(feature, TD_PARS_STATES)
      ps_feature = get_personalized_feature_name(feature, PARS_STATES)
  
      for node in tree.traverse('preorder'):
          if node.is_root():
              node.add_feature(ps_feature_up, set(states))
          else:
              node.add_feature(ps_feature_up,
                               get_most_common_states([getattr(node.up, ps_feature_up)]
                                                      + [getattr(sibling, ps_feature_down) for sibling in node.up.children
                                                         if sibling != node]))
          down_up_states = get_most_common_states([getattr(node, ps_feature_up)]
                                                  + [getattr(child, ps_feature_down) for child in node.children]) \
              if not node.is_leaf() else getattr(node, ps_feature_up)
          preset_states = getattr(node, ps_feature)
          state_intersection = down_up_states & preset_states
          node.add_feature(ps_feature, state_intersection if state_intersection else preset_states)
  
      for node in tree.traverse():
          node.del_feature(ps_feature_down)
          node.del_feature(ps_feature_up)