private void Reshuffle(StateOperator state, SystemBipartition bipartition)
{
EvaluatedMatrix = new Transformation(CreateMatrix.Dense <Complex>(state.RowDimension, state.ColumnDimension));
int rowOffset = 0, columnOffset = 0;
for (int i = 0; i < state.RowDimension; i++)
{
int reshRowStart = rowOffset * bipartition.DimensionA, reshColumnStart = columnOffset * bipartition.DimensionB;
int reshRowIterator = reshRowStart, reshColumnIterator = reshColumnStart;
int reshColumnLimit = reshColumnStart + bipartition.DimensionB;
for (int j = 0; j < state.RowDimension; j++)
{
EvaluatedMatrix[reshRowIterator, reshColumnIterator] = state[i, j];
reshColumnIterator++;
if (reshColumnIterator == reshColumnLimit)
{
reshColumnIterator = reshColumnStart;
reshRowIterator++;
}
}
columnOffset++;
if (columnOffset == bipartition.DimensionA)
{
columnOffset = 0;
rowOffset++;
}
}
}
private void CalculateSubsystemState(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(DiscardedQubitsBox.Text))
{
return;
}
StateOperator state = StateOperator.FromQuantumState(Layer.GetSystemState());
List <int> discardedQubits = new List <int>();
string qubits = DiscardedQubitsBox.Text.Replace(",", "");
for (int i = 0; i < qubits.Length; i++)
{
discardedQubits.Add(Convert.ToInt32(qubits[i] - 48));
}
SubState = state.PartialTrace(discardedQubits);
SubsystemState.ResizeGrid(SubState.RowDimension, SubState.ColumnDimension);
for (int i = 0; i < SubState.RowDimension; i++)
{
for (int j = 0; j < SubState.ColumnDimension; j++)
{
SubsystemState[i, j] = ComplexParser.ToString(SubState[i, j], 4);
}
}
SubsystemStateGrid.Visibility = Visibility.Visible;
if (SubState.Size == 1)
{
ExamineSubsystemButton.IsEnabled = false;
}
}
/*
* public PPTCriterion(QuantumState state)
* {
* State = state;
* StateOperator = StateOperator.FromQuantumState(state);
* }
*
* public PPTCriterion(StateOperator @operator)
* {
* StateOperator = @operator;
* }
*/
public void Evaluate(StateOperator state, SystemBipartition bipartition)
{
EvaluatedMatrix = state.PartialTranspose(bipartition);
Evd <Complex> evd = EvaluatedMatrix.Matrix.Evd();
Eigenvalues = evd.EigenValues.ToArray();
}
public StateDataScaler(uint id, uint mask, byte op)
{
ID = id;
Mask = mask;
if (Enum.IsDefined(typeof(StateOperator), op))
{
Operator = (StateOperator)op;
}
}
public EntanglementWindow(StateOperator state)
{
//Bipartition = new SystemBipartition(state.Size);
StateOperator = state;
//sizeChosen = definitionChosen = true;
//criterionChosen = partitionChosen = false;
InitializeComponent();
//SetPartitions();
}
public override Transformation GetTransformation(StateOperator state)
{
double random = new Random().NextDouble();
Transformation zeroProjection = new Transformation(GateTransformation.Column(0).OuterProduct(GateTransformation.Column(0)));
double probability = zeroProjection.Multiply(state).Trace().Real;
if (random < probability)
{
return(zeroProjection);
}
else
{
return(new Transformation(GateTransformation.Column(1).OuterProduct(GateTransformation.Column(1))));
}
}
private bool CreateStateFromDefinition()
{
Complex[, ] values = ReadTextMatrix();
if (values == null)
{
return(false);
}
if (DensityMatrix.IsChecked == true)
{
if (!StateOperator.IsStateOperator(values))
{
ErrorMessage.Content = "Defined matrix does not represent state operator";
ErrorMessage.Visibility = Visibility.Visible;
return(false);
}
StateOperator = StateOperator.FromValues(values);
return(true);
}
else if (StateMatrix.IsChecked == true)
{
Complex sum = Complex.Zero;
foreach (Complex value in values)
{
sum += value;
}
if (sum == Complex.Zero)
{
ErrorMessage.Content = "At least one value mus be nonzero";
ErrorMessage.Visibility = Visibility.Visible;
return(false);
}
State = QuantumState.FromValues(values);
return(true);
}
return(false);
}
public abstract void DisplayResults(StateOperator @operator, SystemBipartition bipartition);
public override void DisplayResults(StateOperator @operator, SystemBipartition bipartition)
{
Criterion.Evaluate(@operator, bipartition);
SetVisuals((ComputableCrossNormCriterion)Criterion);
}
public override void DisplayResults(QuantumState state, SystemBipartition bipartition)
{
DisplayResults(StateOperator.FromQuantumState(state), bipartition);
}
//public SchmidtDecomposition(QuantumState state) : base(state) { }
public override void Evaluate(StateOperator state, SystemBipartition bipartition)
{
throw new NotImplementedException();
}
public override void Evaluate(StateOperator state, SystemBipartition bipartition)
{
Reshuffle(state, bipartition);
Decompose(EvaluatedMatrix);
}
//public ComputableCrossNormCriterion(QuantumState state) : base(state) { }
//public ComputableCrossNormCriterion(StateOperator @operator) : base(@operator) { }
public override void Evaluate(QuantumState state, SystemBipartition bipartition)
{
Evaluate(StateOperator.FromQuantumState(state), bipartition);
}
public override void DisplayResults(StateOperator @operator, SystemBipartition bipartition)
{
throw new NotImplementedException();
}
public abstract void Evaluate(StateOperator state, SystemBipartition bipartition);
