docs: def lineages_through_time(self, present_day=None, show_plot=True, color='#000000', xmin=None, xmax=None, ymin=None, ymax=None, title=None, xlabel=None, ylabel=None):
          '''Compute the number of lineages through time. If seaborn is installed, a plot is shown as well
  
          Args:
              ``present_day`` (``float``): The time of the furthest node from the root. If ``None``, the top of the tree will be placed at time 0
  
              ``show_plot`` (``bool``): ``True`` to show the plot, otherwise ``False`` to only return the dictionary. To plot multiple LTTs on the same figure, set ``show_plot`` to False for all but the last plot
  
              ``color`` (``str``): The color of the resulting plot
  
              ``title`` (``str``): The title of the resulting plot
  
              ``xmin`` (``float``): The minimum value of the horizontal axis in the resulting plot
  
              ``xmax`` (``float``): The maximum value of the horizontal axis in the resulting plot
  
              ``xlabel`` (``str``): The label of the horizontal axis in the resulting plot
  
              ``ymin`` (``float``): The minimum value of the vertical axis in the resulting plot
  
              ``ymax`` (``float``): The maximum value of the vertical axis in the resulting plot
  
              ``ylabel`` (``str``): The label of the vertical axis in the resulting plot
  
          Returns:
              ``dict``: A dictionary in which each ``(t,n)`` pair denotes the number of lineages ``n`` that existed at time ``t``
          '''
          if present_day is not None and not isinstance(present_day,int) and not isinstance(present_day,float):
              raise TypeError("present_day must be a float")
          time = dict()
          if self.root.edge_length is None:
              tmproot = self.root
          else:
              tmproot = Node(); tmproot.add_child(self.root)
          for node in tmproot.traverse_preorder():
              if node.is_root():
                  time[node] = 0.
              else:
                  time[node] = time[node.parent]
                  if node.edge_length is not None:
                      time[node] += node.edge_length
          nodes = sorted((time[node],node) for node in time)
          lineages = {nodes[0][0]:0}
          for i in range(len(nodes)):
              if nodes[i][0] not in lineages:
                  lineages[nodes[i][0]] = lineages[nodes[i-1][0]]
              if nodes[i][1].edge_length is not None:
                  if nodes[i][1].edge_length >= 0:
                      lineages[nodes[i][0]] -= 1
                  else:
                      lineages[nodes[i][0]] += 1
              for c in nodes[i][1].children:
                  if c.edge_length >= 0:
                      lineages[nodes[i][0]] += 1
                  else:
                      lineages[nodes[i][0]] -= 1
          if present_day is not None:
              shift = present_day - max(lineages.keys())
          else:
              shift = max(0,-min(lineages.keys()))
          if shift != 0:
              tmp = dict()
              for t in lineages:
                  tmp[t+shift] = lineages[t]
              lineages = tmp
          if tmproot != self.root:
              self.root.parent = None
          try:
              plot_ltt(lineages, show_plot=show_plot, color=color, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, title=title, xlabel=xlabel, ylabel=ylabel)
          except Exception as e:
              warn("Unable to produce visualization (but dictionary will still be returned)"); print(e)
          return lineages