# Minimizing Communication for Parallel Symmetric Tensor Times Same Vector Computation

Hussam Al Daas, Grey Ballard, Laura Grigori, Suraj Kumar, Kathryn Rouse, Mathieu Verite

► To cite this version:

Hussam Al Daas, Grey Ballard, Laura Grigori, Suraj Kumar, Kathryn Rouse, et al. Minimizing Communication for Parallel Symmetric Tensor Times Same Vector Computation. SPAA 2025 - ACM Symposium on Parallelism in Algorithms and Architectures, Jul 2025, Portland, United States. 10.1145/3694906.3743332 . hal-05130982

HAL Id: hal-05130982

https://inria.hal.science/hal-05130982v1

Submitted on 26 Jun 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>
# Minimizing Communication for Parallel Symmetric Tensor Times Same Vector Computation

HUSSAM AL DAAS, STFC, Rutherford Appleton Laboratory, UK

GREY BALLARD, Wake Forest University, USA

LAURA GRIGORI, EPFL and PSI, Switzerland

SURAJ KUMAR, Inria Lyon, France

KATHRYN ROUSE, Inmar Intelligence, USA

MATHIEU VÉRITÉ, EPFL, Switzerland

In this article, we focus on the parallel communication cost of multiplying the same vector along two modes of a 3-dimensional symmetric tensor. This is a key computation in the higher-order power method for determining eigenpairs of a 3-dimensional symmetric tensor and in gradient-based methods for computing a symmetric CP decomposition. We establish communication lower bounds that determine how much data movement is required to perform the specified computation in parallel. The core idea of the proof relies on extending a key geometric inequality for 3-dimensional symmetric computations. We demonstrate that the communication lower bounds are tight by presenting an optimal algorithm where the data distribution is a natural extension of the triangle block partition scheme for symmetric matrices to 3-dimensional symmetric tensors.

**Keywords:** Symmetric Tensor Computations, Communication Costs, Parallel Algorithms

## 1 Introduction

Exploiting symmetry in matrix and tensor computations can save computation, memory, and communication, or movement of data. As a symmetric matrix has approximately half the unique parameters of a non-symmetric matrix, many operations involving symmetric matrices require half the computation of their non-symmetric counterparts. Because matrix computations are so fundamental, standard libraries such as implementations of the Basic Linear Algebra Subroutines (BLAS) commit to taking this constant factor advantage whenever possible. More recent results have demonstrated that the communication costs for symmetric matrix computations can also be reduced with more complicated algorithms [2, 4, 6, 10].

In the case of tensors, or multidimensional arrays with 3 or more modes, symmetry offers even more opportunity for cost savings. For example, while a non-symmetric *d*-dimensional tensor of dimensions *n* × *n* × ... × *n* has *n*^*d* entries, a symmetric tensor with the same dimensions has approximately *n*^*d*/d! entries. Here, we consider a symmetric tensor’s entry to have the same value no matter how its indices are permuted, which is sometimes referred to as fully symmetric or supersymmetric.

Two fundamental problems involving a symmetric tensor are tensor eigenvalues, and Canonical Polyadic (CP) decomposition. A Z-eigenvalue of a 3-dimensional tensor *A* is defined as a scalar λ that satisfies the equation *A* ×₂ **x** ×₃ **x** = λ**x** for some unit vector **x** [23, 26], where ×<sub>j</sub> denotes a tensor-times-vector operation in mode *j*. A symmetric CP decomposition of a 3-dimensional tensor *A* is specified by a matrix X with *l*th column denoted **x**<sub>*l*</sub> such that

Authors' Contact Information: Hussam Al Daas, STFC, Rutherford Appleton Laboratory, Didcot, Oxfordshire, UK, hussam.al-daas@stfc.ac.uk; Grey Ballard, Wake Forest University, Winston-Salem, NC, USA, ballard@wfu.edu; Laura Grigori, EPFL and PSI, Lausanne, Switzerland, laura.grigori@epfl.ch; Suraj Kumar, Inria Lyon, Lyon, France, suraj.kumar@inria.fr; Kathryn Rouse, Inmar Intelligence, Winston-Salem, NC, USA, kathryn.rouse@inmar.com; Mathieu Vérité, EPFL, Lausanne, Switzerland, mathieu.verite@epfl.ch.
$\mathcal{A} \approx \sum_{\ell=1}^{r} x_{\ell} \circ x_{\ell} \circ x_{\ell}$, where $\circ$ denotes an outer product [21]. Algorithm 1 specifies a method for computing $\mathbb{Z}$-eigenvalues, and Algorithm 2 specifies the computation of the gradient of the objective function defined by the least squares error of the CP decomposition. In both cases, the bottleneck computation is given by $\mathcal{A} \times_2 x \times_3 x$, which we refer to as the *Symmetric-Tensor-Times-Same-Vector* (STTSV) computation. Algorithms for computing other types of eigenvalues and eigenvectors, including $\mathbb{H}$-eigenvalues, also rely on STTSV [27].

**Algorithm 1 Higher-Order Power Method**

**Require:** $\mathcal{A} \in \mathbb{R}^{n \times n \times n}$ is a symmetric 3-dimensional tensor.

**Ensure:** $x \in \mathbb{R}^n$ and $\lambda \in \mathbb{R}$ such that $\mathcal{A} \times_2 x \times_3 x = \lambda x$.

1. Initialize $x$ to a random unit vector

2. **repeat**

3. $y = \mathcal{A} \times_2 x \times_3 x$

4. $x = \frac{y}{\|y\|}$

5. **until** convergence

6. $\lambda = \mathcal{A} \times_1 x \times_2 x \times_3 x$

► STTSV

**Algorithm 2 Symmetric CP Gradient**

**Require:** $\mathcal{A} \in \mathbb{R}^{n \times n \times n}$ is a symmetric 3-dimensional tensor, $X \in \mathbb{R}^{n \times r}$ is approximate CP factor

**Ensure:** $Y \in \mathbb{R}^{n \times r}$ is the gradient with respect to the function $f(X) = \frac{1}{6} \|\mathcal{A} - \sum_{\ell} x_{\ell} \circ x_{\ell} \circ x_{\ell}\|^2$

1. $G = (X^T X) * (X^T X)$

► * denotes the elementwise product

2. **for** $\ell = 1$ to $r$ **do**

3. $y_{\ell} = \mathcal{A} \times_2 x_{\ell} \times_3 x_{\ell}$

► STTSV

4. **end for**

5. $Y = XG - Y$

In this work, we focus on STTSV and its communication costs. The main contributions of this paper are to

(1) derive a geometric inequality that bounds the maximum reuse of vector elements in a 3-dimensional symmetric computation;

(2) establish communication lower bounds for the parallel load-balanced STTSV computation;

(3) extend triangle block partitioning proposed by Beaumont et al. [10] and Al Daas et al. [6] for symmetric matrices to tetrahedral block partitioning for 3-dimensional symmetric tensors;

(4) present and analyze an algorithm whose communication cost exactly matches the leading term of the lower bound.

To establish communication lower bounds, we employ a geometric inequality to determine the minimal amount of data that a processor requires to perform its share of computation and consider how much data the processor must send or receive. In order to demonstrate that the communication lower bounds are tight, we provide an algorithm where the leading term of the communication cost exactly matches that of the lower bound. We extend the triangle block partition scheme proposed by Beaumont et al. [10] and Al Daas et al. [6] for the lower triangle of symmetric matrices to a tetrahedral partition of the lower tetrahedron of 3-dimensional symmetric tensors. Our algorithm uses tetrahedral blocks to exploit the symmetry. To generate tetrahedral block partitions, we rely on Steiner systems that are collections of equally sized subsets of indices where three distinct indices appear in exactly one subset. We use an owner-compute
rule, assigning all computations involving elements in a block of the tensor to the processor that owns that block, ensuring that no tensor data needs to be communicated and only the input and output vectors need to be exchanged.

The rest of the paper is organized as follows. Section 2 reviews previous work on communication lower bounds and optimal algorithms for some linear algebra computations. In Section 3, we introduce our notations and preliminaries for the STTSV computation. We present some key new results in Section 4, which we use to establish communication lower bounds in Section 5. We explain tetrahedral block partitioning in Section 6 and present a communication optimal algorithm for STTSV in Section 7. Finally, we discuss conclusions and future perspectives in Section 8.

## 2 Related Work

There are numerous studies on establishing communication lower bounds. The first communication lower bounds were proposed by Hong and Kung [17] for various computations, including matrix multiplication, for a sequential machine using the red-blue pebble game. Aggarwal et al. [1] extended their work for the parallel model and derived first memory-independent communication lower bounds for matrix multiplication. Irony et al. [19] reproduced the parallel matrix multiplication bounds with the Loomis-Whitney geometric inequality [24]. Ballard et al. [7] extended the use of Loomis-Whitney inequality to derive sequential and parallel bounds for all direct methods of linear algebra which can be expressed as three nested loops. Olivry et al. [25] and Kwasniewski et al. [22] analyzed computational graphs to automatically derive sequential lower bounds for several linear algebra computations.

Communication lower bounds have also been derived for computations involving tensors. In particular, Ballard et al. [5, 8, 9] gave sequential and parallel lower bounds for the Matricized-Tensor Times Khatri-Rao product (MTTKRP) and Multiple Tensor Times Matrix (Multi-TTM) computations using Hölder-Brascamp-Lieb inequalities [11]. Ziogas et al. [31] improved the leading constant for the sequential and memory dependent parallel lower bounds for MTTKRP using CDAG analysis. Solomnik et al. [28] gave communication lower bounds for symmetric tensor contractions.

