def energy(self):
     grid = self.get_grid()
     try:
         solver.solve(self.width, self.height, grid)
     except Exception:
         return self.size + 1
     return self.shown.count(True)

def simplex_step(A, b, c, R_square, show_bases=False):
    if show_bases: print("basis: ", R_square)
    R = A.D[0]
    # Extract the subsystem
    A_square = Mat((R_square, A.D[1]), {(r,c):A[r,c] for r,c in A.f if r in R_square})
    b_square = Vec(R_square, {k:b[k] for k in R_square})
    # Compute the current vertex
    x = solve(A_square, b_square)
    print("(value: ",c*x,") ",end="")
    # Compute a possibly feasible dual solution
    y_square = solve(A_square.transpose(), c) #compute entries with labels in R_square
    y = Vec(R, y_square.f) #Put in zero for the other entries
    if min(y.values()) >= -1e-10: return ('OPTIMUM', x) #found optimum!
    R_leave = {i for i in R if y[i]< -1e-10} #labels at which y is negative
    r_leave = min(R_leave, key=hash) #choose first label at which y is negative
    # Compute the direction to move
    d = Vec(R_square, {r_leave:1})
    w = solve(A_square, d)
    # Compute how far to move
    Aw = A*w # compute once because we use it many times
    R_enter = {r for r in R if Aw[r] < -1e-10}
    if len(R_enter)==0: return ('UNBOUNDED', None)
    Ax = A*x # compute once because we use it many times
    delta_dict = {r:(b[r] - Ax[r])/(Aw[r]) for r in R_enter}
    delta = min(delta_dict.values())
    # Compute the new tight constraint
    r_enter = min({r for r in R_enter if delta_dict[r] == delta}, key=hash)[0]
    # Update the set representing the basis
    R_square.discard(r_leave)
    R_square.add(r_enter)
    return ('STEP', None)

def test():
    problem = Problem(
        id='6nXC7iyndcldO1dvKHbBmDHv',
        size=6, operators=frozenset(['not', 'shr4', 'shr16', 'shr1']))
    problem.solution = '(lambda (x_5171) (shr4 (shr16 (shr1 (not x_5171)))))'

    server = Server([problem])

    solve(problem, server)

def test():
    """
    Solves the systems and tests on their number of solutions.
    """
    from phcpy2c import py2c_set_seed
    py2c_set_seed(234798272)
    import solver
    print '\nsolving a random binomial system...'
    pols = binomials()
    sols = solver.solve(pols)
    assert len(sols) == 20
    print 'test on binomial system passed'
    print '\nsolving the cyclic 7-roots problem...'
    pols = cyclic7()
    sols = solver.solve(pols)
    assert len(sols) == 924
    print 'test on cyclic 7-roots passed'
    print '\nsolving the benchmark problem D1...'
    pols = sysd1()
    sols = solver.solve(pols)
    assert len(sols) == 48
    print 'test on benchmark problem D1 passed'
    print '\nsolving a generic 5-point 4-bar design problem...'
    pols = fbrfive4()
    sols = solver.solve(pols)
    assert len(sols) == 36
    print 'test on 4-bar system passed'
    print '\ncomputing all Nash equilibria...'
    pols = game4two()
    sols = solver.solve(pols)
    assert len(sols) == 9
    print 'test on Nash equilibria for 4 players passed'
    print '\nsolving a problem in magnetism...'
    pols = katsura6()
    sols = solver.solve(pols)
    assert len(sols) == 64
    print 'test on a problem in magnetism passed'
    print '\nsolving a neural network model...'
    pols = noon3()
    sols = solver.solve(pols)
    assert len(sols) == 21
    print 'test on a neural network model passed'
    print '\nsolving a mechanical design problem...'
    pols = rps10()
    sols = solver.solve(pols)
    assert len(sols) == 1024
    print 'test on RPS serial chains problem passed'
    print '\nsolving a fully real Stewart-Gough platform...'
    pols = stewgou40()
    sols = solver.solve(pols)
    assert len(sols) == 40
    print 'test on real Stewart-Gough platform passed'
    print '\ncomputing all tangent lines to 4 spheres...'
    pols = tangents()
    sols = solver.solve(pols)
    assert len(sols) == 6
    print 'test on multiple tangent lines to spheres passed'

