From Anticommutative Algebras to Combinatorial Structures: A Graph-Theoretic Approach

Abstract

This article develops a combinatorial and graph-theoretic framework for the study of finite-dimensional anticommutative algebras. Given a fixed basis, we associate to each algebra a directed graph that may contain filled oriented triangles, encoding the pattern of nonzero products and the constraints imposed by anticommutativity. Focusing on three-dimensional algebras, we provide the complete list of combinatorial structures associated with each algebra in the known classification. Moreover, we develop two algorithmic procedures: the first determines whether a given anticommutative algebra satisfies the Tortkara identity, and the second identifies the additional conditions a given combinatorial structure must satisfy to correspond to a Tortkara algebra. Finally, we carry out a computational study of these algorithms. Our approach establishes a clear link between algebraic identities and discrete combinatorial objects, opening new avenues for the graphical analysis and classification of anticommutative algebras.

1. Introduction

Anticommutative algebras form a fundamental class within nonassociative algebra, characterized by the identity $xy=-yx$. This simple condition imposes strong structural constraints and encompasses several central varieties, including Lie algebras, Malcev algebras, and binary Lie algebras. Their study dates back to the classical works of A. A. Albert [1] and R. D. Schafer [2], whose monographs established the foundations of modern nonassociative algebra theory. Anticommutative identities appear naturally in geometry, differential equations, and mathematical physics, particularly in the algebraic formalization of symmetries and integrability conditions.

More recently, novel anticommutative structures, most notably the Tortkara algebras introduced by Dzhumadil’daev [3], have attracted renewed interest due to their connections with Zinbiel algebras, operad theory, and the classification of low-dimensional nonassociative systems. Dzhumadil’daev showed in [3] that every Zinbiel algebra endowed with the commutator becomes a Tortkara algebra, and that these algebras satisfy a distinctive identity blending symmetry and alternation. Subsequent research has focused on their structural properties, their relationships with Zinbiel and other nonassociative algebras, and their behavior under various classification frameworks. In particular, nilpotent Tortkara algebras of dimension up to six have been classified both geometrically and algebraically by Gorshkova, Kaygorodov, and Khrypchenko in [4,5]. The systematic exploration of these varieties, together with graph-theoretic and computational methods, continues to provide new insights into the broader landscape of anticommutative nonassociative algebras.

Potential applications include mathematical physics, especially in theories that model complex interactions and symmetries, as well as emerging roles in cryptography and algebraic models for nonlinear dynamical systems.

On the other hand, Graph Theory has become an essential tool for addressing problems across many research fields. It can be effectively applied to the study of non-associative algebras in general, and Tortkara algebras in particular. To the best of our knowledge, the specific connection between graph-theoretic constructions and Tortkara algebras has not been systematically investigated in the literature. However, graph theory has already been crucial in studying other non-associative algebras such as Lie, Leibniz, Malcev, Zinbiel, and evolution algebras. For example, in Lie algebras, trees help determine Dynkin diagrams [6], and graphs are used to represent their structures [7]. Leibniz algebras have been classified via associated graphs [8], and similar studies exist for Malcev and Zinbiel algebras [9,10]. Finite connected bipartite graphs have also been used to construct semisimple semi-indecomposable finite-dimensional Leibniz algebras [11]. Among nonassociative algebras, evolution algebras are especially important. Several papers explore their links with graphs [12,13,14,15], using graph-based methods to study key properties. Finally, ref. [16] addresses open problems related to graphicable algebras, highlighting the potential of graph-theoretical approaches in this area.

On the other hand, Graph Theory has become an essential tool for addressing problems across many research fields. It can be effectively applied to the study of non-associative algebras in general, and Tortkara algebras in particular. To the best of our knowledge, the specific connection between graph-theoretic constructions and Tortkara algebras has not been systematically investigated in the literature. However, graph theory has already been crucial in studying other non-associative algebras such as Lie, Leibniz, Malcev, Zinbiel, and evolution algebras.

In this work, we present a method to associate finite-dimensional anticommutative algebras, defined over a fixed basis $\mathcal{B}$, with combinatorial structures in the form of directed graphs, where full triangles may appear. Starting from the classification of 3-dimensional anticommutative algebras, we provide the list of combinatorial structures associated with each of them. Moreover, we develop two algorithmic methods. The first one computes if a given anticommutative algebra is a Tortkara algebra. The second one computes which additional conditions the algebras associated with a given combinatorial structure have to fulfill in order to be a Tortkara algebra. Finally, we carry out a computational study and complexity analysis of the previous algorithms.

Our results offer new insights into the link between anticommutative algebras and combinatorial structures opening a new research line in the theory of Tortkara algebras and their applications.

2. Preliminaries

In this section we introduce some preliminaries concepts that we will use in this paper. We start with some definitions and results on Tortkara algebras.

