private int findLargestRing(String rootIdentityName) {
		// Given an identity name, we find all 'paths' to other identities via vouchings,
		// Stopping when we see a cycle. We keep the paths where the 'root' identity
		// Is also the final identity, ie a ring-of-trust which the root participates in.
		// We return the length of the longest such ruing.

		// 'finished' paths are those which form a ring with the root identity
		ArrayList<ArrayList<String>> unfinishedPaths = new ArrayList<ArrayList<String>>();
		ArrayList<ArrayList<String>> finishedPaths = new ArrayList<ArrayList<String>>();

		// Initial path lists are the individual parents of the root.
		for (String parentKey: findParentKeys(rootIdentityName)) {
			// A certificate is inherently self-vouched; we must not double-count
			// this vouching if an identity has EXPLICITLY vouched for its certificate
			if (parentKey.equals(rootIdentityName)) continue;
			ArrayList<String> basePath = new ArrayList<String>(Arrays.asList(parentKey));
			unfinishedPaths.add(basePath);
		}
		
		// We keep building identity paths until either they form a loop, or there are no
		// parents. 
		while (unfinishedPaths.size() > 0) {
			ArrayList<ArrayList<String>> nextGeneration = new ArrayList<ArrayList<String>>();

			for (ArrayList<String> path: unfinishedPaths) {
				String lastKey = path.get(path.size() - 1);


				for (String parentKey: findParentKeys(lastKey)) {
					// We bifurcate the path when there are multiple parents
					ArrayList<String> newPath = (ArrayList<String>) path.clone();

					newPath.add(parentKey);

					if (parentKey.equals(rootIdentityName)) {
						// We have found a cycle involving the root
						finishedPaths.add(newPath);
					} else if (! path.contains(parentKey)) {
						// We have NOT found a cycle which excludes the node
						nextGeneration.add(newPath);
					}
				}
				unfinishedPaths = nextGeneration;	
			}
		}

		// Find the largest length of a cycle path
		int largestRingSeen = 0;
		for (ArrayList<String> path: finishedPaths) {
			if (path.size() > largestRingSeen) {
				largestRingSeen = path.size();
			}
		}

		return largestRingSeen;
	}