Rook from top to bottom with only white squares 
In an $8\times 8$ board, consider the number of ways $M$ to color the squares in black and white so that there exists a path from some square in the top row to some square in the bottom row, going only through squares with adjacent edges, such that all squares in the path are white.  Show that $M<2^{63}$.

It should be the case that $M<2^{63}$, but I cannot think of a proof. I can see that there are $2^{64}$ colorings in total, so if we could create an injective correspondence between the "bad" colorings and "good" colorings, then we would be successful.  But I have not yet been able to come up with a correspondence that worked.
Any help appreciated!
 A: Let $M$ represent the number of such possible arrangements.  Then $M$ is obviously also the number of colorings from the first column to the eighth column using only black squares.  It is clear that no coloring can satisfy both of these conditions, and it is similarly clear that there are colorings that satisfy neither condition (such as the canonical chessboard coloring).  Therefore $M+M<2^{64}$, or $M<2^{63}$, as desired.
A: For each binary $8$-tuple $b$ and positive integer $n$ let $a_{n,b}$ be the probability that a random $n\times 8$ binary matrix has that tuple as the set of elements in the bottom row that are reachable.
Hence $a_{1,b} = \frac{1}{2^8}$.
We can calculate all values $a_{n+1,b}$ by using the values of $a_{n,b}$.
To do this iterate over all possibilites of the reachable squares in the second to last row and all possibilities for the squares of the last tuple, and given these options calculate which are the reachable squares of the last row.
After this you want the sum of all the $a_{8,b}$ in which $b$ is not all zeros.
I get the actual value is about $0.396329$.
Here is some C++ code that uses some bit magic to save the bitmasks:
#include <bits/stdc++.h>
using namespace std;

const int MAX = 1e7;
int N = 10;
long double a[10][MAX]; 


    int main(){
            int m = 8;
            int f = 1 << m;
            long double unif = 1/(long double)f;
            for(int t=0;t<f;t++){
                    a[1][t] = unif;
            }
            for(int n = 2;n<N;n++){
                    for(int t=0;t< f;t++){ // assume the first n-1 rows gave bitmask t
                            for(int lr=0;lr<f;lr++){ // assume the last row is l
                                    int c = t & lr; // the white square below reachable cells are reachable
                                    int pot =2;
                                    for(int i=1;i<=m-1;i++){ // fill the white squares to the right of reachable cells
                                            if( lr&pot && t&(pot/2) ) c = c | pot;
                                            pot*=2;
                                    }
                                    pot = f/4;
                                    for(int i=m-2;i>=0;i--){ // fill the white squares to the left of reachable cells
                                            if( lr&pot && t&(pot*2) ) c= c | pot;
                                    }
                                    a[n][c] += a[n-1][t]*unif;
                            }
                    }
            }
            int n = 8;
            long double res = 0;
            for(int b=1;b<f;b++){
                    res += a[n][b];
            }
            cout << res << endl;
    
    }