Definition 1

(Algebra over a field). An algebra $\mathcal{A}$ over a field $\mathbb{K}$ is a vector space with a bilinear product.

Some examples of algebras are the complex numbers, the quaternions, the square matrices, Lie algebras or Tortkara algebras.

Definition 2

(Anticommutative algebra). An algebra $\mathcal{A}$ over a field $\mathbb{K}$ is called anticommutative if its product satisfies

$$xy=-yx,\forall x,y\in \mathcal{A}.$$

(1)

If the field has characteristic different from two, anticommutativity implies the alternating property, that is, $xx=0$ for every $x\in \mathcal{A}$.

Definition 3

(Tortkara algebra). A Tortkara algebra $\mathcal{T}$ over a field $\mathbb{K}$ is an anticommutative algebra which satisfies

$$\left(xy\right)\left(zy\right)=J(x,y,z)y,\mathit{where}J(x,y,z)=\left(xy\right)z+\left(yz\right)x+\left(zx\right)y,\forall x,y,z\in \mathcal{T}.$$

(2)

The latter is called the Tortkara identity.

Proposition 1.

Over a field of characteristic different from two, the Tortkara identity has the following multi-linear form

$$\left(xy\right)\left(zw\right)+\left(xw\right)\left(zy\right)=J(x,y,z)w+J(x,w,z)y,\forall x,y,z,w\in \mathcal{T}.$$

(3)

Proof. 

If the field has characteristic different from two, we obtain (2) from (3) in the case $y=w$. Also, we obtain (3) from (2) by writing y as $y+w$.    □

From now on, we suppose that the field does not have characteristic two. Also, we use the notation

$$T(x,y,z,w)=\left(xy\right)\left(zw\right)+\left(xw\right)\left(zy\right)-J(x,y,z)w-J(x,w,z)y,$$

$$T_L(x,y,z,w)=\left(xy\right)\left(zw\right),$$

$$T_R(x,y,z,w)=J(x,y,z)w.$$

Therefore,

$$T(x,y,z,w)=T_L(x,y,z,w)+T_L(x,w,z,y)-T_R(x,y,z,w)-T_R(x,w,z,y).$$

Since $T(x,y,z,w)$ is lineal, in order to prove that an algebra $\mathcal{T}$ is a Tortkara algebra, we have to verify that $T(x,y,z,w)=0$ for every combination of elements of a basis of $\mathcal{T}$.

The following definitions are about general concepts of algebras. We will write them applied to Tortkara algebras.

Definition 4.

Given a basis ${\left\{e_i\right\}}_{i=1}^n$ of an n-dimensional Tortkara algebra $\mathcal{T}$ over a field $\mathbb{K}$, its structure constants are $c_{ij}^h$, defined by ${\displaystyle e_i{e}_j=\sum _{h=1}^n{c}_{ij}^h{e}_h}$,   for  $1\le i,j\le n$.

Definition 5.

The derived series of a finite-dimensional Tortkara algebra $\mathcal{T}$ is

$${\mathcal{T}}_1=\mathcal{T},{\mathcal{T}}_2=\mathcal{T}\mathcal{T},{\mathcal{T}}_3={\mathcal{T}}_2{\mathcal{T}}_2,\dots ,{\mathcal{T}}_k={\mathcal{T}}_{k-1}{\mathcal{T}}_{k-1},\dots$$

$\mathcal{T}$ is ($m-1$)-step solvable if there exists $m\in \mathbb{N}$ such that ${\mathcal{T}}_m=\left\{0\right\}$ and ${\mathcal{T}}_{m-1}\ne \left\{0\right\}$.

Definition 6.

The central series of a finite-dimensional Tortkara algebra $\mathcal{T}$ is

$${\mathcal{T}}^1=\mathcal{T},{\mathcal{T}}^2=\mathcal{T}\mathcal{T},{\mathcal{T}}^3={\mathcal{T}}^2\mathcal{T},\dots ,{\mathcal{T}}^k={\mathcal{T}}^{k-1}\mathcal{T},\dots$$

$\mathcal{T}$ is ($m-1$)-step nilpotent if there exists $m\in \mathbb{N}$ such that ${\mathcal{T}}^m=\left\{0\right\}$ and ${\mathcal{T}}^{m-1}\ne \left\{0\right\}$.

Corollary 1.

Let $\mathcal{T}$ be a Tortkara algebra. For all $n\in \mathbb{N}$ we have

• ${\mathcal{T}}_{n+1}\subset {\mathcal{T}}_n$.
• ${\mathcal{T}}^{n+1}\subset {\mathcal{T}}^n$.
• ${\mathcal{T}}_n\subset {\mathcal{T}}^n$.

Proof. 

This follows from the definitions of the derived and central series.    □