While many of the automatically derived bounds for linear algebra computations were tight, the leading order constants were not tight for computations involving a symmetric matrix. Beaumont et al. [10] improved the constant for the sequential communication lower bound for SYRK using CDAG analysis by taking advantage of symmetry. They demonstrated the bound is tight by providing an algorithm that matches the lower bound. Their algorithm introduced triangle block partition of the symmetric matrix to allow maximum reuse of the elements of the non-symmetric matrix. Al Daas et al. [4] derived a symmetric version of the Loomis-Whitney inequality which they used to obtain memory-independent parallel communication lower bounds for SYRK. They adapted the triangle block partition given by Beaumont et al. [10] for the parallel case and provided communication optimal algorithms for SYRK. Agullo et al. [2] were able to improve the performance of distributed SYMM implementations by applying the triangle block partition to improve the arithmetic intensity over standard implementations. Al Daas et al. [6] established sequential and parallel communication lower bounds for three nested loop computations involving a symmetric matrix. They gave algorithms for SYRK, SYR2K and SYMM all of which achieve the communication lower bounds, using new families of triangle block partitions derived from finite geometries. We follow their approach and use finite geometries to obtain partitions for 3-dimensional symmetric tensors.

## 3 Notations and Preliminaries

We will use the following notation throughout the paper. $\mathcal{A}$ represents a 3-dimensional symmetric tensor of dimensions $n \times n \times n$, while $\mathbf{x}$ and $\mathbf{y}$ are vectors of length $n$. As $\mathcal{A}$ is a symmetric tensor, $a_{ijk}$ is same for all permutations of $i, j$ and $k$, i.e., $a_{ijk} = a_{ikj} = a_{jik} = a_{jki} = a_{kij} = a_{kji}$.
The tensor-times-vector operation in mode *j* of *A* and **x** is denoted as *A* ×<sub>*j*</sub> **x** and it can be computed element-wise as (*A* ×<sub>*j*</sub> **x**)<sub>*ik*</sub> = ∑<sub>*j*,k*</sub> *a*<sub>*ijk*</sub> ⋅ **x**<sub>*j*</sub> ⋅ **x**<sub>*k*</sub>. Similarly, *A* ×<sub>*j*</sub> ×<sub>*k*</sub> **x** can be computed element-wise as (*A* ×<sub>*j*</sub> ×<sub>*k*</sub> **x**)<sub>*i*</sub> = ∑<sub>*j*,k*</sub> *a*<sub>*ijk*</sub> ⋅ **x**<sub>*j*</sub> ⋅ **x**<sub>*k*</sub>. We refer to the operation *a*<sub>*ijk*</sub> ⋅ **x**<sub>*j*</sub> ⋅ **x**<sub>*k*</sub> as *ternary multiplication*.

We present two algorithms for performing the STTSV computation. The first, Algorithm 3, is straightforward but does not take symmetry into account. It performs the computation by performing all $n^3$ ternary multiplications.

<caption>**Algorithm 3 Pseudocode of STTSV**</caption>

**Require:** $\mathcal{A} \in \mathbb{R}^{n \times n \times n}$ is a symmetric tensor and $\mathbf{x} \in \mathbb{R}^n$ is a vector.
**Ensure:** $\mathbf{y} \in \mathbb{R}^n$ such that $\mathbf{y} = \mathcal{A} \times_2 \mathbf{x} \times_3 \mathbf{x}$.
Initialize vector $\mathbf{y}$ to 0
**for** $i = 1$ to $n$ **do**
    **for** $j = 1$ to $n$ **do**
        **for** $k = 1$ to $n$ **do**
            $\mathbf{y}_i += \mathbf{a}_{ijk} \cdot \mathbf{x}_j \cdot \mathbf{x}_k$
        **end for**
    **end for**
    **end for**

Our second algorithm, Algorithm 4, exploits the property that every element of a symmetric tensor remains constant under any permutation of its indices. It only works with the lower tetrahedral portion of $\mathcal{A}$, $a_{ijk}$ where $i \ge j \ge k$, performing all possible operations involving $a_{ijk}$ within each inner loop iteration. The total number of points in the iteration space is $n(n+1)(n+2)/6$ of which $n(n-1)(n-2)/6$ correspond to computations with the strict lower tetrahedral portion of $\mathcal{A}$, $a_{ijk}$ where $i > j > k$.

Algorithm 4 performs $n^2(n+1)/2$ ternary multiplications, approximately half the number of those in Algorithm 3.

**DEFINITION 1.** A parallel atomic STTSV algorithm computes each ternary multiplication on one processor.

We consider only parallel atomic algorithms for STTSV, that perform $n^2(n+1)/2$ ternary multiplication. Computing a single ternary multiplication on one processor requires that all 3 inputs are accessed by that processor to compute the single output value. This requirement is necessary for our communication lower bounds to hold.

## 3.1 Parallel Computation Model

We use the $\alpha - \beta - \gamma$ or MPI model [12, 29] of parallel computation. In this model, the computation is distributed over *P* processors each of which has its own local memory and can operate on data in its local memory. In order to access data from other processors, a processor must communicate with that processor via a fully connected network with bidirectional links. Each processor can send and receive at most one message at the same time. Hence, communication refers to send and receive operations that transfers data from local memory to the network and vice-versa. The communication cost has two components, the latency cost or number of messages, and bandwidth cost or volume of communication. As the bandwidth cost tends to dominate the latency cost when messages are large, we focus on bandwidth cost and refer to it as communication cost throughout the paper. We focus on memory-independent analysis, so we assume that each processor has sufficiently large local memory.
**Algorithm 4 STTSV exploiting symmetric structure**

**Require:** $\mathcal{A} \in \mathbb{R}^{n \times n \times n}$ is symmetric and $x \in \mathbb{R}^n$

**Ensure:** $y \in \mathbb{R}^n$ such that $y = \mathcal{A} \times_2 x \times_3 x$

Initialize vector y to 0

for $i = 1$ to $n$ do

for $j = 1$ to $i$ do

for $k = 1$ to $j$ do

if $i \neq j$ and $j \neq k$ then

$$y_i += 2a_{ijk} \cdot x_j \cdot x_k$$

$$y_j += 2a_{ijk} \cdot x_i \cdot x_k$$

$$y_k += 2a_{ijk} \cdot x_i \cdot x_j$$

else if $i == j$ and $j \neq k$ then

$$y_i += 2a_{ijk} \cdot x_j \cdot x_k$$

$$y_k += a_{ijk} \cdot x_i \cdot x_j$$

else if $i \neq j$ and $j == k$ then

$$y_i += a_{ijk} \cdot x_j \cdot x_k$$

$$y_j += 2a_{ijk} \cdot x_i \cdot x_k$$

else

$$y_i += a_{ijk} \cdot x_j \cdot x_k$$

end if

end for

end for

end for

## 4 Geometric Results

To minimize communication in parallel computations, we minimize the amount of data required to perform each processor's local computations. We relate data to computations by relating the set of points in $\mathbb{Z}^3$ which correspond to elements in the iteration space to projections onto lower dimensional spaces which correspond to the arrays of data. Our first lemma relates the number of points in a three dimensional lattice to the sizes of its projections onto one dimensional subspaces, relating points in a three dimensional iteration space to vector data required for the computation.

We obtain the following lemma from [8, Lemma 4.1] by fixing the number of dimensions, it can also be proved by applying Loomis-Whitney inequality [24] twice.

**LEMMA 1.** Let $V$ be a finite set of points in $\mathbb{Z}^3$. Let $\phi_i(V)$ be the projection of $V$ on the $i$-axis, i.e., all points $i$ such that there exists a $(j, k)$ so that $(i, j, k) \in V$. Define $\phi_j(V)$ and $\phi_k(V)$ similarly. Then

$$|V| \leq |\phi_i(V)| \cdot |\phi_j(V)| \cdot |\phi_k(V)|.$$

We now extend Lemma 1 for a symmetric set of points.

**LEMMA 2.** Let $V$ be a finite set of points contained in $\{(i, j, k) \in \mathbb{Z}^3 | i > j > k\}$. Let $\phi_i(V)$ be the projection of $V$ on the $i$-axis, i.e., all points $i$ such that there exists a $(j, k)$ so that $(i, j, k) \in V$. Define $\phi_j(V)$ and $\phi_k(V)$ similarly. Then

$$6|V| \leq |\phi_i(V) \cup \phi_j(V) \cup \phi_k(V)|^3.$$

**PROOF.** Consider the set

