Hi Hans,

Thank you for your tip. It works.

But there is a missing & in your code, which should be written as follows:

f[gens_List]:=Block[
  {x,y,z},
  Table[
    (i[[1;;3,1;;3]] . Transpose[{{x,y,z}}]+i[[1;;3,4]])//Transpose,{i,gens}
  ]
  //ArrayFlatten[#,1]&
]

Zhao, I would suggest that you try thinking "in the small" before thinking "in the large". Looking at your code makes me think you spent a lot of time wrestling with the structures on the large scale--a Transpose here, an ArrayFlatten there, and so on. Sometimes it's much simpler and clearer (and more maintainable) to first figure out how to do the small and easy things, and then compose/augment them to handle the larger more complex things. For example, at the small scale what you're trying to do is something like this:

{-1, 0, 0, 1/4} . {x, y, z, 1}

This could be turned into a function that operates on a 4-element list:

Dot[#, {x, y, z, 1}] &

You could also name this function, but I don't know a good name, and all I want to do at this point is demonstrate how to use this "small" function as part of a larger process.

The data you've stored in the variable SGGenSetAK227Left2 is just a bunch of 4-element lists arranged into a larger structure. This suggests that you can just map the "small" function over this larger structure:

Map[Dot[#, {x, y, z, 1}] &, SGGenSetAK227Left2, {-2}]
(* {{1/4 - x, 1/4 - z, 1/4 + x + y + z, 1}, {y, z, -x - y - z, 1}} *)

But it looks like you want to ignore the last "column". Instead of trying to work that into the process, just adjust your data structure first:

Map[Dot[#, {x, y, z, 1}] &, SGGenSetAK227Left2[[All, 1 ;; 3]], {-2}]
(* {{1/4 - x, 1/4 - z, 1/4 + x + y + z}, {y, z, -x - y - z}} *)

And finally, you want the result as a string.

Map[Dot[#, {x, y, z, 1}] &, SGGenSetAK227Left2[[All, 1 ;; 3]], {-2}] // InputForm // ToString

And just a tangential comment... Having seen several of your posts now, your "go to" strategy seems to always be "put everything in a Module". You seem to like to set up a sort of "block" in which to do a bunch of sequential processing steps. This style is often called "imperative". Without debating the pros and cons of that style, I'll just say that Mathematica gives you many very powerful alternatives to that style. To get the most out of Mathematica, I would encourage you eschew Module for awhile, and look for alternative approaches. Maybe you don't really care about what style you're using and just want to get working code, and that's fine, but you will be forever wrestling with the language instead of learning to use it effectively.

Well, then there's been some misunderstanding, because the code I posted reproduces your expected output exactly. In your new examples you've introduced finalaffops but haven't shown how it's defined. Inferring from the output you show, I get this:

test = {{{0, -1, 0, 1/2}, {0, 0, -1, 1/2}, {-1, 0, 0, -(1/2)}, {0, 0, 
    0, 1}}, {{0, 1, 0, -1}, {-1, 0, 0, 1}, {0, 0, -1, -2}, {0, 0, 0, 
    1}}};
Map[Dot[#, {x, y, z, 1}] &, test[[All, 1 ;; 3]], {-2}] ==
 ArrayFlatten[
  Transpose /@ (Map[Dot[#, Transpose[{{x, y, z, 1}}]] &, 
     test[[All, 1 ;; 3]], {-2}]), 1]
(*True*)

So, I don't know what to tell you.

Many hints here:

https://reference.wolfram.com/language/tutorial/ModularityAndTheNamingOfThings.html#22619