Example 1.

Let $\mathcal{T}$ be the anticommutative algebra with basis $\mathcal{B}=\{e_1,e_2,e_3\}$ defined by

$$e_1{e}_2=e_1+3e_2-2e_3,e_1{e}_3=5e_2,e_2{e}_3=-7e_2.$$

$\mathcal{T}$ is a Tortkara algebra since

$$T(e_i,e_j,e_k,e_l)=0,\forall e_i,e_j,e_k,e_l\in \mathcal{B}.$$

Next, we calculate the derived series

$$\begin{array}{c}{\mathcal{T}}_2=\mathcal{T}\mathcal{T}=⟨e_1-2e_3,e_2⟩,\\ {\mathcal{T}}_3={\mathcal{T}}_2{\mathcal{T}}_2=⟨e_1-11e_2-2e_3⟩,\\ {\mathcal{T}}_4={\mathcal{T}}_3{\mathcal{T}}_3=\left\{0\right\}.\end{array}$$

Therefore, $\mathcal{T}$ is 3-step solvable. Lastly, we calculate the central series

$${\mathcal{T}}^2={\mathcal{T}}_2=\mathcal{T}\mathcal{T}=⟨e_1-2e_3,e_2⟩.$$

Since ${\mathcal{T}}^3={\mathcal{T}}^2\mathcal{T}$, we have $e_2{e}_1\in {\mathcal{T}}^3$ and $e_2{e}_3\in {\mathcal{T}}^3$. These two vectors are linearly independent, so ${\mathcal{T}}^3$ is at least 2-dimensional. Since ${\mathcal{T}}^3\subset {\mathcal{T}}^2$ and ${\mathcal{T}}^2$ is 2-dimensional, we obtain ${\mathcal{T}}^3={\mathcal{T}}^2$. Therefore, $\mathcal{T}$ is not nilpotent.

Finally, we will show some concepts on Graph Theory.

Definition 7.

A (undirected) graph is an ordered pair $G=(V,E)$ where

• V is a nonempty set of elements called vertices.
• $E\subseteq \left\{\right\{x,y\}:x,y\in V\wedge x\ne y\}$ is a set of unordered pair of vertices. The elements of E are called edges.

Definition 8.

A directed graph or digraph is an ordered pair $G=(V,E)$ where

• V is a nonempty set of elements called vertices.
• $E\subseteq \{(x,y):(x,y)\in V^2\wedge x\ne y\}$ is a set of ordered pair of vertices. The elements of V are called directed edges.

Let $G=(V,E)$ be a graph (undirected or directed). V and E are called vertex set and edge set, respectively.

Definition 9.

A subgraph (resp. subdigraph) $G^{\prime }$ of a graph (resp. digraph) G is a graph (resp. digraph) $G^{\prime }$ such that its vertex set and edge set are subsets of those of G.

Definition 10.

A subgraph (resp. subdigraph) $G^{\prime }$ of a graph (resp. digraph) $G=(V,E)$ is said to be induced by a vertex subset $V^{\prime }\subseteq V$ if its vertex set is $V^{\prime }$ and its edge set consists of all the edges of G between two vertices in $V^{\prime }$.

Definition 11.

Let $G=(V,E)$ be a directed graph. A vertex $v\in V$ is a sink if each edge incident with v is oriented towards v.

Definition 12.

Let $G=(V,E)$ be a directed graph. A vertex $v\in V$ is a source if each edge incident with v is oriented away from v.

Definition 13.

A directed graph is well-oriented if every vertex is either a sink or a source.

3. Associating Combinatorial Structures with Tortkara Algebras

In this section we describe a procedure that associates, to any anticommutative algebra together with a chosen basis, a combinatorial structure encoding its structure constants.

Let $\mathcal{A}$ be a n-dimensional anticommutative algebra with basis $\mathcal{B}={\left\{e_i\right\}}_{i=1}^n$ and whose structure constants correspond to ${\displaystyle e_i{e}_j=\sum _{h=1}^n{c}_{ij}^h{e}_h}$. Then, the pair $(\mathcal{A},\mathcal{B})$ is associated with a combinatorial structure by the following procedure (Figure 1):

Figure 1. Directed edges, full triangle and two triangles sharing an edge.

(a)

For each $e_i\in \mathcal{B}$, we draw a vertex i.

(b)

Given two distinct vertices i and j, and without loss of generality assuming $i<j$, we proceed as follows:

(b1)

If $c_{ij}^j\ne 0$, we draw a directed edge from vertex i to j with weight $c_{ij}^j$.

(b2)

If $c_{ij}^i\ne 0$, we draw a directed edge from vertex j to i with weight $c_{ij}^i$.

(c)