def find_hole(expression,lower,upper): #Finds the holes of a function in a range
    x = Symbol("x")
    y = sympify(expression)
    forward_open = ['[','('] #List of 'open' separators
    forward_close = [']',')'] #List of 'closed' separators
    separators = ['+','-'] # Neutral separators
    exists = 0 
    found = []
    term_list = []
    holes = []
    while exists != -1: #Finds all division signs in the expression
        exists = expression.find('/',exists)
        if exists != -1:
            found.append(exists)
            exists=exists+1
    for a in found: #For each division sign, find denominator
        counter = 0
        term_indexes = [a+1]#List of indexes of denominator and numerator
        index = a+1 #Starting index of denominator
        while len(term_indexes) < 2: #This loop finds the end of the denomninator
            if index >= len(expression): #If end of expression is reached, append index for end of expression
                term_indexes.append(len(expression))
            elif expression[index] in forward_open: #If open separator found, add to counter
                counter += 1
            elif expression[index] in forward_close: #If closed separator found, subtract from counter
                counter -= 1
                if counter <= 0:# If end of term reached, append current index
                    term_indexes.append(index)
            elif expression[index] in separators and counter == 0: #If neutral separator found, and separators are paired, append current index
                term_indexes.append(index)
            index += 1 #Move forward one index
        index = a-1 #Ending index of numerator
        counter = 0
        while len(term_indexes) < 3: #This loop finds the beginning of the numerator
            if index < 0: #If beginning of expression reached, append index for beginning
                term_indexes.append(0)
            elif expression[index] in forward_close: #If closed separator found, add to counter
                counter += 1
            elif expression[index] in forward_open: #if open separator found, subtract form counter.
                counter -= 1
                if counter <= 0: #If end of term reached, append current index
                    term_indexes.append(index+1)
            elif expression[index] in separators and counter == 0: #If neutral separator found and separators are paired, append current index
                term_indexes.append(index)
            index -= 1 #Move back one index
        term_indexes.append(a) #Append endpoint of numerator
        term_list.append(term_indexes) 
    for b in term_list: #Solves numerator and denominator to find holes
        denominator = expression[b[0]:b[1]] #Slice denominator
        numerator = expression[b[2]:b[3]] #Slice numerator
        d_solution = solv.solve(denominator,0) #Solve denominator
        n_solution = solv.solve(numerator,0) #Solve numerator
        for c in d_solution: #Find matching solutions in given range
            if c in n_solution and c >= lower and c<= upper:
                holes.append([c,limit(y,x,c)])
    return holes

def problem2():
    T = Mat((set([0, 1, 2, 3]), set([0, 1, 2, 3])), {(0, 1): 0.25, (1, 2): 0.0, (3, 2): 0, (0, 0): 1, (3, 3): 1, (3, 0): 0, (3, 1): 0, (2, 1): 0, (0, 2): 0.75, (2, 0): 0, (1, 3): -0.25, (2, 3): 0, (2, 2): 1, (1, 0): 0, (0, 3): 0.5, (1, 1): 1})
    b1 = Vec({0, 1, 2, 3}, {2: 1})
    b2 = Vec({0, 1, 2, 3}, {3: 1})
    print(T)
    print(b1)
    print(b2)
    x1 = solve(T, b1)
    x2 = solve(T, b2)
    
    print([x1,x2])

def is_superfluous(L, i):
    '''
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous(L, 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    '''
    assert i in range(len(L))
    if len(L) > 1:
        colVecs = coldict2mat({ x : L[x] for x in range(len(L)) if x != i })
        u = solve(colVecs, L[i])
        residual = L[i] - colVecs * u
    else:
        residual = 1
    return residual * residual < 10e-14

def is_superfluous(L, i):
    '''
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous(L, 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    '''
    dist= len(L)
    if dist == 1: return False
    A= coldict2mat([L[j] for j in range(dist) if i != j])
    b= L[i]
    u= solve(A,b)
    residual= b - A*u
    return (residual*residual) < 1E-14

def is_superfluous(L, i):
    '''
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    '''
    if len(L) <= 1:
        return False
    
    # remove L[i] without changing the list (i.e. w/o using L.pop())
    b = L[i] # RHS of A*u = b
    A = coldict2mat(L[:i] + L[i+1:]) # coefficient matrix L w/o L[i]
    u = solve(A, b)
    e = b - A*u
    
    return e*e < 1e-14

def is_superfluous(L, i):
    '''
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous(L, 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([ a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    '''
    b = L.pop(i)
    u = solve(coldict2mat(L),b)
    residual = b - coldict2mat(L)*u
    if residual * residual < 10e-14:
        return True
    else:
        return False

def solve():
    line = request.args.get('line', '', type=str)
    sort = request.args.get('sortby', 'scoreD', type=str)
    words = solver.solve(line, sort)
    data = { 'words': [ x.__dict__ for x in words], }

    return jsonify(data)

def is_superfluous(L, i):
    """
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous(L, 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    """
    if len(L) > 1:
        b = L.pop(i)
        A = coldict2mat(L)
        u = solve(A, b)
        residual = b - (A * u)
        condition = u != Vec(A.D[1], {}) and residual * residual < 10 ** -14
        L.insert(i, b)
    else:
        return False
    return condition

def example4():
  '''Modified problem without the final statement by Albert.'''
  dialogue = '''
    Albert: I don't know when Cheryl's birthday is, but I know that Bernard does not know too.
    Bernard: At first I don't know when Cheryl's birthday is, but I know now.
  '''
  return solver.solve(Cheryl.possibilities, Cheryl.projections, dialogue, Cheryl.goal)

def timeitWithPre():
	import solver
	import GenerateChars
	chars = GenerateChars.generate()
	chars = ['i', 'u', 'e', 'z', 't', 'w', 'd', 'j', 'u']
	wordmap = solver.preprocessing()
	result = solver.solve(wordmap, chars)	

