I will show how to build The Oracle of Bacon in Wolfram Language (WL) using a small database of a few 100s actors. This can be easily generalized to many 1000s by a simple parameter change, but here we will keep it small so the graph theory objects can be visualized. Six degrees of separation is a theory proposed by Frigyes Karinthy in 1929. It suggests that any 2 people in the world are are 6 or fewer acquaintance links apart. This idea found its analogy in a parlor game Six Degrees of Kevin Bacon where film-knowledgable people compete to find shortest path between and arbitrary actor and revered Kevin Bacon. It assumes that any Hollywood actor can be linked to Kevin Bacon via at most 6 links - each linked formed when two actors participate in the same movie. Idea became very popular and lead to creation of a website called The Oracle of Bacon: http://oracleofbacon.org where you can find the shortest movie path linking 2 actors and see other related information.

We will show that inside our database there is no longer chain than FIVE. Most remote actors are "Audrey Tautou" and "Ray Romano". Below are typical results of our Oracle:

• Movie-path between given actors - here "Claire Danes" and "Jennifer Garner"
• Community nearest-neighbor sub-graph around the movie path
• Black names - linked actors
• Red names - enablers or hubs - actors who has most connections and around which communities are gathered in the subgraph of 2 given actors

So let's get to it - building the "The Oracle of Bacon". First we need to build a database of actors and movies they played in. There are many ways to do this - including using built-in WL data from Wolfram|Alpha - but lets make things more flexible - use external and internal data. We start from external data - scraping Forbes magazine top-charts webpages for leading actors:




Now let's use built-in data from Wolfram|Alpha and get the movies they played in:


Because of very large set some data will be missing - let's filter those out and build the database:


Now we can get all actors and see how many we have as:


A typical database entry is


Let's construct "adjacency matrix function" which will build a link between any 2 actors if they played in the same movie. And then we use it to compute adjacency matrix for all actors in database - excluding diagonal self-links. Then finally we build "adjacency graph" based on adjacency matrix.


To check if an actor is in the database simply run


If an actor is not there you'll get


Pick any 2 actors in data base and find shortest path between them:


Let's see how the path looks in "portrait" ;-)




Let's find a nearest-neighbor subgraph along the path in our huge adjacency graph:



It has 83 vertices - basically 83 actors influencing this specific path:


This will list all actors along the path and group them in communities of most tightly related people according to graph measure called Modularity:


Let's visualize these communities. Red names that label communities are enablers or hubs - most influential connection-wise actors:




Let's do some text/string processing and format path-movie-actor chain in a readable form:




Finally we can ask a question what is the largest distance between any 2 actors in our database? Is it larger than 6 ? Turns out is is FIVE ! ;-)


Who are they?


What is the path?


This was fun ;-) I hoped enjoyed it. Feel free to experiment, suggest, optimize and comment!