Given three vertices $i<j<k$ such that at least one of the structure constants $(c_{ij}^k,c_{jk}^i,c_{ik}^j)$ is nonzero, we draw the full triangle $ijk$ such that the edges $ij$, $jk$ and $ik$ have weights $c_{ij}^k$, $c_{jk}^i$ and $c_{ik}^j$, respectively. Moreover:

(c1)

We use a discontinuous line (named ghost edge) for edges with weight 0.

(c2)

If two triangles $ijk$ and $ijl$ with $i<j<k<l$ satisfy $c_{ij}^k=c_{ij}^l$, draw only one edge between vertices i and j shared by both triangles.

To illustrate the previous construction, we now present an explicit example. We emphasise that the procedure applies to any anticommutative algebra, but  for concreteness we consider a particular Tortkara algebra.

Example 2.

Let $\mathcal{T}$ be the Tortkara algebra with basis $\mathcal{B}=\{e_1,e_2,e_3\}$ defined by

$$e_1{e}_2=e_1+3e_2-2e_3,e_1{e}_3=5e_2,e_2{e}_3=-7e_2.$$

Its associated combinatorial structure is shown in Figure 2.

Figure 2. Combinatorial structure associated with $\mathcal{T}$.

From now on, when we talk about graphs or combinatorial structures associated with an anticommutative algebra, we refer to the combinatorial structure described previously. If the combinatorial structure has no triangles, then it will be called a directed graph.

We will also use $V\left(G\right)$ to denote the vertices of a combinatorial structure G and $E\left(G\right)$ to denote its edges (directed edges and edges of triangles).

Remark 1.

Let $\mathcal{A}$ be an anticommutative algebra, let $\mathcal{B}={\left\{e_i\right\}}_{i=1}^n$ be a basis of $\mathcal{A}$ and let G be the associated combinatorial structure. By definition of G, for each i, $j\in \{1,\dots ,n\}$ with $i\ne j$, we have that all the structure constants which appears in the products $e_i{e}_j$ and $e_j{e}_i$ (i.e., $c_{ij}^k$, $\forall k\in \{1,\dots ,n\}$) are related to the weights of the edges that are between the vertices i and j. Therefore, the absence of edges between two vertices i and j indicates that all structure constants $c_{ij}^k$ vanish, and hence $e_i{e}_j=0$.

4. Examples of Combinatorial Structures Associated with 3-Dimensional Anticommutative Algebras

In this section we illustrate the correspondence between anticommutative algebras and the combinatorial structures introduced in Section 3. We focus on the case of dimension three, where the complete classification of anticommutative algebras over an algebraically closed field of characteristic different from two was obtained in [17].

Given a basis $\{e_1,e_2,e_3\}$, recall that the associated combinatorial configuration is constructed as follows: an (undirected) edge between i and j is included whenever $e_i·e_j$ is nonzero, and a filled triangle is added whenever a nonzero product involves a nontrivial linear combination of the basis elements. This procedure is exhaustive in dimension three, where at most one triangle can appear.

Table 1 reproduces the seven families of three-dimensional anticommutative algebras. For each of them we determine its associated structure, obtaining the complete list of possible configurations. These examples motivate the algorithmic procedure developed in the next section.

Table 1. Classification of 3-dimensional anticommutative algebras.

Algebra	Multiplication Table
${\mathcal{A}}_1$	$e_2·e_3=e_1$.
${\mathcal{A}}_2$	$e_1·e_3=e_1,e_2·e_3=e_2$.
${\mathcal{A}}_3$	$e_1·e_3=e_1+e_2,e_2·e_3=a{e}_2$.
${\mathcal{A}}_4$	$e_1·e_2=e_3,e_1·e_3=-e_2,e_2·e_3=e_1$.
${\mathcal{A}}_5$	$e_1·e_2=e_3,e_1·e_3=e_1+e_3,e_2·e_3=a{e}_2$.
${\mathcal{A}}_6$	$e_1·e_2=e_1,e_2·e_3=e_2$.
${\mathcal{A}}_7$	$e_1·e_2=e_3,e_1·e_3=e_1,e_2·e_3=e_2$.

Proposition 2.

Let $\mathcal{A}$ be a 3-dimensional anticommutative algebra. Then, $\mathcal{A}$ is associated with one of the combinatorial structures of Figure 3.

Figure 3. Combinatorial structures associated with 3-dimensional anticommutative algebras.

Proof. 

Let $\mathcal{A}$ be one of the algebras listed in Table 1. We determine its associated combinatorial configuration by applying the correspondence described above. Since the algebra is anticommutative and of dimension three, the only possible nonzero products are of the form

$$e_i·e_j={\lambda }_1{e}_1+{\lambda }_2{e}_2+{\lambda }_3{e}_3,i<j.$$

Thus, the underlying combinatorial structure has at most three pair of directed edges and may contain at most one filled triangle (with or without ghost edges).

