My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <cmath>
       
 
       
// return area of a circle

       
double getArea(double radius)
       
{
       
  return radius * radius * 3.14159265358979323846 / 4;
       
}
       
 
       
// return sum of touching circles' areas including their children

       
double evaluate(double k1, double k2, double k3, unsigned int depth)
       
{
       
  // https://en.wikipedia.org/wiki/Descartes%27_theorem
       
  auto k4 = k1 + k2 + k3 + 2 * sqrt(k1*k2 + k2*k3 + k1*k3);
       
 
       
  // area of the current circle
       
  auto radius = 1 / k4;
       
  auto area   = getArea(radius);
       
  // done ?
       
  if (depth == 1)
       
    return area;
       
 
       
  // keep going ...
       
  return area + evaluate(k1, k2, k4, depth - 1) +
       
                evaluate(k2, k3, k4, depth - 1) +
       
                evaluate(k1, k3, k4, depth - 1);
       
}
       
 
       
int main()
       
{
       
  // nesting level
       
  unsigned int depth = 10;
       
  std::cin >> depth;
       
 
       
  // the big circle can be computed with Descartes theorem
       
  // k1 = k2 = k3 = 1 and k4 = k1 + k2 + k3 + 2*sqrt(k1 + k2 + k3)
       
  // => k4 = 3 +- 2*sqrt(3)
       
  // case A: k4 = 3 + 2*sqrt(3) => radius approx. 0.1547 => that's the small circle between the three circles
       
  // case B: k4 = 3 - 2*sqrt(3) => radius approx. 2.1547 => that's the big circle I'm looking for
       
  auto outerK      = 3 - 2 * sqrt(3);
       
  auto outerRadius = -1 / outerK; // note: outerK is negative
       
 
       
  // the first three circle have radius = 1
       
  auto innerRadius = 1.0;
       
  auto innerK      = 1 / innerRadius;
       
 
       
  // (fully covered)  area of the first three circles
       
  auto initial = 3 * getArea(innerRadius);
       
  // (partially full) three identical V-shaped areas between two circles and the big circle
       
  auto vShaped = evaluate(outerK, innerK, innerK, depth);
       
  // (partially full) small area between the first three circles
       
  auto middle  = evaluate(innerK, innerK, innerK, depth);
       
 
       
  // total covered area
       
  auto result = initial + 3 * vShaped + middle;
       
  // as a percentage of the big circle
       
  result /= getArea(outerRadius);
       
  // empty = 100% - covered
       
  std::cout << 1 - result << std::endl;
       
  return 0;
       
}

This solution contains 9 empty lines, 19 comments and 2 preprocessor commands.