Counting graphs according to recursion depth Consider the set $S$ of multigraphs defined recursively as follows:

Example Graph Class
A graph $G$ is in $S$ if(f)
  
  
*
  
*$G$ is a loop on a single vertex, or 
  
*$G$ may be obtained by selecting a graph $G'\in S$ and applying one of the following operations:
  
  
*
  
*Add an edge between two extant vertices, or
  
*Split an edge (add a vertex halfway along an edge) and add an edge between the newly created vertex and any vertex.
  
  

I am studying a number of recursively constructed graph classes similar to this example. In particular, for each of these classes I would like to count the number of unlabeled graphs that can be produced after $n$ applications of a set of graph operations similar to the above.
Continuing our example, the graphs counted for $n=1,2,$ and $3$ are pictured here:

My questions:


*

*Are there are any general combinatorial techniques used to count graphs in this setting?

*Regardless of the existence of general techniques, how might you go about counting my example above?
I am aware of the Polya enumeration theorem, but was unsure if the extra recursive information might be better leveraged with some other technique, or whether this particular statistic would make it difficult to apply Polya's theorem. Importantly, whether or not a graph is counted for a particular $n$ is not directly related to neither the number of vertices nor the number of edges in the graph.
Thank you.
 A: Your picture is missing some graphs. 
There should be 11 graphs on level 3. 
You are for example missing the graph with edges {12,12,23,23,33}. The sequence I get is {1, 3, 11, 61, 484,...} with no hit in the OEIS.
Relevant Mathematica code:
(* Define lex-smallest version of graph structure. *)

GraphCanonicalize[struct_List] := Module[{verts, perms, range},
   verts = Union@Cases[struct, _Integer, 2];
   range = Range@Length@verts;
   perms = 
    Sort@Table[
      Sort[Sort /@ (struct /. Thread[verts -> p])], {p, 
       Permutations[range]}];
   Do[
    GraphCanonicalization[pp] = First[perms];
    , {pp, perms}];
   GraphCanonicalization[struct] = First[perms];
   ];
GraphCanonicalization[struct_List] := (GraphCanonicalize[struct]; 
   GraphCanonicalization[struct]);

graphs[1] := {{{1, 1}}};
graphs[n_Integer] := Module[{childs, prev = graphs[n - 1]},

   childs[g_] := Module[{vs = Union[Join @@ g]},

     GraphCanonicalization /@ Join[

       (* Add edge *)
       Table[
        Append[g , edge]
        , {edge, Subsets[vs, {2}]}]
       ,
       (* Add loop *)
       Table[
        Append[g , {v, v}]
        , {v, vs}]

       ,
       (* Split edge and add extra edge to this new vertex. *)

       Join @@ Table[
         Join[
          DeleteCases[g, edge, 1, 
           1], { {edge[[1]], n}, {edge[[2]], n}, {nv, n}}]
         , {edge, g}, {nv, Append[vs, n]}]
       ]

     ];

   Union[Join @@ (childs /@ prev)]
   ];

Table[Length@graphs[k], {k, 1, 5}]

