Correlation between zeros in a zero-one sequence

I have a sequence of zeros and ones for example, [0,1,0,0,0,1,0]. I want to measure the correlation between zeros in the sequence i.e., given one zero how likely is another zero to follow the first zero. I wanted to do this using the correlation coefficient. However, if I use numpy.corrcoef() in the sequence, it returns 1.0 which is not true. Any suggestions are appreciated.
Here's a code that reproduces the same:

    import numpy as np

    x = np.random.randint(0,2,1000)
    x = x[...,np.newaxis]
    rho = np.corrcoef(x.T)
    print(rho)

You need to compare x to its shifted self:

np.random.seed(0)

x = np.random.randint(0, 2, 1000)

rho = np.corrcoef(x[:-1], x[1:])

Output:

array([[1.        , 0.00292208],  # <- this is the value you want
       [0.00292208, 1.        ]])

how it works

We compare each value to the next one:

x 
# array([0, 1, 1, 0, 1, ...,  0, 0, 1, 0])

# first to second-to-last value
x[:-1]
# array([0, 1, 1, 0, 1, ...,  0, 0, 1])

# second to last value
x[1:]
# array([1, 1, 0, 1, ...,  0, 0, 1, 0])

Your question is somewhat inconsistent, in that you say one one hand that you want to compute a correlation coefficient, and on the other hand that you want to compute a probability. The general idea of "correlation" is related to probability, but Pearson correlation coefficients, such as are computed by numpy.corrcoef() are not probabilities at all. You clarified in comments that you want to compute correlation coefficients for x[i+1] with respect to x[i].

That might look like this:

import numpy as np

# Generate random data
x = np.random.randint(0, 2, 1000)

corr = np.corrcoef(x[:-1], np.roll(x, -1)[:-1])[0][1]
print(corr)

Explanation:

• np.roll(x, -1) generates a copy of x in which the elements have been rotated one position to the left. Thus each element is the successor (in x) of the corresponding element of x.

• the last element of x has no successor, so we need to ignore that, and also the corresponding element of the rotated version of x. The slicing with [:-1] accomplishes this.

• the resulting numpy arrays are suitable for a correlation computation via np.corrcoef(). The result is a symmetric matrix providing the correlation coefficient of each variable with every other. In our case there are only two variables, so this matrix will be 2 x 2.

  The elements on the main diagonal are correlation coefficients of one of the variables with itself; these should be identically 1. The off-diagonal elements are correlation coefficients for one variable against a different one, and these should be symmetric. We can choose either one, and the above chooses [0][1].

Note well that for random data, such as this example, the cross correlation should be approximately zero. (This is a measure of the quality of our (pseudo-)random number generator.)

What you're asking for is not hard to compute. I think you want to know the chances that a 0 is followed by another zero. This code does that:

import numpy as np

x = np.array([ 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 ])
x0 = x[:-1]
x1 = x[1:]

equal = (x0 == x1) & ~x0
zeros = len(x) - sum(x)
coef = sum(equal) / zeros
print(x0)
print(x1)
print(equal)
print(coef)

Output:

[0 0 0 1 0 0 0 1 0 0 0 1 0 0 0]
[0 0 1 0 0 0 1 0 0 0 1 0 0 0 1]
[1 1 0 0 1 1 0 0 1 1 0 0 1 1 0]
0.6666666666666666

So, 2/3 of the zeros are followed by another zero, which is correct.

What I do there is compute the xor of the two sequences, which is 1 where the values are identical. I then NAND that with the original sequence, which leaves 1s only where there were two zeros. By dividing the sum of that list by the number of 0s in the original, we get the answer.