Fill the plane with pentagons as tightly as possible in a regular way I wrote a small python script with recursion to create a "lattice" of non-overlapping pentagons. Below one can see the first stages of recursion.







One can see that 5 small pentagons are missing in the second stage of recursion. The code in python to generate these figures is this:

# fill the plane with pentagons as tightly as possible in a regular way
#!/usr/bin/python
import numpy as np
import matplotlib.pyplot as plt
N = 5
phi = (1.0+np.sqrt(5.0))/2
def pentagon (X, Y, n):
    if n == 0:
        rx = np.append(X, X[0])
        ry = np.append(Y, Y[0])
        plt.plot(rx, ry, 'r-')
        return
    for i in range(N):
        Xn = np.array([X[i], X[i], X[i], X[i], X[i]])
        Yn = np.array([Y[i], Y[i], Y[i], Y[i], Y[i]])
    U = Xn/phi+X*(1-1.0/phi)
    V = Yn/phi+Y*(1-1.0/phi)
    pentagon (U, V, n-1)
Xn = X/phi +np.roll(X, 2)*(1-1.0/phi)
Yn = Y/phi +np.roll(Y, 2)*(1-1.0/phi)
# center pentagon
pentagon (Xn, Yn, n-1)
Ind = np.arange(N)
theta =np.pi/10
X = np.cos(Ind*2*np.pi/N+theta)
Y = np.sin(Ind*2*np.pi/N+theta)
plt.figure()
plt.axes().set_aspect('equal')
n_iter = 2 # number of iterations
pentagon (X, Y, n_iter)
figure = "pentagons%d.png" % n_iter
plt.axis('off')
plt.savefig(figure)
plt.show()


Any suggestions on how to fill in the missing pentagons in a simple way (e.g. keeping the recursive nature of the algorithm)?
If I understand the general idea correctly, you are going to close the gaps which are appearing after further structure growth. I cannot do it algorithmically but geometrically it is quite easy to do. I use Illustrator here and manually cover the gaps with two additional shapes.  

So in addition to the pentagon and flat rhombus, I will need a 5-fold star and another rhombus:  



So after first steps we get such a structure and the filling will be:  



(Initial center is marked red)  

I don't fill all holes and I leave out the obvious ones just to make arrangements more visible.

Then next step will give this:  



Here I do only halves of crack fillings, those are symmetrical. As seen those cracks indeed can be covered using same shapes without gaps and have self-similar patterns. How this can be achieved algorithmically, I don't know unfortunatelly. But this is interesting question, probably there are solutions somewhere, IDK.  

Theoretically if one analyse several crack fillings for each step, one can guess a relatively
simple algorithm.