This
RandomComplex[{0, 0}, {2, 2}, WorkingPrecision->64]
is just {{0,0},{0,0}} because you are looking for a matrix with each value between 0 and 0 and thus can be discarded.
This
Clear[a, b, c, d];
X = {{a, b}, {c, d}};
h1 = RandomComplex[{2 + I, 10 + 20 I}, {2, 2}, WorkingPrecision->64];(*MIMO channel*)
h2 = RandomComplex[{2 + I, 10 + 20 I}, {2, 2}, WorkingPrecision->64];
myu = RandomReal[1, 2, WorkingPrecision->64];(*probabilities of the realization of the MIMO channels*)
Lambda = 3/10;(*0.3 has only 16 digits of precision,use rationals or more precise decimal constants*)
FX1 = myu[[1]]*ConjugateTranspose[h1].Inverse[X.h1.ConjugateTranspose[h1]/(2/10)+IdentityMatrix[2]].h1;
FX2 = myu[[2]]*ConjugateTranspose[h2].Inverse[X.h2.ConjugateTranspose[h2]/(2/10)+IdentityMatrix[2]].h2;
FXlambda = FX1 + FX2
gives you a very very large random complex matrix over a,b,c,d. I could show you the particular random matrix I generated from this particular evaluation, which would take many screens here, but you can just as easily generate your own random complex matrix.
This
min = FindMinimum[Simplify[Norm[Diagonal[FXlambda]]], {{a,1/100}, {b,12/100}, {c,4/100}, {d,14/100}},
WorkingPrecision->64, AccuracyGoal->64, MaxIterations->10^4]
returns at this particular moment with these particular random values
{1.409337889826012221043454568743455506805196535480069698590240944*10^-91,
{a -> -3.616219280166386544963592969780528069042039293961884040397257279*10^90,
b -> -1.047395840122292892172381403380611274109197612363848011420483615*10^91,
c -> -4.265655941117427663894689038211955208567032698493186994406768870*10^90,
d -> -1.933152221127828747959356370666759451780057753648769872401242173*10^91}}
with occasional complaints about convergence and accuracy which you can work on overcoming.
This
X /. min[[2]]
returns this
{{-3.616219280166386544963592969780528069042039293961884040397257279*10^90,
-1.047395840122292892172381403380611274109197612363848011420483615*10^91},
{-4.265655941117427663894689038211955208567032698493186994406768870*10^90,
-1.933152221127828747959356370666759451780057753648769872401242173*10^91}}
which is your desired matrix X with Real elements on the diagonal.
This
FXlambda /. min[[2]]
returns
{{-1.228521870908407132391231192817176855185507203455432182381434*10^-91 +
1.97262984247407592288931878416167615378333567798851071480550*10^-92 I,
4.44888691826143307082987838124192490988725917094492380233716*10^-92 +
2.33797978252268798471808096323191424766051989096546366847254*10^-92 I},
{9.47225280258610185565133151101475581141622957605503796821495*10^-92 -
3.01547536822613285530732469452419099256699443356422071748916*10^-92 I,
-6.31776804330895050336828430370877474291208836448824238836773*10^-92
- 1.97262984247407592288931878416167615378333567798851071480550*10^-92 I}}
which demonstrates that the solution X gives a result FXlambda=={{0,0},{0,0}}, at least within the tiny numerical error associated with your 64 digit random complex original matricies.
Or if you don't want to see the fine details of the solution then
Chop[FXlambda /. min[[2]]] == RandomComplex[{0, 0}, {2, 2}, WorkingPrecision -> 64]
will return
True
I believe this is one solution to your problem. Changing the initial values for a,b,c,d in the FindMinimum may or may not find different solutions.
If you want c==b then
Clear[a, b, d];
X = {{a, b}, {b, d}};
h1 = RandomComplex[{2 + I, 10 + 20 I}, {2, 2}, WorkingPrecision -> 64];(*MIMO channel*)
h2 = RandomComplex[{2 + I, 10 + 20 I}, {2, 2}, WorkingPrecision -> 64];
myu = RandomReal[1, 2, WorkingPrecision->64];(*probabilities of the realization of the MIMO channels*)
Lambda = 3/10;(*0.3 has only 16 digits of precision,use rationals or more precise decimal constants*)
FX1 = myu[[1]]*ConjugateTranspose[h1].Inverse[X.h1.ConjugateTranspose[h1]/(2/10)+IdentityMatrix[2]].h1;
FX2 = myu[[2]]*ConjugateTranspose[h2].Inverse[X.h2.ConjugateTranspose[h2]/(2/10)+IdentityMatrix[2]].h2;
FXlambda = FX1 + FX2;
min = FindMinimum[Simplify[Norm[Diagonal[FXlambda]]], {{a, 1/100}, {b, 12/100}, {d, 14/100}},
WorkingPrecision -> 64, AccuracyGoal -> 64, MaxIterations -> 10^4]
X /. min[[2]]
returns
{{1.042857763942349304591968267547967620603583294015470931877677227*10^164,
5.143214731304323107915050538300431747411562194323159341662060110*10^164},
{5.143214731304323107915050538300431747411562194323159341662060110*10^164,
1.470119158978919648478190964930733450490851469062127614340916143*10^164}}
and
Chop[FXlambda /. min[[2]]] == RandomComplex[{0, 0}, {2, 2}, WorkingPrecision -> 64]
returns
True
If I make the following changes
Clear[a, b, d];
X = {{a, b}, {b, d}};
Nt = 2;(*Number of transmit antennas*)
Nr = 2;(*Number of receive antennas*)
N0 = 2/10;(*Noise energy*)(*MIMO channel*)
h1 = RandomComplex[{45 + I, 10 + 20 I}, {Nr, Nt}, WorkingPrecision -> 128];
h2 = RandomComplex[{105 + I, 100 + 20 I}, {Nr, Nt}, WorkingPrecision -> 128];
h3 = RandomComplex[{20/10 + 1/100 I, 1 + 2 I}, {Nr, Nt}, WorkingPrecision -> 128];
(*Singular values*)
SV1 = SingularValueList[h1, Min[Nr, Nt]];
SV2 = SingularValueList[h2, Min[Nr, Nt]];
SV3 = SingularValueList[h3, Min[Nr, Nt]];
(*Condition numbers*)
ConNum1 = 10*Log[10, Max[SV1]/Min[SV1]];
ConNum2 = 10*Log[10, Max[SV2]/Min[SV2]];
ConNum3 = 10*Log[10, Max[SV3]/Min[SV3]];
(*probabilities of the realization of the MIMO channels*)
myu = RandomReal[1, 3, WorkingPrecision -> 128];
(*Lagrange multiplier*)
Lambda = 3/10;
(*(FXlambda-lambda*I) is the Lagrangian,where I is the identity matrix of dimension Nt*)
FX1 = myu[[1]]*ConjugateTranspose[h1].Inverse[X.h1.ConjugateTranspose[h1]/N0+IdentityMatrix[Nr]].h1;
FX2 = myu[[2]]*ConjugateTranspose[h2].Inverse[X.h2.ConjugateTranspose[h2]/N0+IdentityMatrix[Nr]].h2;
FX3 = myu[[3]]*ConjugateTranspose[h3].Inverse[X.h3.ConjugateTranspose[h3]/N0+IdentityMatrix[Nr]].h3;
FXlambda = FX1 + FX2 + FX3 - Lambda*IdentityMatrix[Nt];
(*Inititial condition is X/Nt*)
min = FindMinimum[Simplify[Norm[Diagonal[FXlambda]]], {{a, 1/Nt}, {b, 0}, {d, 1/Nt}},
WorkingPrecision -> 128, AccuracyGoal -> 64, MaxIterations -> 10^4]
then I get additional accuracy, but still warnings that you should explore. And you should inspect
FXlambda /. min[[2]]
carefully after you have modified your problem in this way because it appears that the result is no longer approximately zero.
You might think carefully, exactly what it is that you really want to find the minimum of in your FXlambda. Is it the Norm of the Diagonal? Is it the Total of the Norm of every element in FXlambda?