Hi,

Sorry for the ambiguity.

I followed your suggested method and rewrote the code as follows:

With[{b = {{b1}, {b2}}, a = {{a1}, {a2}}, 
  S1 = {{s11, s12}, {s12, s22}}},
 rule1 = Conjugate[x_ + y_] :> Conjugate[x] + Conjugate[y]; 
 rule2 = Conjugate[x_ y_] :> Conjugate[x] Conjugate[y]; 
 myRules = {rule1, rule2}; 
 ConjugateTranspose[S1.a]. (S1.a) == ConjugateTranspose[a].a //. 
    myRules // Expand // TraditionalForm]

So I got the following result:

({
   {a1 s11 Conjugate[a1] Conjugate[s11] + 
     a2 s12 Conjugate[a1] Conjugate[s11] + 
     a1 s12 Conjugate[a1] Conjugate[s12] + 
     a2 s22 Conjugate[a1] Conjugate[s12] + 
     a1 s11 Conjugate[a2] Conjugate[s12] + 
     a2 s12 Conjugate[a2] Conjugate[s12] + 
     a1 s12 Conjugate[a2] Conjugate[s22] + 
     a2 s22 Conjugate[a2] Conjugate[s22]}
  }) == ({
   {a1 Conjugate[a1] + a2 Conjugate[a2]}
  })

So my question is what is the sequence of commands that results in substituting EACH and EVERY multiplication of a complex variable with its conjugate with its square absolute value (for example: a2 s12 Conjugate[a2] Conjugate[s12] should be substituted with Abs[a2]^2 Abs[s12]^2). This can usually be done by using the command FullSimplify. However, this command seems to be selective in this case and it is not substituting all the terms.

Thanks

As far as I know, ComplexExpand assumes that all variables in its argument are real and then expands it accordingly. However, in the case I am asking about, variables may be complex. So what I want is, that Mathematica substitutes (a1 s12 + a2 s22)* with a1* s12* + a2* s22*. This equation is necessary for the S-matrix. With reference to your website, I think that you're quite familiar with it,

Thanks

Exactly. This is the answer I wanted. However this bring me to my second question. When I apply the rules you suggested in the following code:

With[{b = {{b1}, {b2}}, a = {{a1}, {a2}}, 
  S1 = {{s11, s12}, {s12, s22}}},
 Rule1 = Conjugate[x_ + y_] :> Conjugate[x] + Conjugate[y]; 
 Rule2 = Conjugate[x_ y_] :> Conjugate[x] Conjugate[y]; 
 MyRules = {Rule1, Rule2}; 
 ConjugateTranspose[S1.a]. (S1.a) == ConjugateTranspose[a].a //. 
     MyRules // Expand // PowerExpand // TraditionalForm]

I get the following result:

({
   {a1 s11 Conjugate[a1] Conjugate[s11] + 
     a2 s12 Conjugate[a1] Conjugate[s11] + 
     a1 s12 Conjugate[a1] Conjugate[s12] + 
     a2 s22 Conjugate[a1] Conjugate[s12] + 
     a1 s11 Conjugate[a2] Conjugate[s12] + 
     a2 s12 Conjugate[a2] Conjugate[s12] + 
     a1 s12 Conjugate[a2] Conjugate[s22] + 
     a2 s22 Conjugate[a2] Conjugate[s22]}
  }) == ({
   {a1 Conjugate[a1] + a2 Conjugate[a2]}
  })

When I add the //FullSimpify to the original code, terms like (a1 s11 Conjugate[a1] Conjugate[s11]) are not converted automatically to (Abs[a1]^2+ Abs[s11]^2). So my question is, do I have to add another rule to make Mathematica take care of the mentioned conversion?

Thanks

Thanks for your reply.. Any idea, why this final answer didn't appear until this third rule was applied? It seemed logical, that this answer would result automatically without additional rules. The application of FullSimplify should have helped. right? Regards.