I tend to use a head other than NonCommutativeMultiply, and to attach down values of interest. This code is adapted from a Mathematica StackOverflow thread (I've used it elsewhere as well).

First define rules to enforce associativity and to distribute our product over Plus. Als we have some, not needed here, to pull out "scalars".

ncTimes[] := 1
ncTimes[a_] := a
ncTimes[a___, ncTimes[b_, c__], d___] := ncTimes[a, b, c, d]
ncTimes[a___, x_ + y_, b___] := ncTimes[a, x, b] + ncTimes[a, y, b]
ncTimes[a___, i_?NumericQ*c_, b___] := i*ncTimes[a, c, b]
ncTimes[a___, i_?NumericQ, b___] := i*ncTimes[a, b]
commutator[x_, y_] := ncTimes[x, y] - ncTimes[y, x]
anticommutator[x_, y_] := ncTimes[x, y] + ncTimes[y, x]

Here is the example.

lhs = commutator[ncTimes[a, b], ncTimes[c, d]]

(* Out[153]= ncTimes[a, b, c, d] - ncTimes[c, d, a, b] *)

rhs = 
 ncTimes[a, anticommutator[c, b], d] - 
  ncTimes[a, c, anticommutator[d, b]] + 
  ncTimes[anticommutator[c, a], d, b] - 
  ncTimes[c, anticommutator[d, a], b]

(* Out[154]= ncTimes[a, b, c, d] - ncTimes[c, d, a, b] *)

So the two canonicalize to the same expression (hence are equivalent).

But, now I found another strange thing: If I load and then unload NCAlgebra package, then my code snippet will not work correctly:

1. First, test without loading NCAlgebra package, my code snippet works smoothly:

   In[1]:= (*
   The following method doesn't rely on NCAlgebra package.
   
   Unable to Simplify non-commutative Expression Further in Mathematica.
   https://community.wolfram.com/groups/-/m/t/3076922*)
   ClearAll["Global`*"]
   Unprotect[NonCommutativeMultiply];
   a_ ** (b_?NumberQ c_) := b*(a ** c)
   (b_?NumberQ c_) ** a_ := b*(c ** a)
   a_ ** (b_ + c_) := a ** b + a ** c
   (b_ + c_) ** a_ := b ** a + c ** a
   comm[x_, y_] := x ** y - y ** x
   anticomm[x_, y_] := x ** y + y ** x
   A ** anticomm[C, B] ** D - A ** C ** anticomm[D, B] + 
     anticomm[C, A] ** D ** B - C ** anticomm[D, A] ** B // Simplify
   % == comm[A ** B, C ** D] // FullSimplify
   
   Out[9]= A ** B ** C ** D - C ** D ** A ** B
   
   Out[10]= True
   

2. Then, I try to load NCAlgebra package, and then unload it by ClearAll as follows:

   << NC`
   << NCAlgebra`
   
   NC::Directory: You are using a paclet version of NCAlgebra.
   
   NCAlgebra::SmallCapSymbolsNonCommutative: All lower cap single letter symbols (e.g. a,b,c,...) were set as noncommutative.
   
   In[15]:= (*
   The following method doesn't rely on NCAlgebra package.
   
   Unable to Simplify non-commutative Expression Further in Mathematica.
   https://community.wolfram.com/groups/-/m/t/3076922*)
   ClearAll["Global`*"]
   Unprotect[NonCommutativeMultiply];
   a_ ** (b_?NumberQ c_) := b*(a ** c)
   (b_?NumberQ c_) ** a_ := b*(c ** a)
   a_ ** (b_ + c_) := a ** b + a ** c
   (b_ + c_) ** a_ := b ** a + c ** a
   comm[x_, y_] := x ** y - y ** x
   anticomm[x_, y_] := x ** y + y ** x
   A ** anticomm[C, B] ** D - A ** C ** anticomm[D, B] + 
     anticomm[C, A] ** D ** B - C ** anticomm[D, A] ** B // Simplify
   % == comm[A ** B, C ** D] // FullSimplify
   
   During evaluation of In[15]:= ClearAll::wrsym: Symbol T is Protected.
   
   Out[23]= 0
   
   Out[24]= True
   

As you can see, now the result is 0. Any tips for fixing this problem will be appreciated.

See here for the related discussion.

Regards, Zhao

Try giving these rules:

Unprotect[NonCommutativeMultiply];
a_ ** (b_?NumberQ c_ ) := b*(a ** c)
(b_?NumberQ c_ ) ** a_ := b*(c ** a)
a_ ** (b_ + c_) := a ** b + a ** c
(b_ + c_) ** a_ := b ** a + c ** a