As you can see

No, no, we can't see! Why do you continue doing this? You need to show us the relevant code, otherwise we're just constantly guessing about what's going on. What happened between In[174] and Out[175]? Or for that matter, what happened before In[174]? Or more to the point, why do you even make that part of your question? Why don't you provide a simplified version of your question so that we don't have to understand all of your domain-specific details? Where did these Associations come from? Why should I have to parse the complicated structures you're presenting here when your question seems to be about how to represent subscripted variables? What "subsequent assignment operations" are being interfered with? You do realize that x and x1 are completely different and independent symbols, don't you? Just ask a clear question with clear examples in code, please.

Okay Werner. The "syntax problems" were actually the effect of the post editors dysfunctional rendering of code output. But when output formatting is important it can be better to include a notebook directly in the post:

That is "Add Notebook" to the left in the top toolbar. As opposed to the button "Add a file" at the bottom.

What do you mean by saying interesting uses for Indexed?

Look at the last two examples in the documentation for Indexed. So, for example, by asserting that x is an element of the region Rectangle[] one can infer that x is a 2-dimensional vector (aka a 2-element list) and so Indexed[x,1] and Indexed[x,2] can be meaningfully interpreted in the rest of the expression.

Could you please give an example of this trick?

You already started with your example Array[X,{3,3}]. You can use X[1,1] as you would have used Subscript[x,1,1] or Indexed[x,{1,1}]. If you define X[1,1] = ..., then you have DownValues for X instead of for Subscript. And so you can do ClearAll[X] to easily achieve your original task.

I don't understand your code. What is xTM?

If you want to use subscripted variables, instead of Subscript[x,1,2] and the like you should better use Indexed and write:

Clear[x];
{Indexed[x, 1], Indexed[x, {2, 1}]}
(* ==> {x subscripted with 1, x substripted with 12 *)

... assign values:

{x[1], x[1, 2]} = {1, 21};
{x[1], x[1, 2]}
(* ==> {1, 21} *)

... and clear them all:

Clear[x];
{x[1], x[1, 2]}
(* ==> {x[1], x[1, 2]} *)

But, as I suggested, the authors of that package are experts in the area and are most likely to be able to answer the original question that you asked…

Thank you for telling me the MaXrd package and other related information. But my goal is not the same as all of these technologies described and implemented in these packages/literatures.

As an aside, IntegerString can be used for left-padding integers with zeros.

StringPadLeft[ToString[#1], 2, "0"]

can be replaced by

IntegerString[#1, 10, 2]

Yes, of course.

But the question is: How to change the value of an indexed (or better: simulated indexed) variable Symbol["b"<>ToString[i]] for arbitrary i?

I don't think so. The second part of each code block is the Echo-Output, not Input. Unfortunately, the community editor cannot handle Output, or at least I don't know how to do it. Often, I insert screenshots, but this is tedious.

Yes, it is acceptable, Zhao. It is even very fast during creation of the Array as you can see from the following comparison code for large vector lengths n:

n = 1000000
Clear[b, bs];
{t, tmp} = AbsoluteTiming[bs = Array[Indexed[b, #] &, n]];
{t // EngineeringForm, bs[[1]]}
Clear[b, bs];
{t, tmp} = AbsoluteTiming[bs = Array[b, n]];
{t // EngineeringForm, bs[[1]]}
Clear[b, bs];
{t, tmp} = AbsoluteTiming[bs = Array[b[#] &, n]];
{t // EngineeringForm, bs[[1]]}
Clear[bs];
{t, tmp} = AbsoluteTiming[bs = Array[Symbol["b" <> ToString[#]] &, n]];
{t // EngineeringForm, bs[[1]]}
(* ==> *)

The unsuccessful call to b[i] seems to be faster than any successful call. The symbolic method (the last one) is comparable slow, which does not surprise since string functions are involved.

Because it's the same issue. I did not want to write the same thing twice.

Therefore, the final solution is the following approach:

In[121]:= m = Array[m, {9, 12}];
m // Flatten // Length
m // Flatten // DeleteDuplicates // Length

Out[122]= 108

Out[123]= 108

Werner, there is not much practical difference in using the two methods, yours or mine. See the attached edit of your CalcTrans notebook.

Attachments:

CalcTrans HM.nb

Hi Hans,

When I try to use the above tip, I encounter the following very strange problem:

In[174]:= ClearAll[x];
Array[Symbol["x" <> ToString@FromDigits@{##}] &, {3}]

Out[175]= {<|{{-1, -1, -1}, 
    2} -> {{-1, 0, 0}, {0, -1, 0}, {0, 0, -1}}, {{-1, -1, 1}, 
    2} -> {{2, -1, -1}, {3/2, -(3/2), -(1/2)}, {3/
     2, -(1/2), -(3/2)}}, {{-1, -I, I}, 
    4} -> {{3/2, -(1/2), -(3/2)}, {3/
     2, -(3/2), -(1/2)}, {2, -1, -1}}, {{-1, 1, 1}, 
    2} -> {{2, -1, -1}, {3/2, -(1/2), -(3/2)}, {3/
     2, -(3/2), -(1/2)}}, {{-1, (-1)^(1/3), -(-1)^(2/3)}, 
    6} -> {{1, 1, -2}, {3/2, 1/2, -(3/2)}, {1/2, 3/2, -(3/2)}}, {{-I, 
     I, 1}, 4} -> {{3/2, 1/2, -(3/2)}, {1, 1, -2}, {1/2, 3/
     2, -(3/2)}}, {{1, 1, 1}, 
    1} -> {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{1, -(-1)^(1/3), (-1)^(
     2/3)}, 3} -> {{3/2, -(1/2), -(3/2)}, {2, -1, -1}, {3/
     2, -(3/2), -(1/2)}}|>, <|{{-1, -1, -1}, 
    2} -> {{-1, 0, 0}, {0, -1, 0}, {0, 0, -1}}, {{-1, -1, 1}, 
    2} -> {{1, 0, 0}, {0, -1, 0}, {0, 0, -1}}, {{-1, -I, I}, 
    4} -> {{0, 1, 0}, {-1, 0, 0}, {0, 0, -1}}, {{-1, 1, 1}, 
    2} -> {{1, 0, 0}, {0, 1, 0}, {0, 0, -1}}, {{-1, (-1)^(
     1/3), -(-1)^(2/3)}, 
    6} -> {{0, 1, 0}, {0, 0, 1}, {-1, 0, 0}}, {{-I, I, 1}, 
    4} -> {{1, 0, 0}, {0, 0, 1}, {0, -1, 0}}, {{1, 1, 1}, 
    1} -> {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{1, -(-1)^(1/3), (-1)^(
     2/3)}, 3} -> {{0, 1, 0}, {0, 0, 1}, {1, 0, 0}}|>, x3}

As you can see, I've cleared the variable x, however, it still interferes with subsequent assignment operations.

I am not familiar with space groups and unfortunately cannot help. The question goes far beyond your original question about Subscript.

9-26-2022 Hi Dr. Zhang, Very interesting problems. Among the 230 3-D space groups, how many differences ar there between any pair of space groups? Could that formulation be applied to Mathematica, to assist the problems that you raise?