We now analyse each algebra family.

Case ${\mathcal{A}}_1$. The only nonzero product is $e_2·e_3=e_1$. Hence the combinatorial structure consists of a triangle with only one non-ghost edge, $\{2,3\}$.

Case ${\mathcal{A}}_2$. Here $e_1·e_3=e_1$ and $e_2·e_3=e_2$, which yields two directed edges $(3,1)$ and $(3,2)$. No nontrivial linear combination appears, so there is no triangle.

Case ${\mathcal{A}}_3$. The products satisfy

$$e_1·e_3=e_1+e_2,e_2·e_3=a{e}_2.$$

Thus vertex 3 is connected to vertices $1,2$, and the product $e_1·e_3$ involves the other basis element, $e_2$, so the triangle $1–2–3$ with two ghost edges, $\{1,2\}$ and $\{2,3\}$ is included in the associated combinatorial structure.

Case ${\mathcal{A}}_4$. This algebra satisfies

$$e_1·e_2=e_3,e_1·e_3=-e_2,e_2·e_3=e_1.$$

Each pair of basis elements has a nonzero product, and every product is nontrivial, so the combinatorial structure consists in the filled triangle without ghost edges.

Case ${\mathcal{A}}_5$. The nonzero products give directed edges connected vertex 3 to vertices $1,2$, and the unique nontrivial product is

$$e_1·e_2=e_3.$$

Therefore the underlying combinatorial structure includes the filled triangle with only one non-ghost edge, $\{1,2\}$, besides the directed edges $(1,3)$, $(3,1)$ y $(3,2)$.

Case ${\mathcal{A}}_6$. The products $e_1·e_2=e_1$ and $e_2·e_3=e_2$ give a path 321. No nontrivial linear combination appears, so there is no filled triangle.

Case ${\mathcal{A}}_7$. This algebra has

$$e_1·e_2=e_3,e_1·e_3=e_1,e_2·e_3=e_2.$$

Thus vertex 3 is connected to vertices $1,2$ by directed edges, and the configuration also contains the filled triangle with only one non-ghost edge, $\{1,2\}$.

These are all seven isomorphism classes of three-dimensional anticommutative algebras. Each gives rise to a unique configuration, and all configurations in Figure 3 arise in this manner. Hence the correspondence is exhaustive and the list is complete.    □

5. Algorithms and Program Codes

In this section we describe two complementary procedures. The first one determines whether a given anticommutative algebra is a Tortkara algebra. The second one computes the additional constraints that an anticommutative algebra associated with a fixed combinatorial structure must satisfy in order to fulfill the Tortkara identity. Both algorithms rely on symbolic manipulation of the structure constants and automatic expansion of identities.

Although in this section we particularize our computations to Tortkara algebras in order to explicitly impose the Tortkara identity, the algorithmic framework we describe is completely general. Indeed, the same methodology applies verbatim to any class of anticommutative (or even non-anticommutative) algebras defined by polynomial identities, such as Lie, Leibniz, Malcev, or Zinbiel algebras. Once the multilinear form of the defining identity is written in symbolic form, the procedure of generating the bilinear products, expanding the identity, and solving the resulting system of equations works in exactly the same way. Therefore, our implementation provides a unified computational tool to test whether a given algebra satisfies a prescribed identity, or to determine the additional constraints that the structure constants of algebras associated with a fixed combinatorial pattern must satisfy in order to belong to any of these varieties.

To implement these algorithms, we fix a basis $\mathcal{B}=\{e_1,\dots ,e_n\}$ and denote by $c_{ij}^k$, $1<i,j,k<n$, the structure constants of the algebra. We have implemented our algorithm in Python, using NumPy and SymPy libraries and following these steps:

• Computing the product between two arbitrary basis vectors in $\mathcal{B}$.
• Evaluating the product between two vectors expressed as a linear combination of vectors from $\mathcal{B}$.
• Imposing the multi-linear form of the Tortkara identity and solving the corresponding system of equations.

AnticommutativeAlgebraSymbolic class represents a generic anticommutative algebra. Its constructor receives the dimension of the algebra as a parameter. The structure constants of the algebra are stored in the class property called coeffs, which is a 3-dimensional array. The constant $c_{ij}^k$ is stored in the position $(i-1,j-1,k-1)$. This array is initialized with all its values set to zero. Next, we show the constructor of the class.

•             import numpy as np
•             import sympy as sp
•             from IPython.display import display, Math

•             class AnticommutativeAlgebraSymbolic:
•             def __init__(self, dim: int):
•             self.dimension = dim
•             self.coeffs = np.ndarray((dim, dim, dim), object)
•             self.coeffs[:,:,:] = sp.Rational(0)
•             self.is_in_graph = np.zeros((dim, dim, dim), int)