$$\tilde{V} = \{(i, j, k), (i, k, j), (j, i, k), (j, k, i), (k, i, j), (k, j, i) | (i, j, k) \in V\}$$
and its projections. To begin, we will show that $|\tilde{V}| = 6|V|$. For each $(i, j, k) \in V$, there are 6 corresponding elements in $\tilde{V}$. Therefore $|\tilde{V}| \le 6|V|$. If $(i, j, k), (i', j', k') \in V$ and $(i, j, k) \ne (i', j', k')$, then $\{\text{all permutations of } (i, j, k)\} \cap \{\text{all permutations of } (i', j', k')\} = \emptyset$. Therefore $|\tilde{V}| \ge 6|V|$. Thus we have $|\tilde{V}| = 6|V|$.

Now we will show that $\phi_i(\tilde{V}) = \phi_i(V) \cup \phi_j(V) \cup \phi_k(V)$. If $i \in \phi_i(\tilde{V})$, then there exists a $(j, k)$ such that $(i, j, k) \in V$ or $(j, i, k) \in V$ or $(j, k, i) \in V$. Therefore $\phi_i(\tilde{V}) \subseteq \phi_i(V) \cup \phi_j(V) \cup \phi_k(V)$. If $i \in \phi_i(V) \cup \phi_j(V) \cup \phi_k(V)$, then there exists a $(j, k)$ such that $(i, j, k) \in V$ or $(j, i, k) \in V$ or $(j, k, i) \in V$, thus $(i, j, k) \in \tilde{V}$. Therefore $\phi_i(V) \cup \phi_j(V) \cup \phi_k(V) \subseteq \phi_i(\tilde{V})$. Thus we have $\phi_i(\tilde{V}) = \phi_i(V) \cup \phi_j(V) \cup \phi_k(V)$. The same set of arguments shows that $\phi_j(\tilde{V}) = \phi_k(\tilde{V}) = \phi_i(V) \cup \phi_j(V) \cup \phi_k(V)$.

By Lemma 1, we know that $|\tilde{V}| \le |\phi_i(\tilde{V})||\phi_j(\tilde{V})||\phi_k(\tilde{V})|$. Substituting the above results in this inequality yields $6|V| \le |\phi_i(V) \cup \phi_j(V) \cup \phi_k(V)|^3$. □

Lemma 2 indicates that when $\phi_i(V) = \phi_j(V) = \phi_k(V)$, these projections can be utilized in at most $\frac{|\phi_i(V)|^3}{6}$ points of a 3-dimensional symmetric iteration space.

# 5 Memory-Independent Communication Bounds

Our lower bound arguments minimize the total amount of data required to perform a processor's assigned computation. Ultimately our lower bound relies on a constrained minimization problem which we state abstractly in Lemma 3. The objective function of the minimization problem gives the number of elements which must be accessed to perform the required computation. The first constraint comes from the assumption that the processor performs $1/P$th of the ternary multiplications associated with the strict lower tetrahedron of the symmetric tensor. The second constraint comes from Lemma 2.

We can prove the following lemma by taking minimum values of both variables.

LEMMA 3. Consider the following optimization problem:

$$ \min x_1 + 2x_2 $$

such that

$$ \frac{n(n-1)(n-2)}{6P} \le x_1, $$

$$ \frac{n(n-1)(n-2)}{P} \le x_2^3, $$

where $P \ge 1$, and $n$ is a positive integer. The optimal solution occurs at $\left(\frac{n(n-1)(n-2)}{6P}, \left(\frac{n(n-1)(n-2)}{P}\right)^{1/3}\right)$.

## 5.1 Communication Lower Bounds

We now apply the solution of Lemma 3 to derive the communication bounds for the STTSV computation, presented as Theorem 1. We consider a single processor that performs the computations associated with $1/P$th of iteration points and has access to $1/P$th of the data. To obtain the lower bound on communication, we subtract the quantity of data the processor stores at the start and end of the computation from the required amount of data to perform its computations.

THEOREM 1. Consider the STTSV computation, $y = A \times_2 x \times_3 x$, where $x$ and $y$ are vectors of length $n$ and $A$ has dimensions $n \times n \times n$. Suppose a parallel atomic algorithm using $P$ processors begins with one copy of $x$ and the strict lower tetrahedron of $A$, and ends with one copy of $y$. If each processor performs the ternary multiplications associated with $1/P$th
of the points in the iteration space involving the strict lower tetrahedron of A, then at least one processor must communicate at least $2 \left( \frac{n(n-1)(n-2)}{P} \right)^{1/3} - 2 \frac{n}{P}$ elements.

PROOF. To begin we note that there are $\frac{n(n-1)(n-2)}{6}$ elements in the strict lower tetrahedron of A and n elements each in x and y. There must be a processor that owns at most 1/Pth of these elements as otherwise input and output elements need to be replicated contradicting our assumptions.

We determine how many elements this processor must access to perform the ternary multiplications of the assigned iteration points. Let F be the set of points $(i, j, k)$ associated with the strict lower tetrahedron of A assigned to this processor. Then $F \subseteq \{(i, j, k) \in \mathbb{Z}^3 | i > j > k\}$ and $|F| \ge \frac{n(n-1)(n-2)}{6P}$ by our assumption that this processor performs $\frac{n(n-1)(n-2)}{6P}$ iteration points.

By Lemma 2, we know that

$$|\phi_i(F) \cup \phi_j(F) \cup \phi_k(F)|^3 \ge 6|F| \ge \frac{n(n-1)(n-2)}{P}.$$

For each point, in F, exactly one element of A is accessed, thus the total number of accessed elements of A is $|F|$. The union of projections of F, $\phi_i(F) \cup \phi_j(F) \cup \phi_k(F)$, gives the indices of the elements of each vector x and y accessed or modified by the processor. To minimize the communication we want to minimize the number of elements accessed by this processor. Thus we want to minimize $|F| + 2|\phi_i(F) \cup \phi_j(F) \cup \phi_k(F)|$ subject to the above constraints. By Lemma 3, the minimum number of elements that must be accessed by this processor is $\frac{n(n-1)(n-2)}{6P} + 2 \left( \frac{n(n-1)(n-2)}{P} \right)^{1/3}$.

As the processor owns at most $\frac{n(n-1)(n-2)}{6P} + \frac{2n}{P}$ elements, the number of elements communicated must be at least

$$\frac{n(n-1)(n-2)}{6P} + 2 \left( \frac{n(n-1)(n-2)}{P} \right)^{1/3} - \left( \frac{n(n-1)(n-1)}{6P} + \frac{2n}{P} \right) = 2 \left( \frac{n(n-1)(n-2)}{P} \right)^{1/3} - 2 \frac{n}{P}.$$

□

# 6 Tetrahedral Block Partitioning

Communication optimal algorithms for several symmetric matrix computations have been proposed recently [2, 4, 6, 10]. These algorithms improve the communication complexity for computations involving symmetric matrices by partitioning the lower triangle of a symmetric matrix into triangle blocks which allows all computations involving an element of the symmetric matrix to be computed together. A triangle block is the set of pairs corresponding to the strict lower triangle of the product of a set of indices with itself. For example, given a set of indices $\{1, 4, 6, 8\}$, the associated triangle block is the set of pairs $\{(4, 1), (6, 1), (8, 1), (6, 4), (8, 4), (8, 6)\}$. By using a triangle block partition of the symmetric matrix, a processor can perform operations with $O(r^2)$ elements of the symmetric matrix by using only r elements from the same column of a non-symmetric matrix.

We generalize the definition of triangle blocks to 3-dimensions so that we can partition the lower tetrahedron of a symmetric 3-dimensional tensor into tetrahedral blocks. Let R be a subset of indices of the symmetric 3-dimensional tensor, $R \subseteq \{1, \dots, n\}$, then the tetrahedral block defined by R is $TB_3(R) = \{(i, j, k) | i, j, k \in R, i > j > k\}$. For example, $TB_3(\{1, 4, 6, 8\}) = \{(6, 4, 1), (8, 4, 1), (8, 6, 1), (8, 6, 4)\}$. In order to partition the lower tetrahedron of a symmetric 3-dimensional tensor into tetrahedral blocks, we rely on Steiner systems which are well studied combinatorial objects.

DEFINITION 2. [16, Section 3] A Steiner (n, r, s)-system is a collection $\Sigma$ of subsets of size r from the set $S = \{1, \dots, n\}$ such that every subset of S of size s is contained in exactly one set from $\Sigma$.
While general results on the existence of Steiner systems are due to Keevash [20], existence results for $s = 3$ are due to Wilson [30].

**THEOREM 2.** [30, Corollary A] Given a positive integer $r$, there exists an $n_0 \in \mathbb{Z}$ such that Steiner $(n, r, 3)$ systems exist for all $n \ge n_0$ for which $r-2$ divides $n-2$, $(r-1)(r-2)$ divides $(n-1)(n-2)$ and $r(r-1)(r-2)$ divides $n(n-1)(n-2)$.

The following lemmas, which follow directly from Theorem 3.3 of [13], allow us to count the number of subsets in a Steiner $(n, r, 3)$ system which share two or 1 element subsets of the original set $S = \{1, \dots, n\}$.

**LEMMA 4.** If $\Sigma$ is a Steiner $(n, r, 3)$ system and $X$ any 2 element subset of $S$, then the number of subsets in $\Sigma$ containing $X$ is $\frac{n-2}{r-2}$.

**LEMMA 5.** If $\Sigma$ is a Steiner $(n, r, 3)$ system then any element of $S$ appears in exactly $\frac{(n-1)(n-2)}{(r-1)(r-2)}$ subsets.

A well known infinite family of Steiner $(n, r, 3)$ systems can be constructed from finite spherical geometries.

**THEOREM 3.** [13, Example 3.23] Let $q$ be a prime power and $\alpha > 0$ an integer. Then $G = PGL_2(q^\alpha)$ acts sharply 3-transitively on $\mathbb{F}_q^\alpha \cup \{\infty\}$. If $S \subseteq \mathbb{F}_q^\alpha \cup \{\infty\}$ is the natural inclusion of $\mathbb{F}_q \cup \{\infty\}$, then the orbit of $S$ under the action of $G$ is a Steiner $(q^\alpha + 1, q + 1, 3)$ system.

To construct these systems, one can compute the images of $\mathbb{F}_q \cup \{\infty\}$ under one element of each coset in $PGL_2(q^\alpha)/PGL_2(q)$.

A Steiner $(q^\alpha + 1, q + 1, 3)$ system has $\frac{(q^\alpha+1)q^\alpha(q^{\alpha-1})}{(q+1)q(q-1)}$ subsets. A tetrahedral block can be constructed from each subset. We will use tetrahedral block constructions from Steiner $(q^2 + 1, q + 1, 3)$ systems to simplify the analysis of our algorithm. In this case, there are $|\Sigma| = \frac{(q^2+1)q^2(q^{2-1})}{(q+1)q(q-1)} = q(q^2 + 1)$ blocks, any index appears in $\frac{q^2(q^{2-1})}{q(q-1)} = q(q+1)$ blocks by Lemma 5, and two distinct indices together appear in $\frac{q^2-1}{q-1} = q+1$ blocks by Lemma 4.

## 6.1 Data distributions and assignment of computations

As the communication lower bounds of Section 5 do not contain any terms from communicating the symmetric tensor, we design algorithms that only communicate entries from the vectors. To do this, each processor begins the computation with a tetrahedral block of the symmetric tensor and performs all computations that involve elements of the block. Thus the number of processors $P$ must match the number of tetrahedral blocks produced by our blocking scheme, and we assume that $P = q(q^2 + 1)$ for some prime power $q$.

In order to partition the lower tetrahedron of a tensor with dimension $n$ using a Steiner $(q^2 + 1, q + 1, 3)$ system we follow Al Daas et al. [4] and use a tetrahedral block of blocks. For the given $n$ and $P = q(q^2 + 1)$, we divide the indices $\{1, \dots, n\}$ into contiguous parts, each of length $b = n/(q^2 + 1)$. Then we work with $b \times b \times b$ blocks of the symmetric tensor, and $b$ contiguous elements of the vector. If $q^2 + 1$ does not divide $n$, we can pad our tensor to dimension $n'$, where $n'$ is the smallest multiple of $q^2 + 1$ that is at least $n$, satisfying the divisibility condition and set $b = n'/(q^2 + 1)$.

To simplify our presentation, we name different types of blocks from the symmetric tensor. As we only consider the blocks in the lower tetrahedron of $\mathcal{A}$, all block indices satisfy $i \ge j \ge k$.

* *off-diagonal block:* a block with index $(i, j, k)$ is called *off-diagonal* if $i > j > k$.

* *non-central diagonal block:* a block is called *non-central diagonal* if exactly two of its indices are equal.

* *central diagonal block:* a block is called *central diagonal* if all its indices are equal.

There are $(q^2+1)(q^2+2)(q^2+3)/6$ blocks in the lower tetrahedron of the symmetric tensor where $(q^2+1)q^2(q^2-1)/6$ blocks are off diagonal, $q^2(q^2+1)$ blocks are non-central diagonal and $q^2+1$ blocks are central diagonal. The Steiner
<table><caption>Table 1. Processor sets of tetrahedral block partition for $m = 10$ and $P = 30$. Processor $p$ owns all $TB_3(R_p) \cup N_p \cup D_p$ blocks of the symmetric tensor and performs all required computations with them.</caption><thead><tr><th>p</th><th>R<sub>p</sub></th><th>N<sub>p</sub></th><th>D<sub>p</sub></th></tr></thead><tbody><tr><td>1</td><td>{1,2,3,7}</td><td>{(2,2,1), (2,1,1), (7,2,2)}</td><td>{(1,1,1)}</td></tr><tr><td>2</td><td>{1,2,4,5}</td><td>{(4,4,1), (4,1,1), (5,1,1)}</td><td>{(2,2,2)}</td></tr><tr><td>3</td><td>{1,2,6,10}</td><td>{(6,6,1),(10,10,2), (6,1,1)}</td><td>{(6,6,6)}</td></tr><tr><td>4</td><td>{1,2,8,9}</td><td>{(8,8,1),(9,9,8), (8,1,1)}</td><td>{(8,8,8)}</td></tr><tr><td>5</td><td>{1,3,4,10}</td><td>{(10,10,1),(10,10,3), (10,1,1)}</td><td>{(3,3,3)}</td></tr><tr><td>6</td><td>{1,3,5,8}</td><td>{(3,3,1),(8,8,5), (3,1,1)}</td><td>{(5,5,5)}</td></tr><tr><td>7</td><td>{1,3,6,9}</td><td>{(9,9,1),(9,9,3), (9,1,1)}</td><td>{(9,9,9)}</td></tr><tr><td>8</td><td>{1,4,6,8}</td><td>{(6,6,4),(8,8,6), (6,4,4)}</td><td>{(4,4,4)}</td></tr><tr><td>9</td><td>{1,4,7,9}</td><td>{(7,7,1), (9,9,4), (7,1,1)}</td><td>{(7,7,7)}</td></tr><tr><td>10</td><td>{1,5,6,7}</td><td>{(5,5,1), (7,7,6), (7,6,6)}</td><td>{}</td></tr><tr><td>11</td><td>{1,5,9,10}</td><td>{(9,9,5),(10,10,9), (9,5,5)}</td><td>{(10,10,10)}</td></tr><tr><td>12</td><td>{1,7,8,10}</td><td>{(8,8,7),(10,10,8), (10,8,8)}</td><td>{}</td></tr><tr><td>13</td><td>{2,3,4,8}</td><td>{(3,3,2), (3,2,2),(4,2,2)}</td><td>{}</td></tr><tr><td>14</td><td>{2,3,5,6}</td><td>{(5,5,2), (5,2,2),(6,5,5)}</td><td>{}</td></tr><tr><td>15</td><td>{2,3,9,10}</td><td>{(9,9,2), (9,2,2),(10,2,2)}</td><td>{}</td></tr><tr><td>16</td><td>{2,4,6,9}</td><td>{(4,4,2), (9,9,6), (9,6,6)}</td><td>{}</td></tr><tr><td>17</td><td>{2,4,7,10}</td><td>{(7,7,2),(10,10,4), (10,4,4)}</td><td>{}</td></tr><tr><td>18</td><td>{2,5,7,9}</td><td>{(7,7,5),(9,9,7), (7,5,5)}</td><td>{}</td></tr><tr><td>19</td><td>{2,5,8,10}</td><td>{(8,8,2), (8,2,2),(10,5,5)}</td><td>{}</td></tr><tr><td>20</td><td>{2,6,7,8}</td><td>{(6,6,2), (6,2,2),(8,6,6)}</td><td>{}</td></tr><tr><td>21</td><td>{3,4,5,9}</td><td>{(4,4,3), (4,3,3),(9,4,4)}</td><td>{}</td></tr><tr><td>22</td><td>{3,4,6,7}</td><td>{(6,6,3), (6,3,3),(7,3,3)}</td><td>{}</td></tr><tr><td>23</td><td>{3,5,7,10}</td><td>{(5,5,3), (5,3,3),(10,3,3)}</td><td>{}</td></tr><tr><td>24</td><td>{3,6,8,10}</td><td>{(8,8,3),(10,10,6), (8,3,3)}</td><td>{}</td></tr><tr><td>25</td><td>{3,7,8,9}</td><td>{(7,7,3), (9,7,7),(9,3,3)}</td><td>{}</td></tr><tr><td>26</td><td>{4,5,6,10}</td><td>{(5,5,4), (5,4,4),(10,10,5)}</td><td>{}</td></tr><tr><td>27</td><td>{4,5,7,8}</td><td>{(7,7,4), (7,4,4),(8,7,7)}</td><td>{}</td></tr><tr><td>28</td><td>{4,8,9,10}</td><td>{(8,8,4), (8,4,4),(10,9,9)}</td><td>{}</td></tr><tr><td>29</td><td>{5,6,8,9}</td><td>{(6,6,5), (8,5,5), (9,8,8)}</td><td>{}</td></tr><tr><td>30</td><td>{6,7,9,10}</td><td>{(10,6,6),(10,10,7), (10,7,7)}</td><td>{}</td></tr></tbody></table>

system partitions the off diagonal blocks, but we need to assign the diagonal blocks to processors in a way that is compatible with the assignment of off diagonal blocks, specifically in a way that their computations do not require any vector elements that are not already required by the processor.

Let {$R_p$} be the set of subsets of {$1, \dots, q^2 + 1$} defined by the Steiner ($q^2 + 1, q + 1, 3$) system, so $|R_p| = q + 1$. We let $N_p$ and $D_p$ represent a set of non-central diagonal blocks and a set of central diagonal blocks, respectively, assigned to processor $p$. Table 1 shows the assignment of all lower tetrahedral blocks of a symmetric tensor from the Steiner (10, 4, 3) system. We will work with this example throughout the text.

We first discuss the data distribution of the off-diagonal blocks of the symmetric tensor, followed by the data distribution of both vectors, and then the data distribution of the non-central and central diagonal blocks of the symmetric tensor.

### 6.1.1 Data distribution of off-diagonal blocks.
The blocks corresponding to indices of $TB_3(R_p)$ are assigned to processor $p$. As $|R_p| = q+1$, processor $p$ has all $(q+1)q(q-1)/6$ off-diagonal blocks corresponding to $TB_3(R_p)$ at the beginning of
<table><caption>Table 2. Row block sets of tetrahedral block partition for $m = 10$ and $P = 30$. Row block $i$ of a vector is evenly distributed among all processors of $Q_i$.</caption><thead><tr><th>i</th><th>Q<sub>i</sub></th></tr></thead><tbody><tr><td>1</td><td>{1,2,3,4,5,6,7,8,9,10,11,12}</td></tr><tr><td>2</td><td>{1,2,3,4,13,14,15,16,17,18,19,20}</td></tr><tr><td>3</td><td>{1,5,6,7,13,14,15,21,22,23,24,25}</td></tr><tr><td>4</td><td>{2,5,8,9,13,16,17,21,22,26,27,28}</td></tr><tr><td>5</td><td>{2,6,10,11,14,18,19,21,23,26,27,29}</td></tr><tr><td>6</td><td>{3,7,8,10,14,16,20,22,24,26,29,30}</td></tr><tr><td>7</td><td>{1,9,10,12,17,18,20,22,23,25,27,30}</td></tr><tr><td>8</td><td>{4,6,8,12,13,19,20,24,25,27,28,29}</td></tr><tr><td>9</td><td>{4,7,9,11,15,16,18,21,25,28,29,30}</td></tr><tr><td>10</td><td>{3,5,11,12,15,17,19,23,24,26,28,30}</td></tr></tbody></table>

the computation, and will perform all computations that require entries from these blocks. For example, $R_3 = \{1, 2, 6, 10\}$ in Table 1 indicates that processor 3 has blocks $(6, 2, 1)$, $(10, 2, 1)$, $(10, 6, 1)$ and $(10, 6, 2)$ of the symmetric tensor and will perform all computation involving these blocks.

### 6.1.2 Data distribution of both vectors.
We distribute row blocks of vectors $x$ and $y$ to be compatible with the data required by each processor. By Lemma 5, each row block of the vectors is required on $q(q+1)$ processors, so we distribute the row block equally on these processors. We assume that $b = \frac{n}{q^2+1} \ge q(q+1)$ to ensure that we can divide each row block across all the processors that require it. Table 2 shows which processors need a particular row block from each vector. For example, row block 3 from both vectors $x$ and $y$ is required by processors $1, 5, 6, 7, 13, 14, 15, 21, 22, 23, 24$ and $25$. We use $Q_i$ to denote the set of processors that requires the $i$th block of each vector. We obtain $\{Q_i\}$ by analyzing the sets $R_p$.

As each processor works with $q+1$ row blocks of each vector $x$ and $y$, each processor has $(q+1) \frac{b}{q(q+1)} = \frac{n}{p}$ elements of $x$ at the beginning of the computation and the same number of elements of $y$ at the end of the computation.

### 6.1.3 Data distribution of non-central and central diagonal blocks.
We first discuss the distribution of $q^2(q^2+1)$ non-central diagonal blocks of the symmetric tensor. We want to assign blocks to a processor in a compatible way with the off-diagonal blocks. Specifically we want to assign the non-central diagonal blocks in such a way that performing their associated computations only requires data from $x$ and $y$ that is already required to perform the computations associated with the off-diagonal blocks assigned to the processor. For example, processors $1, 2, 3$ and $4$ are the potential candidates for the block $(2, 2, 1)$ based on the sets $R_p$ defined in Table 1 as these processors already require the 1st and 2nd row blocks of both vectors. We assign $q^2(q^2+1)/P = q$ blocks to each processor.

Assigning disjoint sets of $q$ non-central diagonal blocks to each processor is equivalent to finding $q$ disjoint matchings in the bipartite graph $G(X, Y, E)$ with $X = \{1, \dots, P\}$ corresponding to processors, $Y = \{(a, a, b) : q^2 + 1 \ge a > b \ge 1\} \cup \{(a, b, b) : q^2 + 1 \ge a > b \ge 1\}$ corresponding to the non-central diagonal blocks, and $E = \{(x, y) \in X \times Y : y = (a, b, b) \text{ or } y = (a, a, b) \text{ and } a, b \in R_x\}$. To show that such an assignment is possible, we use the following results.

**THEOREM 4 (HALL'S MARRIAGE THEOREM, [14, THEOREM 2.1.2]).** Let $G(X, Y, E)$ be a finite bipartite graph with bipartite sets $X$ and $Y$ and edge set $E$. There exists a matching with a set of disjoint edges that covers every vertex in $X$ iff $|W| \le |N_G(W)|$ for every subset $W \subseteq X$. Here $N_G(W)$ denotes the set of all vertices in $Y$ that are adjacent to at least one vertex of $W$.
We obtain the following corollary by applying Theorem 4 on an extended graph.

**COROLLARY 5.** Let $G(X, Y, E)$ be a finite bipartite graph with bipartite sets $X$ and $Y$ and edge set $E$. There exist $d$ disjoint matchings if $d|W| \le |N_G(W)|$ for every subset $W \subseteq X$. Here $N_G(W)$ denotes the set of all vertices in $Y$ that are adjacent to at least one vertex of $W$. Every matching consists of a set of disjoint edges that covers each vertex in $X$ and exactly $|X|$ unique vertices in $Y$.

**PROOF.** We transform $G$ into a new bipartite graph $G_d$ by replacing each vertex in $X$ with $d$ copies of itself, and connect each copy as in the original graph. We apply Hall's theorem to the transformed graph. If $|W| \le d|N_G(W)|$ for every subset $W \subseteq X$, then there exists a matching in $G_d$ by Theorem 4. It implies that a matching exists for each of the $d$ copies. These matchings correspond to $d$ disjoint matchings in $G$. $\square$

From the construction of our bipartite graph, we know that each element of $X$ has $(q+1)q/2 \cdot 2 = q(q+1)$ edges because $|R_p| = q+1$ for all $p$. Each element of $Y$ has $(q^2-1)/(q-1) = (q+1)$ edges because a pair of indices occurs in exactly $(q^2-1)/(q-1)$ sets $R_p$ by Lemma 4. Thus for any $W \subseteq X$, $|N_G(W)| \ge q(q+1)/(q+1)|W| = q|W|$. By Corollary 5, there exist $q$ disjoint matchings. This is equivalent to assigning $q$ non-central diagonal blocks to each processor.

To obtain $q$ disjoint matchings, we can use maximum cardinality matching algorithms, such as the Ford-Fulkerson algorithm [15] and the Hopcroft-Karp algorithm [18], on the transformed graph.

*Data distribution of central diagonal blocks.* There are $q^2+1 < P$ central diagonal blocks, so we want to assign 1 central diagonal block to some processors in such a way that no additional data from the vectors $x$ and $y$ is required for the processor to perform the computations associated with the diagonal block. To demonstrate that there exists such an assignment, we again apply Hall's Marriage Theorem this time to the graph $G(X, Y, E)$ where $X = \{1, \dots, q^2+1\}$, $Y = \{1, \dots, P\}$ and $e = \{(x, y) : x \in R_y\}$. As $|R_p| = q+1$ for each $p$, therefore each element of $Y$ has $q+1$ edges. Each index appears in $q(q+1)$ sets $R_p$ by Lemma 5. Therefore, each element of $X$ has $q(q+1)$ edges. Thus for any $W \subseteq X$, $|N_G(W)| \ge q(q+1)/(q+1)|W| = q|W|$. By Theorem 4, a matching can be found. Again to find the matching we can use a maximum cardinality matching algorithm.

Recall that the block size is $b = n/(q^2+1)$ and $P = q(q^2+1)$. The numbers of lower tetrahedral elements in an off-diagonal block, a non-central diagonal block and a central diagonal block are $b^3$, $b^2(b+1)/2$ and $b(b+1)(b+2)/6$, respectively. As each processor owns $(q+1)q(q-1)/6$ off-diagonal blocks, $q$ non-central diagonal blocks, and up to 1 central diagonal block of the symmetric tensor, the processor stores at most

$$ \frac{(q+1)q(q-1)}{6}b^3 + q\frac{b^2(b+1)}{2} + \frac{b(b+1)(b+2)}{6} \approx \frac{n^3}{6P} $$

elements of the tensor.

## 7 Algorithm

Now we present our algorithm that attains the lower bound of Theorem 1 matching the leading order constant exactly. It is outlined in Algorithm 5.

We use $\Pi$ to denote the set of all processors where $|\Pi| = P = q(q^2+1)$ for a prime power $q$. We use $\mathbf{x}[i]$ to denote the $i$th row block of $\mathbf{x}$, and $\mathcal{A}[i][j][k]$ to denote the block of $\mathcal{A}$ at index $(i, j, k)$. To perform the local computation, each processor $p$ must gather $q+1$ row blocks corresponding to the set $R_p$ for the vector $\mathbf{x}$. The processor owns only the $\mathbf{x}[i]^{(p)}$ portion of the $\mathbf{x}[i]$ row block for each $i \in R_p$, therefore it must communicate with the other processors in $Q_i$ to gather the full $\mathbf{x}[i]$ block. As any processor may communicate to at most $P-1$ processors, we expressed our
<caption>**Algorithm 5 Parallel STTSV computation**</caption>

**Require:** $q$ is a prime power
**Require:** $b = n/(q^2 + 1)$ is the block size and $m = n/b$.
**Require:** $\Pi$ is a set of processors with $|\Pi| = P = q(q^2 + 1)$.
**Require:** $\mathcal{A}[T_p] = \{\mathcal{A}[i][j][k] : i > j > k \in R_p\} \cup \{\mathcal{A}[i][i][k] : (i, i, k) \in N_p\} \cup \{\mathcal{A}[i][k][k] : (i, k, k) \in N_p\} \cup \{\mathcal{A}[i][i][i] : (i, i, i) \in D_p\}$ is extended tetrahedral block owned by processor $p$.
**Require:** $x$ is evenly divided into $m$ row blocks, and each row block $x[i]$ is evenly divided across a set of $q(q+1)$ processors $Q_i$ with $x[i]^{(p)}$ owned by processor $p$ so that $x[R_p]^{(p)} = \{x[i]^{(p)} : i \in R_p\}$ is a set of data blocks of $x$ owned by processor $p$. Similarly, $y[R_p]^{(p)}$ is defined and it is owned by processor $p$.
**Ensure:** $y = \mathcal{A} \times_2 x \times_3 x$ with $y[R_p]^{(p)}$ owned by processor $p$.
1: **function** $y[R_p]^{(p)} = \text{STTSV}(\mathcal{A}[T_p], x[R_p]^{(p)}, \Pi)$
2: $p = \text{MYRANK}(\Pi)$
3: Allocate array $\bar{x}$ of $2P$ blocks, each of size $\frac{b}{q(q+1)}$
4: **for all** $i \in R_p$ **do**
5: &nbsp;&nbsp;&nbsp;&nbsp;**for all** $p' \in Q_i \setminus \{p\}$ **do**
6: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\bar{x}[p'] = x[i]^{(p)}$
7: &nbsp;&nbsp;&nbsp;&nbsp;**end for**
8: **end for**
9: $\bar{x} = \text{ALL-TO-ALL}(\bar{x}, \Pi)$
10: **for all** $i \in R_p$ **do**
11: &nbsp;&nbsp;&nbsp;&nbsp;**for all** $p' \in Q_i \setminus \{p\}$ **do**
12: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Store $\bar{x}[p']$ into $x[i]$
13: &nbsp;&nbsp;&nbsp;&nbsp;**end for**
14: **end for**
15: Initialize portions of row blocks of $y$ own by $p$ to 0
16: **for all** $\mathcal{A}[i][j][k] \in \mathcal{A}[T_k]$ **do**
17: &nbsp;&nbsp;&nbsp;&nbsp;**if** $i \neq j \neq k$ **then**
18: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$y[i] = 2\mathcal{A}[i][j][k] \times_2 x[j] \times_3 x[k]$
19: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$y[j] = 2\mathcal{A}[i][j][k] \times_1 x[i] \times_3 x[k]$
20: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$y[k] = 2\mathcal{A}[i][j][k] \times_1 x[i] \times_2 x[j]$
21: &nbsp;&nbsp;&nbsp;&nbsp;**else if** $i == j$ and $j \neq k$ **then**
22: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$y[i] = 2\mathcal{A}[i][i][k] \times_2 x[i] \times_3 x[k]$; $y[k] = \mathcal{A}[i][i][k] \times_1 x[i] \times_2 x[i]$
23: &nbsp;&nbsp;&nbsp;&nbsp;**else if** $i \neq j$ and $j == k$ **then**
24: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$y[i] = \mathcal{A}[i][k][k] \times_2 x[k] \times_3 x[k]$; $y[k] = 2\mathcal{A}[i][k][k] \times_1 x[i] \times_2 x[k]$
25: &nbsp;&nbsp;&nbsp;&nbsp;**else**
26: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$y[i] = \mathcal{A}[i][i][i] \times_2 x[i] \times_3 x[i]$
27: **end if**
28: **end for**
29: Allocate array $\bar{y}$ of $2P$ blocks, each of size $\frac{b}{q(q+1)}$
30: **for all** $i \in R_p$ **do**
31: &nbsp;&nbsp;&nbsp;&nbsp;**for all** $p' \in Q_i \setminus \{p\}$ **do**
32: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\bar{y}[p'] = y[i]^{(p)}$
33: &nbsp;&nbsp;&nbsp;&nbsp;**end for**
34: **end for**
35: $\bar{y} = \text{ALL-TO-ALL}(\bar{y}, \Pi)$
36: **for all** $i \in R_p$ **do**
37: &nbsp;&nbsp;&nbsp;&nbsp;$y[i]^{(p)} += \bar{y}[i]^{(p)}$
38: &nbsp;&nbsp;&nbsp;&nbsp;**for all** $p' \in Q_i \setminus \{p\}$ **do**
39: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$y[i]^{(p)} += \bar{y}[p']$
40: &nbsp;&nbsp;&nbsp;&nbsp;**end for**
41: **end for**
42: **end function**

▶ Store its own data of a row in $q(q+1) - 1$ blocks

▶ Perform local computations (ternary multiplications)

▶ Distribute and reduce results for each row block set
communication pattern with a ALL-TO-ALL collective which is presented in line 3 to line 14. Most of the pseudocode involves packing and unpacking of a temporary array $\bar{x}$ to organize the data for communication. Each processor performs its share of local computations (ternary multiplications) in line 16 to line 28 to compute its partial contributions to y. Then, each processor p must share the partially computed y[i] with the other processors in $Q_i$ to obtain the final y[i]($p$) portion of y[i] for each $i \in R_p$. This communication pattern is also expressed with an ALL-TO-ALL collective, which is presented in line 29 to line 41. Similar to the communication of x, a temporary array $\bar{y}$ is employed to pack and unpack the data for communication. The processor p sums all partial results in line 39 to obtain the final y[i]($p$).

## 7.1 Computational Cost Analysis

We express the computational cost of the algorithm in terms of number of ternary multiplications performed. Recall that the dimension of each row block of a vector is $b = n/(q^2 + 1)$, and the dimensions of each block of the symmetric tensor are $b \times b \times b$. We analyze the amount of computations performed for each type of block of the symmetric tensor. There are $b^3$ strict lower tetrahedral elements of $\mathcal{A}$ in an off-diagonal block, therefore the number of ternary multiplications performed by the algorithm for each block is $3b^3$. There are $b^2(b+1)/2$ lower tetrahedral elements of $\mathcal{A}$ in a non-central diagonal block, of which $b^2(b-1)/2$ are strictly lower tetrahedral elements and $b^2$ are non-central diagonal elements. Therefore, the number of ternary multiplications performed by the algorithm for each non-central diagonal block is $3b^2(b-1)/2 + 2b^2$. A central diagonal block contains $b(b+1)(b+2)/6$ lower tetrahedral elements of $\mathcal{A}$, among which $b(b-1)(b-2)/6$ are strictly lower tetrahedral elements, $b(b-1)$ are non-central diagonal elements and $b$ are central diagonal elements. Therefore, the number of ternary multiplications performed by the algorithm for each central diagonal block is $3b(b-1)(b-2)/6 + 2b(b-1) + b$.

All ternary multiplications occur between line 16 and line 28 in Algorithm 5. For every p, we have $|R_p| = q + 1$, $|N_p| = q$ and $|D_p| \in \{0, 1\}$. Thus the computational cost of the algorithm, in terms of ternary multiplications performed, is at most

$$ \frac{(q+1)q(q-1)}{6} \cdot 3b^3 + q \cdot 3b^2(b-1) + \frac{3b(b-1)(b-2)}{6}. $$

As $q(q^2 + 1) = P$ and $b = n/(q^2 + 1)$, the leading order terms of the computational cost is

$$ \frac{n^3}{2q^3} + \frac{3n^3}{q^5} + \frac{n^3}{2q^6} = \frac{n^3}{2P} + o\left(\frac{n^3}{P}\right). $$

Note that we may not have perfect computational load balance, as not all processors are assigned a central diagonal block. However the imbalance does not affect the constant in the leading order term.

## 7.2 Communication Cost Analysis

### 7.2.1 New Results on Communication Costs.
Here we present results that we will use while analyzing communication cost of our parallel algorithm in Section 7. One can easily obtain the following lemma by applying Theorem 4 on a bipartite graph where each vertex in X and Y is repeated d times.

**LEMMA 6.** Let $G(X, Y)$ be a finite bipartite graph with bipartite sets X and Y, where $|X| = |Y|$, each vertex in X is connected to exactly d vertices in Y, and vice versa. There exist d disjoint matchings in G, and each of them covers every vertex in X and Y.

We can use maximum cardinality matching algorithms, such as the Ford-Fulkerson algorithm [15] and the Hopcroft-Karp algorithm [18], on G to obtain d such matchings.
We will use Lemma 6 to bound the number of words sent by any processor in a set of processors, where each processor communicates with the same number of processors. We remind the reader that, in our model, a processor can send and receive at most one message at the same time.

**THEOREM 6.** *Consider a set of *P* processors. Every processor needs to send and receive one message of *W* words to and from each processor in a set of *d* ($d \le P-1$) processors. Then, all required communication can be performed in *d* steps, with the maximum number of words sent or received by any processor being *dW*.*

**PROOF.** Consider the bipartite graph $G(X, Y)$ with $X = Y = \{1, \dots, P\}$ corresponding to processors. If a processor $i$ needs to send a message to processor $j$, then there is an edge from $i \in X$ to $j \in Y$. From the construction, each vertex in $X$ is connected to exactly $d$ vertices in $Y$, and vice versa. By Lemma 6, there exist $d$ matchings and each of them covers all the vertices of $X$ and $Y$. We can see that each matching corresponds to a communication step that describes how processors can communicate. Every processor sends and receives $W$ words in each step. As there are $d$ different matchings, every processor can perform all required communication in $d$ steps and the total number of words sent or received by the processor is $dW$. $\square$

### 7.2.2 Communication Cost of Algorithm 5.
The communication is performed in line 9 to collect all required row blocks of the input vector $x$ and in line 35 to distribute the partially computed row blocks of the output vector $y$.

Each row block of a vector is shared evenly among $q(q+1)$ processors. Therefore, each participating processor must send $\frac{b}{q(q+1)}$ words of the block to all other participating processors and receive the same number of words from each of them. For every $p$, $|R_p| = q+1$, therefore each processor owns portions of $q+1$ row blocks of a vector. Thus, each processor must send $(q+1)\frac{b}{q(q+1)}(q(q+1)-1) = n\frac{q+1}{q^2+1} - \frac{n}{p}$ words and receive the same number of words, in total, for each vector.

In Table 1, we can observe that processor 1 does not share any data with processor 26. This indicates that each processor does not need to communicate to all other processors. We expressed communication in our algorithm using ALL-TO-ALL collectives to simplify our presentation. However, it can be accomplished by directly communicating between source and destination. We will show that it is possible to perform only the required amount of data transfers for each vector in $(q+1)(q(q+1)-1) - q\frac{q(q+1)}{2} = \frac{q^3}{2} + \frac{3q^2}{2} - 1$ steps.

As each processor owns row blocks of a vector defined by a tetrahedral block partition, any pair of processors can share at most 2 row blocks. Any pair of row blocks is present in $q+1$ sets $R_p$ by Lemma 4, each participating processor will communicate data from its data from 2 row blocks with other participating processors. There are $q(q+1)/2$ possible pairs for a $R_p$ set, therefore each processor will communicate 2 row blocks with $\frac{q(q+1)}{2}(q+1-1) = \frac{q^2(q+1)}{2}$ processors. By Theorem 6, all required communication can be performed in $\frac{q^2(q+1)}{2}$ steps, where each processor sends and receives $\frac{q^2(q+1)}{2} \cdot \frac{2b}{q(q+1)}$ words. The distribution presented in Table 1 shows that each processor will communicate 2 blocks with 18 processor for each vector.

Now we determine the number of processors with which a processor will communicate only one row block of each vector. Our algorithm requires each processor communicates $(q(q+1)-1)(q+1)$ row blocks, where 2 blocks must be sent to each of $\frac{q^2(q+1)}{2}$ processors. Therefore, each processor will communicate only one row block with $q^2-1$ processors. By Theorem 6, all required communications can be performed in $q^2-1$ steps, where each processor sends and receives $(q^2-1) \cdot \frac{b}{q(q+1)}$ words. In our working example processor 1 communicates only one row block with processors 8, 11, 16, 19, 21, 24, 27 and 30.
Thus each processor sends and receives $q^2(q+1) \cdot \frac{b}{q(q+1)} + (q^2 - 1) \cdot \frac{b}{q(q+1)} = n \frac{q+1}{q^2+1} - \frac{n}{P}$ words in $\frac{q^2(q+1)}{2} + q^2 - 1 = \frac{q^3}{2} + \frac{3q^2}{2} - 1$ steps. We show a sequence of communication steps for a relatively small example in Appendix A.

As communication is performed for both vectors, the bandwidth cost of the algorithm is

$$2 \left( n \frac{q+1}{q^2+1} - \frac{n}{P} \right).$$

As $P = q(q^2 + 1)$, which implies that $(q^2 + 1)/(q + 1) \approx P^{1/3}$, the bandwidth cost is dominated by $2(n/P^{1/3} - n/P)$. Hence the bandwidth cost of the algorithm matches the leading term in the lower bound exactly.

*Communication cost of our algorithm with All-to-All collectives.* Here we discuss bandwidth cost of our algorithm when ALL-TO-ALL collectives are used to communicate both vectors x and y. An ALL-TO-ALL collective, using an algorithm that achieves optimal bandwidth cost, takes $P - 1$ steps [29]. For each vector, at each step, a processor may send its own data of 2 row blocks to another processor. Therefore, the bandwidth cost of each step is $2 \frac{b}{q(q+1)}$, and the overall bandwidth cost of an ALL-TO-ALL collective is $2 \frac{b}{q(q+1)}(P - 1) = \frac{2n}{q+1}(1 - 1/P)$. As communication is performed for both vectors, the bandwidth cost of the algorithm using ALL-TO-ALL collectives is $\frac{4n}{q+1}(1 - 1/P)$. Given that $P = q(q^2 + 1)$, which implies $q \approx P^{1/3}$, the bandwidth cost is dominated by $4n/P^{1/3}$, which is twice the leading term in the lower bound.

## 8 Conclusion

In this work, we establish communication lower bounds for the parallel STTSV computation. The lower bound on accessed data is formulated as the solution of a constrained optimization problem. One of the constraints is obtained by manipulating the symmetric iteration space and deriving a relation between the number of iteration points and the required data access within vectors. We also show that our bounds are tight by presenting a communication optimal algorithm. We extend the triangle block partition scheme proposed by Beaumont et al. [10] and Al Daas et al. [4] for the lower triangle of symmetric matrices to a tetrahedral partition of the lower tetrahedron of 3-dimensional symmetric tensors. Our algorithm works with tetrahedral blocks that reduces data accesses within vectors. We use Steiner systems, which provide collections of equally sized subsets of indices where any three distinct indices appear in exactly one subset, to generate the tetrahedral partitions.

We focus on Algorithm 4 that performs $n^2(n+1)/2$ ternary multiplications. Each ternary multiplication requires 2 elementary multiplications. Furthermore, an addition and often a multiplication are involved with each ternary multiplication. Therefore, the algorithm needs to perform a total of approximately $2n^3$ elementary arithmetic operations. In our approach, we assume that each ternary multiplication is computed on a single processor, i.e, partial ternary multiplications are not reused across processors. However it is reasonable for an algorithm to break this assumption to improve arithmetic costs by reusing partial results across processors. For example, STTSV can also be performed in sequence, first $A \times_2 x$ is computed with parallel matrix multiplication and then the result is multiplied with $x$ in parallel to obtain the final output. This approach requires performing a total of $2n^3 + 2n^2$ elementary arithmetic operations. However, by leveraging symmetry, the total number of operations can be reduced by almost half. When $P$ is small ($P \le n$), bandwidth cost of the first step is at least $O(n)$ [3], which is asymptotically larger than that of our algorithm. We plan to study the sequence approach for parallel STTSV computation in detail in the future.
We intend to generalize our results for d-dimensional computations. The lower bound arguments can easily be extended for d-dimensional STTSV computations. However, there are no known infinite families of Steiner systems for s > 3, so constructing partitions for higher dimensions is more challenging.

In our computational model, we assume that each processor has sufficiently large local memory. Therefore, our algorithm may not be feasible in limited-memory scenarios. We plan to explore parallel algorithms that are communication optimal for such scenarios.

Matricized tensor times Khatri-Rao product (MTTKRP) is a bottleneck operation for algorithms to compute a Canonical Polyadic tensor decomposition. Mode-1 MTTKRP for a 3-dimensional symmetric tensor A can be computed element-wise as

$$Y_{it} = \sum_{j,k} A_{ijk} \cdot X_{jt} \cdot X_{kt}.$$

Here X is the factor matrix associated with the decomposition. For a fixed t, the above expression represents a STTSV computation. We plan to generalize our lower bound and algorithm to MTTKRP in the future.

## Acknowledgments

This project has received funding through the UKRI Digital Research Infrastructure Programme through the Science and Technology Facilities Council's Computational Science Centre for Research Communities (CoSeC). This project received funding from the European Research Council (ERC) under European Union's Horizon 2020 research and innovation program (grant agreement 810367). This work is supported by the National Science Foundation under grant CCF-1942892. This material is based upon work supported by the US Department of Energy, Office of Science, Advanced Scientific Computing Research program under award DE-SC-0023296.

## References

[1] A. Aggarwal, A. K. Chandra, and M. Snir. 1990. Communication Complexity of PRAMs. Theor. Comp. Sci. 71, 1 (1990). doi:10.1016/0304-3975(90)90188-N

[2] E. Agullo, A. Buttari, O. Coulaud, L. Eyraud-Dubois, M. Faverge, A. Franc, A. Guermouche, A. Jego, R. Peressoni, and F. Pruvost. 2023. On the Arithmetic Intensity of Distributed-Memory Dense Matrix Multiplication Involving a Symmetric Input Matrix (SYMM). In 2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE, 357-367. doi:10.1109/IPDPS54959.2023.00044

[3] H. Al Daas, G. Ballard, L. Grigori, S. Kumar, and K. Rouse. 2022. Brief Announcement: Tight Memory-Independent Parallel Matrix Multiplication Communication Lower Bounds. In Proceedings of the 34th ACM Symposium on Parallelism in Algorithms and Architectures (Philadelphia, PA, USA) (SPAA '22). Association for Computing Machinery, New York, NY, USA, 445-448. doi:10.1145/3490148.3538552

[4] H. Al Daas, G. Ballard, L. Grigori, S. Kumar, and K. Rouse. 2023. Parallel Memory-Independent Communication Bounds for SYRK. In Proceedings of the 35th ACM Symposium on Parallelism in Algorithms and Architectures (Orlando, FL, USA) (SPAA '23). Association for Computing Machinery, New York, NY, USA, 391-401. doi:10.1145/3558481.3591072

[5] H Al Daas, G. Ballard, L. Grigori, S. Kumar, and K. Rouse. 2024. Communication Lower Bounds and Optimal Algorithms for Multiple Tensor-Times-Matrix Computation. SIAM J. Matrix Anal. Appl. 45, 1 (2024), 450-477. doi:10.1137/22M1510443

[6] H. Al Daas, G. Ballard, L. Grigori, S. Kumar, K. Rouse, and M. Verite. 2025. Communication Lower Bounds and Optimal Algorithms for Symmetric Matrix Computations. ACM Trans. Parallel Comput. 12, 2, Article 6 (June 2025), 46 pages. doi:10.1145/3727344

[7] G. Ballard, E. Carson, J. Demmel, M. Hoemmen, N. Knight, and O. Schwartz. 2014. Communication Lower Bounds and Optimal Algorithms for Numerical Linear Algebra. Acta Numerica 23 (2014). doi:10.1017/S0962492914000038

[8] G. Ballard, N. Knight, and K. Rouse. 2018. Communication Lower Bounds for Matricized Tensor Times Khatri-Rao Product. In IPDPS 2018. 557-567. doi:10.1109/IPDPS.2018.00065

[9] G. Ballard and K. Rouse. 2020. General Memory-Independent Lower Bound for MTTKRP. In SIAM PP. 1-11. doi:10.1137/1.9781611976137.1

[10] O. Beaumont, L. Eyraud-Dubois, J. Langou, and M. Vérité. 2022. I/O-Optimal Algorithms for Symmetric Linear Algebra Kernels. In SPAA 2022. doi:10.1145/3490148.3538587

[11] J. Bennett, A. Carbery, M. Christ, and T. Tao. 2010. Finite bounds for Hölder-Brascamp-Lieb multilinear inequalities. Mathematical Research Letters 17, 4 (2010), 647-666. doi:10.4310/MRL.2010.v17.n4.a6
[12] E. Chan, M. Heimlich, A. Purkayastha, and R. van de Geijn. 2007. Collective Communication: Theory, Practice, and Experience. Conc. and Comp.: Prac. and Exper. 19, 13 (2007). doi:10.1002/cpe.1206

[13] C. J. Colbourn and J. H. Dinitz. 1996. Handbook of Combinatorial Designs.

[14] R. Diestel. 2017. *Graph Theory*. Springer Berlin Heidelberg. doi:10.1007/978-3-662-53622-3

[15] L. R. Ford and D. R. Fulkerson. 1987. *Maximal Flow Through a Network*. Birkhäuser Boston, Boston, MA, 243–248. doi:10.1007/978-0-8176-4842-8_15

[16] W. T. Gowers. 2017. Probabilistic Combinatorics and the Recent Work of Peter Keevash. *Bulletin (New Series) of the American Mathematical Society* 54, 1 (2017). doi:10.1090/bull/1553

[17] J. W. Hong and H. T. Kung. 1981. I/O complexity: The Red-Blue Pebble Game. In *STOC 1981*. doi:10.1145/800076.802486

[18] J. E. Hopcroft and R. M. Karp. 1973. An $n^{5/2}$ algorithm for maximum matchings in bipartite graphs. *SIAM Journal on computing* 2, 4 (1973), 225–231. doi:10.1137/0202019

[19] D. Irony, S. Toledo, and A. Tiskin. 2004. Communication Lower Bounds for Distributed-Memory Matrix Multiplication. *J. Parallel and Distrib. Comput.* 64, 9 (2004), 1017–1026. doi:10.1016/j.jpdc.2004.03.021

[20] P. Keevash. 2014. The existence of designs. *arXiv preprint arXiv:1401.3665* (2014). https://arxiv.org/abs/1401.3665

[21] T. G. Kolda. 2015. Numerical optimization for symmetric tensor decomposition. *Mathematical Programming* 151, 1 (2015), 225–248. doi:10.1007/s10107-015-0895-0

[22] G. Kwasniewski, T. Ben-Nun, L. Gianinazzi, A. Calotoiu, T. Schneider, A. N. Ziogas, M. Besta, and T. Hoefler. 2021. Pebbles, Graphs, and a Pinch of Combinatorics: Towards Tight I/O Lower Bounds for Statically Analyzable Programs. In *Proceedings of the 33rd ACM Symposium on Parallelism in Algorithms and Architectures* (Virtual Event, USA) (SPAA '21). Association for Computing Machinery, New York, NY, USA, 328–339. doi:10.1145/3409964.3461796

[23] L.-H. Lim. 2005. Singular values and eigenvalues of tensors: a variational approach. In *1st IEEE International Workshop on Computational Advances in Multi-Sensor Adaptive Processing, 2005*. 129–132. doi:10.1109/CAMAP.2005.1574201

[24] L. H. Loomis and H. Whitney. 1949. An Inequality Related to the Isoperimetric Inequality. *Bull. Amer. Math. Soc.* 55, 10 (1949). doi:10.1090/S0002-9904-1949-09320-5

[25] A. Olivry, J. Langou, L.-N. Pouchet, P. Sadayappan, and F. Rastello. 2020. Automated Derivation of Parametric Data Movement Lower Bounds for Affine Programs. In *PLDI 2020*. doi:10.1145/3385412.3385989

[26] L. Qi. 2005. Eigenvalues of a real supersymmetric tensor. *Journal of Symbolic Computation* 40, 6 (2005), 1302–1324. doi:10.1016/j.jsc.2005.05.007

[27] S. Shivakumar, I. Amburg, S. G. Aksoy, J. Li, S. J. Young, and S. Aluru. 2023. Fast Parallel Tensor Times Same Vector for Hypergraphs. In *2023 IEEE 30th International Conference on High Performance Computing, Data, and Analytics (HiPC)*. IEEE Computer Society, Los Alamitos, CA, USA, 324–334. doi:10.1109/HiPC58850.2023.00049

[28] E. Solomonik, J. Demmel, and T. Hoefler. 2021. Communication Lower Bounds of Bilinear Algorithms for Symmetric Tensor Contractions. *SIAM Journal on Scientific Computing* 43, 5 (2021), A3328–A3356. doi:10.1137/20M1338599

[29] R. Thakur, R. Rabenseifner, and W. Gropp. 2005. Optimization of Collective Communication Operations in MPICH. *Intl. J. High Perf. Comp. App.* 19, 1 (2005). doi:10.1177/1094342005051521

[30] Richard M Wilson. 1975. An existence theory for pairwise balanced designs, III: Proof of the existence conjectures. *Journal of Combinatorial Theory, Series A* 18, 1 (1975), 71–79. doi:10.1016/0097-3165(75)90067-9

[31] A. N. Ziogas, G. Kwasniewski, T. Ben-Nun, T. Schneider, and T. Hoefler. 2022. Deinsum: practically I/O optimal multi-linear algebra. In *Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis*. doi:10.5555/3571885.3571918
A Another Example of Tetrahedral Block Partition

While our main text focused on Steiner (n, r, s) systems in the infinite family from finite spherical geometries, there are many more Steiner (n, r, 3) systems which can be used to generate tetrahedral block partitions. We will use a smaller system to demonstrate a sequence of steps for the required point-to-point communication. Table 3 shows the assignment of all lower tetrahedron blocks of a symmetric tensor from a Steiner (8, 4, 3) system. This system does not belong to the family of Steiner ($q^\alpha + 1, q + 1, 3$) systems, but exists in the literature.

<table><caption>Table 3. Processor and row block sets of tetrahedral block partition for $m = 8$ and $P = 14$. Processor $p$ has all $TB_3(R_p) \cup N_p \cup D_p$ blocks of the symmetric tensor and performs all required computations with them. Row block $i$ of a vector is evenly distributed among all processors of $Q_i$.</caption><thead><tr><th>p</th><th>R<sub>p</sub></th><th>N<sub>p</sub></th><th>D<sub>p</sub></th><th>i</th><th>Q<sub>i</sub></th></tr></thead><tbody><tr><td>1</td><td>{1,2,3,4}</td><td>{(2,2,1), (3,3,2), (2,1,1), (3,2,2)}</td><td>{(1,1,1)}</td><td>1</td><td>{1,2,3,4,5,6,7}</td></tr><tr><td>2</td><td>{1,2,5,6}</td><td>{(5,5,1), (6,6,1), (5,1,1), (5,2,2)}</td><td>{(2,2,2)}</td><td>2</td><td>{1,2,3,8,9,10,11}</td></tr><tr><td>3</td><td>{1,2,7,8}</td><td>{(7,7,1), (8,8,1), (7,1,1), (7,2,2)}</td><td>{(7,7,7)}</td><td>3</td><td>{1,4,5,8,9,12,13}</td></tr><tr><td>4</td><td>{1,3,5,7}</td><td>{(7,7,3), (7,7,5), (3,1,1), (7,3,3)}</td><td>{(3,3,3)}</td><td>4</td><td>{1,6,7,10,11,12,13}</td></tr><tr><td>5</td><td>{1,3,6,8}</td><td>{(6,6,3), (3,3,1), (6,1,1), (8,1,1)}</td><td>{(6,6,6)}</td><td>5</td><td>{2,4,6,8,10,12,14}</td></tr><tr><td>6</td><td>{1,4,5,8}</td><td>{(8,8,4), (5,5,4), (4,1,1), (5,4,4)}</td><td>{(5,5,5)}</td><td>6</td><td>{2,5,7,9,11,12,14}</td></tr><tr><td>7</td><td>{1,4,6,7}</td><td>{(7,7,4), (4,4,1), (6,4,4), (7,6,6)}</td><td>{(4,4,4)}</td><td>7</td><td>{3,4,7,9,10,13,14}</td></tr><tr><td>8</td><td>{2,3,5,8}</td><td>{(8,8,5), (5,5,3), (5,3,3), (8,2,2)}</td><td>{(8,8,8)}</td><td>8</td><td>{3,5,6,8,11,13,14}</td></tr><tr><td>9</td><td>{2,3,6,7}</td><td>{(6,6,2), (7,7,2), (6,2,2), (6,3,3)}</td><td></td><td></td><td></td></tr><tr><td>10</td><td>{2,4,5,7}</td><td>{(5,5,2), (4,4,2), (4,2,2), (7,4,4)}</td><td></td><td></td><td></td></tr><tr><td>11</td><td>{2,4,6,8}</td><td>{(8,8,2), (8,8,6), (8,4,4), (8,6,6)}</td><td></td><td></td><td></td></tr><tr><td>12</td><td>{3,4,5,6}</td><td>{(6,6,4), (4,4,3), (4,3,3), (6,5,5)}</td><td></td><td></td><td></td></tr><tr><td>13</td><td>{3,4,7,8}</td><td>{(8,8,3), (8,8,7), (8,3,3), (8,7,7)}</td><td></td><td></td><td></td></tr><tr><td>14</td><td>{5,6,7,8}</td><td>{(6,6,5), (7,7,6), (7,5,5), (8,5,5)}</td><td></td><td></td><td></td></tr></tbody></table>

Figure 1 shows a sequence of steps to perform all required communication for the assignment of Table 3 with $m = 8$ and $P = 14$. In each step, every processor directly communicates with another processor. Note that the number of steps is 12, which is less than $P - 1$.
<figure><img src="image_2.png" /><figcaption>Fig. 1. A sequence of 12 communication steps to perform all required data transfers among all 14 processors for the tetrahedral block partition of Table 3. $i \to j$ indicates that processor $i$ sends a message to processor $j$. In each step, a processor sends and receives exactly one message.</figcaption></figure>