Introduction

A symmetric tensor keeps the same value when its indices are permuted. For matrices this is familiar as A[i, j] == A[j, i]; for higher-order tensors the same idea applies across every axis.

What symmetry means for a tensor

Suppose you want a 3rd-order tensor T with shape (n, n, n). Full symmetry means entries like T[0, 1, 2], T[2, 1, 0], and T[1, 0, 2] must all be identical. You do not pick a separate random value for each permutation. You pick one value for the index pattern and copy it to every permuted location.

That is the main difference between "random tensor" and "random symmetric tensor." Generating raw random numbers and hoping symmetry appears will not work.

A direct construction for small tensors

One clean approach is to generate values only for index tuples in sorted order, then write the same value into every permutation of that tuple.

1import numpy as np
2from itertools import combinations_with_replacement, permutations
3
4
5def random_symmetric_tensor(dimension, order, rng=None):
6    if rng is None:
7        rng = np.random.default_rng()
8
9    shape = (dimension,) * order
10    tensor = np.zeros(shape, dtype=float)
11
12    for index_tuple in combinations_with_replacement(range(dimension), order):
13        value = rng.normal()
14        for permuted in set(permutations(index_tuple)):
15            tensor[permuted] = value
16
17    return tensor
18
19
20tensor = random_symmetric_tensor(dimension=3, order=3)
21print(tensor.shape)
22print(np.allclose(tensor, np.transpose(tensor, (1, 0, 2))))
23print(np.allclose(tensor, np.transpose(tensor, (2, 1, 0))))

This code guarantees exact symmetry. Each unique multiset of indices gets one random number, and every permutation receives the same assignment.

Why averaging a random tensor is another option

Another idea is to start with a fully random tensor and average it over permutations of the axes. That also produces a symmetric tensor.

For example, with a 3rd-order tensor you could average all six axis permutations. The result is mathematically clean, but it is usually more expensive than direct construction because you allocate and combine several transformed views of the tensor.

For small experiments, either method is fine. For larger tensors, direct construction is easier to reason about and avoids extra full-tensor passes.

Performance considerations

The construction above is practical for small orders and dimensions, but it is not magic. The number of unique index groups grows quickly, and the number of permutations grows with the tensor order. A 6th-order tensor is far more expensive to symmetrize than a matrix.

That means the best implementation depends on the workload. If you only need a symmetric matrix or a low-order tensor for tests, the simple function above is excellent. If you are doing heavy scientific computing, you may need a domain-specific representation that stores only the unique entries instead of the fully expanded tensor.

It also helps to be clear about the distribution you want. The example uses rng.normal(), but you could replace that with rng.uniform(), integers, or any custom sampling rule.

Verifying the result

For a matrix, checking symmetry is easy with tensor.T. For higher-order tensors, verify equality against a few axis permutations using np.transpose. That gives you confidence the construction code really enforces the property you need.

If the tensor must also satisfy extra constraints such as positive definiteness in a matrix slice or sparsity, symmetry alone is not enough. Generate the tensor with those constraints in mind instead of trying to bolt them on afterward.

Common Pitfalls

• Filling every tensor entry independently, which destroys symmetry immediately.
• Confusing matrix symmetry with full higher-order tensor symmetry across all axis permutations.
• Assuming an averaged tensor and a directly constructed tensor have identical performance characteristics.
• Forgetting that the cost grows quickly with tensor order and dimension.
• Verifying symmetry on only one axis swap when the tensor is supposed to be fully symmetric.

Summary

• A symmetric tensor keeps the same value under index permutation.
• The safest construction is to assign one random value per sorted index tuple and copy it to all permutations.
• Axis-averaging also works, but it can be more expensive.
• The simple permutation-based method is best suited to small and medium tensors.
• Always verify symmetry explicitly, especially for higher-order tensors.