Testing Fibonacci conjecture
As always, the first option is to use PyPy:

&gt;&gt;&gt; time python2 p.py 0 30000
[]
14.4747481346
python2 p.py 0 30000  14.50s user 0.01s system 100% cpu 14.500 total

&gt;&gt;&gt; time pypy p.py 0 30000 
[]
0.990810871124
pypy p.py 0 30000  1.06s user 0.03s system 99% cpu 1.098 total


You shouldn't use star imports. Instead directly import the things you want:

from fibonacci_conjecture import is_fibo, is_prime


You should wrap the main body in a function called main.

The iteration would be better as a generator:

def get_falsifiers(start, end):
    for i in range(int(start), int(end)):
        if is_prime(5*i*i+37) and is_fibo(5*i*i+37):
            yield i


This would be run as:

_list = list(get_falsifiers(start, end))


Note that _list is a poor naming choice since it refers to the type and not the value. Something like falsifiers would be better.

These:

def fibonacci_conjecture(end):
    return (True not in map(is_prime, [fibo(i)*fibo(i)+41 for i in range(end+1)]))

def second_way(end):
    return (True not in map(is_prime, [i**2+41 for i in range(end+1) if is_fibo(i)]))

def third_way(end):
    return (True not in map(is_prime, [fibo(i)*fibo(i)+41 for i in range(end+1) if minus_four(i)]))


would be better as

def fibonacci_conjecture(end):
    return not any(map(is_prime, [fibo(i)*fibo(i)+41 for i in range(end+1)]))

def second_way(end):
    return not any(map(is_prime, [i**2+41 for i in range(end+1) if is_fibo(i)]))

def third_way(end):
    return not any(map(is_prime, [fibo(i)*fibo(i)+41 for i in range(end+1) if minus_four(i)]))


Further one should flatten the list comprehensions and map:

def fibonacci_conjecture(end):
    return not any([is_prime(fibo(i)*fibo(i)+41) for i in range(end+1)])

def second_way(end):
    return not any([is_prime(i**2+41) for i in range(end+1) if is_fibo(i)])

def third_way(end):
    return not any([is_prime(fibo(i)*fibo(i)+41) for i in range(end+1) if minus_four(i)])


You also then can just use a generator comprehension:

def fibonacci_conjecture(end):
    return not any(is_prime(fibo(i)*fibo(i)+41) for i in range(end+1))

def second_way(end):
    return not any(is_prime(i**2+41) for i in range(end+1) if is_fibo(i))

def third_way(end):
    return not any(is_prime(fibo(i)*fibo(i)+41) for i in range(end+1) if minus_four(i))


Your fibo(i)*fibo(i) requires two calls to fibo - this can be one with fibo(i) ** 2. Consider also using PEP 8 spacing. You can also remove the if in place and an and:

def fibonacci_conjecture(end):
    return not any(is_prime(fibo(i) ** 2 + 41) for i in range(end+1))

def second_way(end):
    return not any(is_fibo(i) and is_prime(i ** 2 + 41) for i in range(end+1))

def third_way(end):
    return not any(minus_four(i) and is_prime(fibo(i) ** 2 + 41) for i in range(end+1))


Some of these names (eg. minus_four) are particularly cryptic.

Your fibo actually takes \$\mathcal{O}(e^n)\$ time -  what you really want as a basis is a generator to let you do

return all(not is_prime(f ** 2 + 41) for f in fibonacci_numbers(count))


This generator is typically written something like

def fibonacci_numbers(count):
    prev = 1
    curr = 0

    for _ in range(count):
        yield curr
        prev, curr = curr, prev + curr


Now each number takes \$\mathcal{O}(1)\$ (approximately), which is much faster.

Doing this actually quickly leads to an

OverflowError: long int too large to convert to float


since math.sqrt(x) needs to convert

400624556078135004801005131049868376277487458971454665625744044750241868509910118684223898375755770833486910716679881483356186192835924621611785526885928263384281394311273430963137957057246385921466246089044680129333479765771922731594997403327473526588890161488739900887481571279985972340702546216307221018066


to a float.

One other problem is also precision issues. For large numbers your is_perfect_square fails:

is_perfect_square(100000000**2 + 1)


since

float(100000000**2 + 1) == 1e+16


which is rounded. So the results are actually meaningless.