This class has methods that helps us populate the 3-dimensional structure constants array. The method set_coefficient_value(i, j, k, value) sets $c_{ij}^k$$= \mathtt{v}\mathtt{a}\mathtt{l}\mathtt{u}\mathtt{e}$, while set_coefficient_variable(i, j, k, is_non_zero = True) sets the constant $c_{ij}^k$ as a variable. Also, add_directed_edge_variable(⋯) and add_triangle_variable(⋯) set as variables all the constants related to the corresponding directed edge and triangle, respectively, of the associated combinatorial structure. There is also a method called get_coefficient(i, j, k) that returns the structure constant $c_{ij}^k$. Finally, the method get_variables() returns a list of all the structure constants that are set as variables. We show these methods below.

•             def get_coefficient(self, i, j, k):
•             return self.coeffs[i−1, j−1, k−1]

•             def set_coefficient_value(self, i, j, k, value):
•             if(i == j and value != 0):
•             print(f“The product e_{i} e_{j} must be zero.”)
•             return
•             i0 = i−1
•             j0 = j−1
•             k0 = k−1
•             self.coeffs[i0,j0,k0] = value
•             self.coeffs[j0,i0,k0] = −value
•             self.is_in_graph[i0,j0,k0] = 1
•             self.is_in_graph[j0,i0,k0] = 1

•             def set_coefficient_variable(self, i, j, k,
•             is_non_zero = True):
•             i0 = i−1
•             j0 = j−1
•             k0 = k−1
•             self.is_in_graph[i0,j0,k0] = 1
•             self.is_in_graph[j0,i0,k0] = 1
•             if is_non_zero:
•             self.coeffs[i0,j0,k0] = sp.symbols(f‘c{i}{j}^{k}’)
•             self.coeffs[j0,i0,k0] = −self.coeffs[i0,j0,k0]
•             else:
•             self.coeffs[i0,j0,k0] = sp.Rational(0)
•             self.coeffs[j0,i0,k0] = sp.Rational(0)

•             def add_directed_edge_variable(self, i, j):
•             if(i<j):
•             self.set_coefficient_variable(i, j, j, True)
•             elif(i>j):
•             self.set_coefficient_variable(j, i, j, True)

•             def add_triangle_variable(self, i, j, k,
•             ij_is_non_zero = True, ik_is_non_zero = True,
•             jk_is_non_zero = True):
•             if not ij_is_non_zero and not ik_is_non_zero
•             and not jk_is_non_zero:
•             print(“All the edges of a triangle can not be zero.”)
•             return
•             if(i<j):
•             self.set_coefficient_variable(i, j, k, ij_is_non_zero)
•             elif(i>j):
•             self.set_coefficient_variable(j, i, k, ij_is_non_zero)
•             if(i<k):
•             self.set_coefficient_variable(i, k, j, ik_is_non_zero)
•             elif(i>k):
•             self.set_coefficient_variable(k, i, j, ik_is_non_zero)
•             if(j<k):
•             self.set_coefficient_variable(j, k, i, jk_is_non_zero)
•             elif(j>k):
•             self.set_coefficient_variable(k, j, i, jk_is_non_zero)

•             def get_variables(self):
•             dim = self.dimension
•             return [self.coeffs[i,j,k] for i in range(0, dim−1)
•             for j in range(i+1, dim)
•             for k in range(0, dim)
•             if (self.is_in_graph[i,j,k]
•             and type(self.coeffs[i,j,k]) is sp.Symbol)]

The method bilineal_vector_product(v1, v2) shown below computes the bilinear product $v_1{v}_2$. It returns an n-dimensional array representing the vector $v=v_1{v}_2$, where the i-th element of the array is the i-th coordinate of v. The other three are variations of this one in the case $v_1$ or $v_2$ (or both) are elements of the basis. For example, bilineal_vector_product_int_int(i, j) returns the product $e_i{e}_j$.

•             def bilineal_vector_product_int_int(self, i, j):
•             return self.coeffs[i, j]

•             def bilineal_vector_product_vector_int(self, v1, j):
•             return np.einsum(‘i,ik->k’, v1, self.coeffs[:, j])

•             def bilineal_vector_product_int_vector(self, i, v2):
•             return np.einsum(‘jk,j->k’, self.coeffs[i], v2)

•             def bilineal_vector_product(self, v1, v2):
•             return np.einsum(‘i,ijk,j->k’, v1, self.coeffs, v2)

The method tortkara_identity(i, j, k, l) returns $T(i,j,k,l)$. Similarly to the previous methods, it returns an n-dimensional array representing the vector $T(i,j,k,l)$. It also uses the auxiliary methods tortkara_identity_left_side(i, j, k, l) and tortkara_identity_right_side(i, j, k, l).

