Is it possible to tile the pane with a semi-regular tesselation given only the vertex type? I want to write a computer program that tessellates the plane with semi regular tiling, i.e these tilings:
https://en.wikipedia.org/wiki/List_of_convex_uniform_tilings
If I start with the vertex figure of a tile, (a sequence of regular polygons arranged around a vertex, each with a number of sides corresponding to it's index in the vertex type list.)
e.g: vertex type 3,3,3,4,4 
https://en.wikipedia.org/wiki/List_of_convex_uniform_tilings#/media/File:Tiling_33344-vertfig.png
Is it possible to extend the tiling by only looking at each open vertex (a vertex that doesn't yet have all of the polygons of the sequence attached) and figuring out what the next polygon in sequence should be? 
As far as I understand, with semi regular tiling, each vertex always has the same polygons in the "same order" - however, the order isn't always consistent, it can be reversed, or offset. e.g if the vertex figure is 3,3,3,4,4 and I pick the second polygon in the sequence, I know it's index in the current sequence, but the next sequence of polygons attached to it's open vertex could be 4,4,3,3,3 or 3,4,4,3,3
Does this mean it's not possible to tile the plane with the vertex figure of a semi-regular tiling? If it is possible how do I do it?
I know that I can tile the plane by translating a selection of polygons from a semi-regular tiling (a "translational unit"). However that doesn't work if that selection is the vertex figure. It's unclear to me what a general system is for finding that "translational unit", other than hand selecting each group of polygons to be translated. 
 A: Semi-regularity does imply uniformity and that does imply isogonality (same vertex figure), but not the other way round.
A counter-example in the realm of polyhedra is the Johnson figure J37 aka Miller's solid, cf. https://en.wikipedia.org/wiki/Elongated_square_gyrobicupola.
The same could be reproduced in the realm of tilings too. Consider the vertex figure of 3 red plus one green square. Then align a fully red row of squares. Any choice at a single vertex at the one rim of your so-far patch would then provide all other vertices of that rim consistently. But at the opposite rim of that patch you once again could apply either choice!

| g | r | g | r |
+---+---+---+---+
| r | r | r | r |
+---+---+---+---+
| g | r | g | r |
vs.


| g | r | g | r |
+---+---+---+---+
| r | r | r | r |
+---+---+---+---+
| r | g | r | g |

--- rk
A: I have written such a program, You can find the latest version here.
To answer Your question - it is sort of possible, but looking from the vertex perspective only, You need additional information.
Unfortunately I cannot provide definitive mathematic proof only empirical findings.
The algorithm I built (as a tool for my thesis project) is recursive, and processes each vertex separately. Each different tessellation is defined by order of angles around the vertex, as well as list of angle indexes from which angle to start at the specific next vertex. As You noted, the order sometimes changes - my empirical investigation shows, that these can be all in one cycle or form several cycles, this is why it is not trivial to notice the pattern.
Each step of the recursion on a new vertex thus needs some information from the previous vertex - the angle at which the vertex was reached from previous vertex, as well as which angle in the tessellation it was. Additionally information on wether the previous vertex was being processed clockwise or anti-clockwise is also important, as the next vertex is allways processed in the oposite direction.
For more information see the linked source code.
To test the tesselator in practice, You can use the sample Jupyter notebook.
The provided tessellator library is used as follows:
from tessellator import Tessellator

tessellator = Tessellator(algorithm = "3.3.3.4.4", bounds = your_bounding_shape, edge_length = 1, maximum_iterations = 10000)
tessellator.generate(start_point,start_angle)
tess_result = tessellator.get_generated_grid()

Where maximum iterations is needed for the recursion to end if no bounds are set, bounds is any closed shape, and point parameter for generate() is any point within that bound. The shapely Python library is extensively used in the code.
Hope this helps, and maybe someone can help make this answer more formal.
A: As long as you restrict yourself to Euclidean plane, the vertex sequence determines the uniform tiling uniquely, with the exception of (6,3,3,3,3) which is chiral.
The moment you go into hyperbolic plane, you may encounter situations where one vertex sequence generates several distinct tilings (for example, (6,6,6,3) has three uniform solutions).
Some of these can be demonstrated in Euclidean plane if you extend the definition of tiling a bit -- like rk's example with colored squares. Another way to extend the definition is to permit digons: for example (6,6,6,2) is a planar tiling with three hexagons and one digon which can be displayed like a bold edge. Three hyperbolic solutions of (6,6,6,3) then transform in three distinct uniform ways how to bold one edge per vertex of (6,6,6).
