Square Root of a Boolean Matrix

Question

I am trying to find the square roots of transitive Boolean matrices.

Let $B$ be a transitive Boolean matrix, If $A^2= B$, then $A$ is the square root of $B$.

Here is my try

checkTrans[m1_] := Module[{m2}, m2 = m1 . m1; m1 m2 == m2]
n = 3; (*martix order*)
ms = IntegerDigits[#, 2, n^2] & /@ Range[0, 2^(n^2) - 1];
ms = ArrayReshape[#, {n, n}] & /@ ms;
squareRoots = 
  Flatten[Function[{m}, 
     Select[MatrixPower[#, 1/2] & /@ 
       ms, # [Element] Reals && 
        AllTrue[Flatten[#], # == 0 || # == 1 &] && checkTrans[m] &]] /@
     ms, 1];
Length[squareRoots]
Print["Matrices with Existing Square Roots (Boolean):"];
MatrixForm /@ squareRoots

For 2x2, I am getting 8 martices. How to make sure that I am getting all the possible square roots matrices of each matrix? As expected, for 3x3 its very slow, any suggestions?

It's worth noting that not every Boolean matrix has a square root. Some Boolean matrices may not have a square root, while others may have multiple square roots.

Answer 1

You could turn this into SAT problem and use SatisfiabilityInstances.

Notebook

Generate all $d\times d$ boolean matrices such that their square is weakly transitive

Weakly transitive means $A\ge A^2$

Number of such matrices grows as $\{2, 16, 432, 32242, 739848\}$

ClearAll["Global`*"];
ClearAll["Global`*"];
booleanMatmul[mat1_, mat2_] := 
  Array[Inner[And, mat1[[#1, ;;]], mat2[[;; , #2]], Or] &, {Length[
     mat1], Length[mat2]}];
booleanEquals[mat1_, mat2_] := 
  And @@ Flatten@MapThread[Xnor, {mat1, mat2}, 2];
booleanGreaterEqual[mat1_, mat2_] := 
  And @@ Flatten@MapThread[Or[#1, Not[#2]] &, {mat1, mat2}, 2];
genWeaklyTransitiveSquare[d_] := Block[{x},
   mat = Array[x, {d, d}];
   vars = Flatten[mat];
mat2 = booleanMatmul[mat, mat];
   mat4 = booleanMatmul[mat2, mat2];
   sat = booleanGreaterEqual[mat2, mat4];
numSolutions = SatisfiabilityCount[sat, vars];
   booleSolutions = SatisfiabilityInstances[sat, vars, numSolutions];
   On[Assert]; Assert[Length@booleSolutions == numSolutions];
   (Convert solutions to matrix form)
   matrixSolutions = mat /. Thread[vars -> Boole@#] & /@ booleSolutions
   ];
MatrixForm /@ genWeaklyTransitiveSquare[3]

Generate all $d\times d$ boolean matrices such that their square is idempotent

Counts grow as ${2,16,420,31114,7192088}$

genIdempotentSquare[d_] := (
   mat = Array[x, {d, d}];
   vars = Flatten[mat];
(construct mat^2 using And/Or instead of/+*)
   mat2 = Array[
     Inner[And, mat[[#1, ;;]], mat[[;; , #2]], Or] &, {d, d}];
   mat4 = 
    Array[Inner[And, mat2[[#1, ;;]], mat2[[;; , #2]], Or] &, {d, d}];
   sat = And @@ Flatten@MapThread[Xnor, {mat2, mat4}, 2];
   numSolutions = SatisfiabilityCount[sat, vars];
   booleSolutions = SatisfiabilityInstances[sat, vars, numSolutions];
   On[Assert]; Assert[Length@booleSolutions == numSolutions];
(Convert solutions to matrix form)
   matrixSolutions = mat /. Thread[vars -> Boole@#] & /@ booleSolutions
   );
MatrixForm /@ genIdempotentSquare[3]

List all boolean idempotent matrices of size $d\times d$

Counts grow as $1, 2, 11, 123, 2360$, A121337

d = 3;
mat = Array[x, {d, d}];
vars = Flatten[mat];
(construct mat^2 using And/Or instead of/+*)
mat2 = Array[
   Inner[And, mat[[#1, ;;]], mat[[;; , #2]], Or] &, {d, d}];
sat = And @@ Flatten@MapThread[Xnor, {mat, mat2}, 2];
numSolutions = SatisfiabilityCount[sat, vars];
booleSolutions = SatisfiabilityInstances[sat, vars, numSolutions];
On[Assert]; Assert[Length@booleSolutions == numSolutions];
(Convert solutions to matrix form)
matrixSolutions = mat /. Thread[vars -> Boole@#] & /@ booleSolutions;
Print["Solutions idempotent: ", 
  AllTrue[matrixSolutions, Boole@Positive[# . #] == # &]];
MatrixForm /@ matrixSolutions

List all square roots of given boolean matrix

For IdentityMatrix[d] target, counts grow as A000085

ClearAll["Global`*"];
target = IdentityMatrix[4];
Clear[x];
d = Length[target];
mat = Array[x, {d, d}];
vars = Flatten[mat];
(construct mat^2 using And/Or instead of/+*)
mat2 = Array[Inner[And, mat[[#1, ;;]], mat[[;; , #2]], Or] &, {d, d}];
(* construct SAT problem *)
posClauses = Extract[mat2, Position[target, 1]];
negClauses = Not /@ Extract[mat2, Position[target, 0]];
sat = (And @@ posClauses)~And~(And @@ negClauses);
(* solve SAT problem *)
numSolutions = SatisfiabilityCount[sat, vars];
booleSolutions = SatisfiabilityInstances[sat, vars, numSolutions];
On[Assert]; Assert[Length@booleSolutions == numSolutions];
(* Convert solutions to matrix form *)
matrixSolutions = mat /. Thread[vars -> Boole@#] & /@ booleSolutions;
MatrixForm /@ matrixSolutions