•             def tortkara_identity(self, i, j, k, l):
•             left_side = self.tortkara_identity_left_side(i, j, k, l)
•             + self.tortkara_identity_left_side(i, l, k, j)
•             right_side = self.tortkara_identity_right_side(i, j, k, l)
•             + self.tortkara_identity_right_side(i, l, k, j)
•             tortkara_identity = left_side − right_side
•             for i in range(0,self.dimension):
•             tortkara_identity[i] =
•             sp.expand(sp.simplify(tortkara_identity[i]))
•             return~tortkara_identity

•             def tortkara_identity_left_side(self, i, j, k, l):
•             return self.bilineal_vector_product(
•             self.bilineal_vector_product_int_int(i, j),
•             self.bilineal_vector_product_int_int(k, l))

•             def tortkara_identity_right_side(self, i, j, k, l):
•             r1 = self.bilineal_vector_product_vector_int(
•             self.bilineal_vector_product_int_int(i, j), k)
•             r2 = self.bilineal_vector_product_vector_int(
•             self.bilineal_vector_product_int_int(j, k), i)
•             r3 = self.bilineal_vector_product_vector_int(
•             self.bilineal_vector_product_int_int(k, i), j)
•             jacobi_ijk = r1 + r2 + r3
•             return
•             self.bilineal_vector_product_vector_int(jacobi_ijk,l)

If there are no structure constants set as variables, we can use the method is_tortkara_algebra() show below to test if the algebra that we have defined is a Tortkara algebra. If it is not, it prints which Tortkara identities are not zero. The method get_string_vector(v) is an auxiliary method from another class not shown here that prints an array as a sum of elements of the basis.

•             def is_tortkara_algebra(self):
•             dim = self.dimension
•             is_tortkara = True
•             for i in range(0, dim):
•             for j in range(0, dim):
•             for k in range(0, dim):
•             for l in range(0, dim):
•             identity = self.tortkara_identity(i, j, k, l)
•             if not np.any(identity):
•             continue
•             if is_tortkara:
•             is_tortkara = False
•             print(f“e_{i}, e_{j}, e_{k}, e_{l}:
•             {BaseMath.get_string_vector(identity)} != 0”)
•             if is_tortkara:
•             print(“It’s a Tortkara Algebra, yay!”)
•             else:
•             print(“It’s NOT a Tortkara Algebra :”)
•             return is_tortkara

Finally, if there are structure constants set as variables, the method get_equations_tortkara() returns a list of the equations that the algebra must satisfy to be a Tortkara algebra. If some equation is of the form $0=0$, it is not added to the list. Therefore, if the method returns the empty list, it is always a Tortkara algebra. If the list contains at least one equation, we can use the solver in SymPy to calculate the conditions the algebra has to met to be a Tortkara algebra.

•             def get_equations_tortkara(self):
•             dim = self.dimension
•             identities = self.get_identities_tortkara()
•             return [sp.Eq(identity[i],0)
•             for identity in identities for i in range(0, dim)]

•             def get_identities_tortkara(self):
•             dim = self.dimension
•             return [self.tortkara_identity(i, j, k, l)
•             for i in range(0, dim)
•             for j in range(0, dim)
•             for k in range(0, dim)
•             for l in range(0, dim)]

Example 3.

Here we show an example to calculate the conditions an algebra associated with a combinatorial structure has to met to be a Tortkara algebra.

•             t = AnticommutativeAlgebraSymbolic(3)
•             t.add_triangle_variable(1,2,3,1,0,0)
•             t.add_directed_edge_variable(1,2)
•             t.add_directed_edge_variable(2,1)
•             t.add_directed_edge_variable(1,3)
•             t.add_directed_edge_variable(3,1)
•             t.add_directed_edge_variable(2,3)
•             t.add_directed_edge_variable(3,2)

•             variables = t.get_variables()
•             sp.solve(t.get_equations(),variables,dict=False,set=True)

It returns

•             ([c12^1, c12^2, c12^3, c13^1, c13^3, c23^2, c23^3],
•             {(c13^1*(−c12^2*c23^3 + c12^3*c23^2)/(c13^3*c23^2),
•                   c12^2,
•                   c12^3,
•                   c13^1,
•                   c13^3,
•                   c23^2,
•                   c23^3)})

Therefore, the condition that the algebra associated with that combinatorial structure has to met is $c_{12}^1=c_{13}^1{\displaystyle \frac{-c_{12}^2{c}_{23}^3+c_{12}^3{c}_{23}^2}{c_{13}^3{c}_{23}^2}}$.

Example 4.

Here we show another example.

•             t = AnticommutativeAlgebraSymbolic(3)
•             t.add_triangle_variable(1,2,3,1,1,0)
•             t.add_directed_edge_variable(1,2)
•             t.add_directed_edge_variable(2,1)
•             t.add_directed_edge_variable(1,3)
•             t.add_directed_edge_variable(2,3)