def QR_solve(A, b):
    '''
    Input:
        - A: a Mat
        - b: a Vec
    Output:
        - vector x that minimizes norm(b - A*x)
    Example:
        >>> domain = ({'a','b','c'},{'A','B'})
        >>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2})
        >>> Q, R = QR.factor(A)
        >>> b = Vec(domain[0], {'a': 1, 'b': -1})
        >>> x = QR_solve(A, b)
        >>> result = A.transpose()*(b-A*x)
        >>> result * result < 1E-10
        True

I used the following as args to triangular_solve() and the grader was happy:
rowlist = mat2rowdict(R) (mentioned in the pdf)
label_list = sorted(A.D[1], key=repr) (mentioned in the pdf)
b = c vector b = Vec(domain[0], {'a': 1, 'b': -1})(mentioned above and on slide 1 of orthogonalization 8)        
    '''

    Q, R = QR.factor(A)
    rowlist = mat2rowdict(R)
    label_list = sorted(A.D[1], key = repr)
    return solve(A,b)

def is_superfluous(L, i):
    '''
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous(L, 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    '''
    if len(L) == 1:
        return False

    Li = L.pop(i)
    mL = coldict2mat(L)
    sol = solve(mL,Li)
    res = Li - mL * sol
    if abs(res*res) < 10**-14:
        return True
    else:
        return False

def test_track(silent=True, precision='d', decimals=80):
    """
    Tests the path tracking on a small random system.
    Two random trinomials are generated and random constants
    are added to ensure there are no singular solutions
    so we can use this generated system as a start system.
    The target system has the same monomial structure as
    the start system, but with random real coefficients.
    Because all coefficients are random, the number of
    paths tracked equals the mixed volume of the system.
    """
    from solver import random_trinomials, real_random_trinomials
    from solver import solve, mixed_volume, newton_step
    pols = random_trinomials()
    real_pols = real_random_trinomials(pols)
    from random import uniform as u
    qone = pols[0][:-1] + ('%+.17f' % u(-1, +1)) + ';'
    qtwo = pols[1][:-1] + ('%+.17f' % u(-1, +1)) + ';'
    rone = real_pols[0][:-1] + ('%+.17f' % u(-1, +1)) + ';'
    rtwo = real_pols[1][:-1] + ('%+.17f' % u(-1, +1)) + ';'
    start = [qone, qtwo]
    target = [rone, rtwo]
    start_sols = solve(start, silent)
    sols = track(target, start, start_sols, precision, decimals)
    mixvol = mixed_volume(target)
    print 'mixed volume of the target is', mixvol
    print 'number of solutions found :', len(sols)
    newton_step(target, sols, precision, decimals)

def direct_sum_decompose(U_basis, V_basis, w):
    '''
    input:  A list of Vecs, U_basis, containing a basis for a vector space, U.
    A list of Vecs, V_basis, containing a basis for a vector space, V.
    A Vec, w, that belongs to the direct sum of these spaces.
    output: A pair, (u, v), such that u+v=w and u is an element of U and
    v is an element of V.
    
    >>> U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
    >>> V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
    >>> w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
    >>> direct_sum_decompose(U_basis, V_basis, w) == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
    True
    '''
    sum_base = U_basis + V_basis
    # find coefficients
    composed_result = solve(coldict2mat(sum_base),w)
    # calculate u
    u = Vec(U_basis[0].D,{})
    for i in range(len(U_basis)):
        u += composed_result[i] * U_basis[i]
    # calculate v
    v = Vec(V_basis[0].D,{})
    for i in range(len(U_basis), len(sum_base)):
        v += composed_result[i] * V_basis[i-len(U_basis)]
    return (u,v)  

def is_superfluous(L, i):
    '''
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous(L, 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    '''
    assert i in range(len(L))
    A = coldict2mat({c:L[c] for c in range(len(L)) if c!=i})
    residual = L[i] - A*solve(A, L[i])
    if residual * residual < 1e-14:
        return True
    return False

def is_superfluous(L, i):
    '''
    Input:
        - L: list of vectors as instances of Vec class
        - i: integer in range(len(L))
    Output:
        True if the span of the vectors of L is the same
        as the span of the vectors of L, excluding L[i].

        False otherwise.
    Examples:
        >>> a0 = Vec({'a','b','c','d'}, {'a':1})
        >>> a1 = Vec({'a','b','c','d'}, {'b':1})
        >>> a2 = Vec({'a','b','c','d'}, {'c':1})
        >>> a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 3)
        True
        >>> is_superfluous([a0,a1,a2,a3], 0)
        True
        >>> is_superfluous([a0,a1,a2,a3], 1)
        False
    '''
    assert(len(L) > 0)
    assert(i < len(L))

    if len(L) == 1:
        return True

    mtx = coldict2mat([ L[j] for j in range(len(L)) if j != i ])
    u = solve(mtx,L[i])

    residual = mtx * u - L[i]
    return residual * residual < 10e-14