You have at least one error:

i += i # Counts the number of times the loop has be exicuted.

This should be:

i += 1

and wouldn't need a comment if the variable was named e.g. loop_count (see below on variable naming). Having said that, you never actually use the value of i (which is probably why you never noticed it was always zero), so perhaps you should reconsider including it at all.

parsimonyPower = input("Please enter the leap-penalty power: ")

Should be

parsimonyPower = int(raw_input("Please enter the leap-penalty power: "))

to ensure that you are getting the correct type of input. You can add validation, too; see e.g. this SO question.

The loop

j = 0 
while (j < numChords):
    ...
    j += 1

could be simplified to

for _ in range(numChords):
    ...

As you don't need the value of j within the loop, and break in the only case where you don't increment.

imports should be in a separate block, in alphabetical order (three separate blocks for standard library, third-party and local modules, but that's not relevant here):

from ast import literal_eval
import itertools
import math
from random import triangular
import time

Many of your lines are too long:

Limit all lines to a maximum of 79 characters.

For flowing long blocks of text with fewer structural restrictions (docstrings or comments), the line length should be limited to 72 characters.

Many of your variable names are unclear (v1? v2? v3?) or don't follow the Python conventions (numChords should be num_chords, for example).

Python has standards for documentation strings; your comment blocks don't follow them. Also, better variable names would remove the need for many of your inline comments, some of which are trivial anyway (commenting print, sum and int seems especially pointless):

def parsimony_ranking(parsim_power, start_set, deriv_set):
    """Calculate the distance between the starting and derivative sets.

    Each value representing the distance between the elements of
    start_set and deriv_set is raised to the power of parsim_power, in
    order to account for the relative different in parsimoniesness for
    chord changes incorporating large leaps between elements.

    """
    distances = tuple(map(lambda x, y: math.pow(abs(x - y), parsim_power), 
                      start_set, deriv_set))
    return int(math.floor(sum(distances)))

You have far too much code in the body of your script. Almost everything should be wrapped up into separate functions, so that all that is left to run when the script is run directly is something like:

if __name__ == "__main__":
    start_time = time.time()
    print "=== The Parsimony Tool program has started running. This may take a while. ==="
    # a few function calls
    # ...
    print ("\n")
    print ("=== The Parsimony Tool program has finished running. ===")
    print ("=== The time requiered was %s seconds. ===" % (time.time() - start_time))

The if __name__ ... guard means that this won't run when your script is imported elsewhere, making it easier to reuse this functionality in the future.