•             variables = t.get_variables()
•             sp.solve(t.get_equations(),variables,dict=False,set=True)

It returns

•             ([c12^1, c12^2, c12^3, c13^2, c13^3, c23^3],
•             {(0, c12^2, c12^3, c13^2, c13^3, c23^3),
•                   (c12^1, c12^2, c12^3, 0, c13^3, c23^3),
•                   (c12^1, c12^2, c12^3, c13^2, c13^3, 0)})

Every possible solutions has some structure constant set to zero. Therefore, this combinatorial structure can not be associated with a Tortkara algebra.

6. Computational Study

In this section we present a detailed computational study of the algorithmic procedures introduced in Section 5. The implementation has been carried out in Python 3.10, using NumPy 1.26 and SymPy 1.12, on an Intel(R) Core(TM) i7-4510U CPU at 2.60 GHz with 12 GB of RAM. Both computing time (C.T.) and used memory (U.M.) have been measured for various dimensions n of the algebra.

The computational study considers general anticommutative algebras with symbolic structure constants associated with arbitrary combinatorial structures, including directed edges and triangles. For each dimension n, all multilinear Tortkara identities are generated and solved symbolically using SymPy. Table 2 summarizes the observed computing time and memory usage.

Table 2. Computing time and memory usage for different algebra dimensions.

Dimension n	Computing Time (s)	Used Memory (MB)
3	0.12	4.6
4	0.48	5.1
5	3.2	6.0
6	18.5	7.4
7	105	9.8
8	620	12.5

Figure 4 and Figure 5 show the growth of computing time and memory usage as functions of the algebra dimension n. Both quantities fit a positive exponential trend, while the ratio U.M./C.T. approximately follows a decreasing exponential behavior, as shown in Figure 6.

Figure 4. Computing time (C.T.) with respect to dimension n. The data can be approximated by an exponential model $T\left(n\right)\sim a\exp \left(bn\right)$.

Figure 5. Memory usage (U.M.) with respect to dimension n. The exponential growth is milder than for C.T.

Figure 6. Ratio U.M./C.T. versus dimension n. The decreasing trend follows an approximate negative exponential model.

To quantify the computational trends, we fit exponential models of the form:

$$T\left(n\right)=a{e}^{bn},M\left(n\right)=c{e}^{dn}$$

where $T\left(n\right)$ is computing time, $M\left(n\right)$ is memory usage, and $a,b,c,d$ are fitting parameters. Least-squares regression yields:

$$\begin{array}{cc}\hfill T\left(n\right)& \approx 0.05,e^{0.95n}\hfill \\ \hfill \mathrm{s},\\ \hfill M\left(n\right)& \approx 4.5,e^{0.12n}\hfill \\ \hfill \mathrm{MB}.\end{array}$$

The faster exponential growth of computing time compared to memory explains why symbolic solutions become infeasible for dimensions $n>6$–7. The quotient U.M./C.T. behaves as $Q\left(n\right)=M\left(n\right)/T\left(n\right)\sim 90,e^{-0.83n}$, illustrating the negative exponential trend in Figure 6.

7. Complexity Analysis

The algorithmic complexity can be estimated in terms of the number of operations in the worst case. In Table 3, we show that complexity, where $N_i\left(n\right)$ denote the number of operations for Step i of the procedure:

Table 3. Complexity estimates and number of operations for each algorithmic step.

Step	Routine	Complexity	Number of Operations ${\mathit{N}}_{\mathit{i}}\left(\mathit{n}\right)$
1	Initialize structure constants	$O\left(n^3\right)$	${\displaystyle 3+\sum _{i=1}^{n^3}1}$
2	Compute bilinear products	$O\left(n^3\right)$	${\displaystyle \sum _{i,j=1}^{n}n}$
3	Evaluate Tortkara identities	$O\left(n^5\right)$	${\displaystyle \sum _{i,j,k,l=1}^{n}n}$
4	Solve symbolic equations	$O\left(n^7\right)$	depends on number of variables and equations

The effective number of non-trivial identities is often much smaller due to anticommutativity and the combinatorial pattern, which allows feasible computation for $n\le 5$–6.

From the computational experiments and statistical modeling, we observe:

• Dense combinatorial structures with many triangles produce a large number of symbolic variables and constraints, significantly increasing computing time.
• Sparse or acyclic graphs tend to generate fewer non-trivial identities, making the computation faster and solutions more likely to exist.
• Certain combinatorial configurations are inherently incompatible with Tortkara algebras, regardless of the choice of structure constants.
• Exponential fitting provides a predictive model for resources, helping to plan computations for larger dimensions.

These results support a systematic, algorithmic approach for exploring combinatorial structures likely to correspond to Tortkara algebras.