Python code seems logically equivalent but one is failing and the other is not

The following is Bellman-Ford's algorithm implemented to find whether there is a negative cycle in the graph or not.
I do not have access to the test cases but there is some edge case that's causing the code to fail when the dist array is initialized with float('inf'). Why?

def negative_cycle(n, graph):
    # dist = [float('inf')] * (n+1)  (This code fails)
    dist = [1001] * (n+1)          # (this code doesn't)
    dist[1] = 0
    for i in range(n):
        for st, end, cost in graph:
            print(dist)
            if dist[end] > dist[st] + cost:
                dist[end] = dist[st] + cost
                if i == n - 1:
                    return 1
    return 0


if __name__ == '__main__':
    n_vertices, n_edges = map(int, input().split())
    edges = []
    for i in range(n_edges):
        a, b, w = map(int, input().split())
        edges.append((a, b, w)) 
    print(negative_cycle(n_vertices, edges))

You'll get a different output when the input graph has these characteristics:

• Not all nodes are reachable from node 1
• There is a negative cycle between nodes that are not reachable from node 1

In this case the faulty code (with "inf") will report there is no negative cycle, while the correct code will report there is one.

Here is an example input/run of such a case:

edges = [
    (1, 2, 0),
    (2, 1, 0),

    (3, 4, -1),
    (4, 3, 0),
    (4, 1, 0)
]
print(negative_cycle(4, edges))

Each time the edge with the negative weight is visited, the algorithm will compare dist[4] > dist[3] - 1. In the faulty code this expression is float('inf') > float('inf') - 1 which is False, while in the correct code this expression is 1001 > 1001 - 1 (the first time, then 1000 > 1000 - 1, ...etc) and so the if block gets executed repeatedly, eventually executing return 1.

Remarks

In the correct code it is not necessary to initialise dist[1] in a different way than for the other nodes. You could initialise them all with 0. This algorithm doesn't need to have the notion of "I never was here before", which in other algorithms would make it interesting to initialise with float('inf').

Here the only thing that matters is that the algorithm detects that the distance of one or more nodes keeps reducing and never settles to a stable value. For such a detection it doesn't matter at which initial value you start the algorithm with, as long as it is a finite value.