pycubool is a python wrapper for cuBool library.

cuBool is a linear Boolean algebra library primitives and operations for work with sparse matrices written on the NVIDIA CUDA platform. The primary goal of the library is implementation, testing and profiling algorithms for solving formal-language-constrained problems, such as context-free and regular path queries with various semantics for graph databases. The library provides C-compatible API, written in the GraphBLAS style.

The library is shipped with python package pycubool - wrapper for cuBool library C API. This package exports library features and primitives in high-level format with automated resources management and fancy syntax sugar.

The primary library primitives are sparse matrix and sparse vector of boolean values. The library provides the most popular operations for matrix manipulation, such as construction from values, transpose, sub-matrix/sub-vector extraction, matrix-to-vector reduce, element-wise addition, matrix-matrix, matrix-vector, vector-matrix multiplication, and Kronecker product.

As a fallback library provides sequential backend for mentioned above operations for computations on CPU side only. This backend is selected automatically if Cuda compatible device is not presented in the system. This can be quite handy for prototyping algorithms on a local computer for later running on a powerful server.

• Cuda backend for computations
• Cpu backend for computations
• Matrix/vector creation (empty, from data, with random data)
• Matrix-matrix operations (multiplication, element-wise addition, element-wise multiplication, kronecker product)
• Matrix-vector operations (matrix-vector and vector-matrix multiplication)
• Vector-vector operations (element-wise addition, element-wise multiplication)
• Matrix operations (equality, transpose, reduce to vector, extract sub-matrix)
• Vector operations (equality, reduce to value, extract sub-vector)
• Matrix/vector data extraction (as lists, as list of pairs)
• Matrix/vector syntax sugar (pretty string printing, slicing, iterating through non-zero values)
• IO (import/export matrix from/to .mtx file format)
• GraphViz (export single matrix or set of matrices as a graph with custom color and label settings)
• Debug (matrix string debug markers, logging)

Sparse Boolean matrix-matrix multiplication evaluation results are listed bellow. Machine configuration: PC with Ubuntu 20.04, Intel Core i7-6700 3.40GHz CPU, DDR4 64Gb RAM, GeForce GTX 1070 GPU with 8Gb VRAM.

The matrix data is selected from the SuiteSparse Matrix Collection link.

Detailed comparison is available in the full paper text at link.

Create sparse matrices, compute matrix-matrix product and print the result to the output:

import pycubool as cb

a = cb.Matrix.empty(shape=(2, 3))
a[0, 0] = True
a[1, 2] = True

b = cb.Matrix.empty(shape=(3, 4))
b[0, 1] = True
b[0, 2] = True
b[1, 3] = True
b[2, 1] = True

print(a, b, a.mxm(b), sep="\n")

Create sparse matrix and vector, compute matrix-vector and vector-matrix products and print the result:

import pycubool as cb

m = cb.Matrix.empty(shape=(3, 4))
m[0, 1] = True
m[1, 0] = True
m[1, 3] = True
m[2, 2] = True

v = cb.Vector.empty(nrows=4)
v[0] = True
v[2] = True

t = cb.Vector.empty(nrows=3) 
t[0] = True
t[2] = True

print(m.mxv(v), t.vxm(m), sep="\n")

Compute the transitive closure problem for the directed graph and print the result:

import pycubool as cb

a = cb.Matrix.empty(shape=(4, 4))
a[0, 1] = True
a[1, 2] = True
a[2, 0] = True
a[2, 3] = True
a[3, 2] = True

t = a.dup()                             # Duplicate matrix where to store result
total = 0                               # Current number of values

while total != t.nvals:
    total = t.nvals
    t.mxm(t, out=t, accumulate=True)    # t += t * t

print(a, t, sep="\n")

Generate GraphViz graph script for a graph stored as a set of adjacency matrices:

import pycubool as cb

name = "Test"                           # Displayed graph name   
shape = (4, 4)                          # Adjacency matrices shape
colors = {"a": "red", "b": "green"}     # Colors per label

a = cb.Matrix.empty(shape=shape)        # Edges labeled as 'a'
a[0, 1] = True
a[1, 2] = True
a[2, 0] = True

b = cb.Matrix.empty(shape=shape)        # Edges labeled as 'b'
b[2, 3] = True
b[3, 2] = True

print(cb.matrices_to_gviz(matrices={"a": a, "b": b}, graph_name=name, edge_colors=colors))

Script can be rendered by any gviz tool online and the result can be following:

• Egor Orachyov (Github: EgorOrachyov)
• Pavel Alimov (Github : Krekep)
• Semyon Grigorev (Github: gsvgit)

@MISC{cuBool,
  author = {Orachyov, Egor and Alimov, Pavel and Grigorev, Semyon},
  title = {cuBool: sparse Boolean linear algebra for Nvidia Cuda},
  year = 2021,
  url = {https://github.com/JetBrains-Research/cuBool},
  note = {Version 1.2.0}
}

This project is licensed under MIT License. License text can be found in the license file.

This is a research project of the Programming Languages and Tools Laboratory at JetBrains-Research. Laboratory website link.

The name of the library is formed by a combination of words Cuda and Boolean, what literally means Cuda with Boolean and sounds very similar to the name of the programming language COBOL.