Ejemplo n.º 1
0
        public void InverseCPhaseShift(int dist, int target, params int[] controls)
        {
            Validate(target, "InverseCPhaseShift", "target");
            for (int i = 0; i < controls.Length; i++)
            {
                Validate(controls[i], "InverseCPhaseShift", "controls[" + i + "]");
            }

            RegisterRefModel targetRef;

            RegisterRefModel[] controlsRefs;
            if (_model == null)
            {
                targetRef    = _compModel.GetRefFromOffset(target);
                controlsRefs = controls
                               .Select <int, RegisterRefModel>(x => _compModel.GetRefFromOffset(x))
                               .ToArray <RegisterRefModel>();
            }
            else
            {
                targetRef = new RegisterRefModel()
                {
                    Register = _model, Offset = _offsetToModel + target
                };
                controlsRefs = controls
                               .Select <int, RegisterRefModel>(x => new RegisterRefModel()
                {
                    Register = _model, Offset = _offsetToModel + x
                })
                               .ToArray <RegisterRefModel>();
            }
            InvCPhaseShiftGate gate = new InvCPhaseShiftGate(dist, targetRef, controlsRefs);

            AddGate(gate);
        }
Ejemplo n.º 2
0
        private string GenerateGateCode(ComputerModel model, Gate gate, int column, string indent, string defaultRegName = null)
        {
            Func <string, Gate, string> appendControlTarget = (string begin, Gate g) =>
            {
                if (g.Control.HasValue)
                {
                    string namedC = "control: ";
                    string namedT = "target: ";
                    if (g.Name != GateName.CNot)
                    {
                        namedC = "";
                        namedT = "";
                    }

                    if (g.Control.Value.Register == g.Target.Register)
                    {
                        return(String.Format("{0}.{1}{4}{2}, {5}{3});",
                                             GetRegName(g.Target.Register, defaultRegName),
                                             begin,
                                             g.Target.Offset,
                                             g.Control.Value.Offset,
                                             namedT,
                                             namedC));
                    }
                    else
                    {
                        return(String.Format("comp.{0}{5}{1}[{2}], {6}{3}[{4}]);",
                                             begin,
                                             GetRegName(g.Target.Register, defaultRegName),
                                             g.Target.Offset,
                                             GetRegName(g.Control.Value.Register, defaultRegName),
                                             g.Control.Value.Offset,
                                             namedT,
                                             namedC));
                    }
                }
                else
                {
                    return(String.Format("{0}.{1}{2});", GetRegName(g.Target.Register, defaultRegName), begin, g.Target.Offset));
                }
            };

            Func <string, string, Gate, RegisterRefModel[], string> appendMoreControls =
                (string begin, string beginComment, Gate g, RegisterRefModel[] controls) =>
            {
                if (controls.All <RegisterRefModel>(x => x.Register == g.Target.Register) &&
                    (g.Control == null || g.Control.Value.Register == g.Target.Register))
                {
                    StringBuilder format = new StringBuilder(GetRegName(g.Target.Register, defaultRegName)).Append(".").Append(begin);
                    format.Append(g.Target.Offset);

                    if (g.Control.HasValue)
                    {
                        format.Append(", ").Append(g.Control.Value.Offset);
                    }

                    for (int i = 0; i < controls.Length; i++)
                    {
                        format.Append(", ").Append(controls[i].Offset);
                    }
                    format.Append(");");
                    format.Append("\t\t// ").Append(beginComment).Append("<target_bit>, ... <control_bits> ...)");
                    return(format.ToString());
                }
                else
                {
                    StringBuilder format = new StringBuilder("comp.").Append(begin);
                    format.Append(GetRegName(g.Target.Register, defaultRegName))
                    .Append("[").Append(g.Target.Offset).Append("]");

                    if (g.Control.HasValue)
                    {
                        format.Append(", ")
                        .Append(GetRegName(g.Control.Value.Register, defaultRegName)).Append("[")
                        .Append(g.Control.Value.Offset).Append("]");
                    }

                    for (int i = 0; i < controls.Length; i++)
                    {
                        format.Append(", ")
                        .Append(GetRegName(controls[i].Register, defaultRegName)).Append("[")
                        .Append(controls[i].Offset).Append("]");
                    }
                    format.Append(");");
                    format.Append("\t\t// ").Append(beginComment).Append("<target_bit>, ... <control_bits> ...)");
                    return(format.ToString());
                }
            };

            switch (gate.Name)
            {
            case GateName.Hadamard:
                return(appendControlTarget("Hadamard(", gate));

            case GateName.SigmaX:
                return(appendControlTarget("SigmaX(", gate));

            case GateName.SigmaY:
                return(appendControlTarget("SigmaY(", gate));

            case GateName.SigmaZ:
                return(appendControlTarget("SigmaZ(", gate));

            case GateName.SqrtX:
                return(appendControlTarget("SqrtX(", gate));

            case GateName.RotateX:
                RotateXGate rx = gate as RotateXGate;
                return(appendControlTarget(String.Format("RotateX({0}, ", rx.Gamma), gate));

            case GateName.RotateY:
                RotateYGate ry = gate as RotateYGate;
                return(appendControlTarget(String.Format("RotateY({0}, ", ry.Gamma), gate));

            case GateName.RotateZ:
                RotateZGate rz = gate as RotateZGate;
                return(appendControlTarget(String.Format("RotateZ({0}, ", rz.Gamma), gate));

            case GateName.PhaseKick:
                PhaseKickGate pk = gate as PhaseKickGate;
                if (pk.Controls.Length > 0)
                {
                    return(appendMoreControls(
                               String.Format("PhaseKick({0}, ", pk.Gamma),
                               "PhaseKick(<gamma_value>, ",
                               gate,
                               pk.Controls));
                }
                else
                {
                    return(appendControlTarget(String.Format("PhaseKick({0}, ", pk.Gamma), gate));
                }

            case GateName.PhaseScale:
                PhaseScaleGate ps = gate as PhaseScaleGate;
                return(appendControlTarget(String.Format("PhaseScale({0}, ", ps.Gamma), gate));

            case GateName.CNot:
                return(appendControlTarget("CNot(", gate));

            case GateName.CPhaseShift:
                CPhaseShiftGate cps = gate as CPhaseShiftGate;
                if (cps.Controls.Length > 0)
                {
                    return(appendMoreControls(
                               String.Format("CPhaseShift({0}, ", cps.Dist),
                               "CPhaseShift(<phase_distance_value>, ",
                               gate,
                               cps.Controls));
                }
                else
                {
                    return(appendControlTarget(String.Format("CPhaseShift({0}, ", cps.Dist), gate));
                }

            case GateName.InvCPhaseShift:
                InvCPhaseShiftGate icps = gate as InvCPhaseShiftGate;
                if (icps.Controls.Length > 0)
                {
                    return(appendMoreControls(
                               String.Format("InverseCPhaseShift({0}, ", icps.Dist),
                               "InverseCPhaseShift(<phase_distance_value>, ",
                               gate,
                               icps.Controls));
                }
                else
                {
                    return(appendControlTarget(String.Format("InverseCPhaseShift({0}, ", icps.Dist), gate));
                }

            case GateName.Toffoli:
                ToffoliGate t = gate as ToffoliGate;
                return(appendMoreControls(
                           "Toffoli(",
                           "Toffoli(",
                           gate,
                           t.Controls));

            case GateName.Measure:
                MeasureGate m = gate as MeasureGate;
                if (m.Begin == m.End)
                {
                    return(String.Format("{0}.Measure({1});", GetRegName(m.Target.Register, defaultRegName), m.Target.Offset));
                }
                else if (m.BeginRow.Register == m.EndRow.Register)
                {
                    string regName = GetRegName(m.BeginRow.Register, defaultRegName);
                    if (m.BeginRow.Register != null)
                    {
                        if (m.End - m.Begin + 1 == m.BeginRow.Register.Qubits.Count)
                        {
                            return(String.Format("{0}.Measure();", regName));
                        }
                        else
                        {
                            StringBuilder builder = new StringBuilder();
                            for (int i = m.BeginRow.Offset; i <= m.EndRow.Offset; i++)
                            {
                                builder.AppendFormat("{0}.Measure({1});\n", regName, i);
                            }
                            return(builder.ToString());
                        }
                    }
                    else
                    {
                        if (m.End - m.Begin + 1 == model.TotalWidth)
                        {
                            return(String.Format("{0}.Measure();", regName));
                        }
                        else
                        {
                            StringBuilder builder = new StringBuilder();
                            for (int i = m.BeginRow.Offset; i <= m.EndRow.Offset; i++)
                            {
                                builder.AppendFormat("{0}.Measure({1});\n", regName, i);
                            }
                            return(builder.ToString());
                        }
                    }
                }
                else
                {
                    StringBuilder builder = new StringBuilder();
                    int           i       = m.Begin;
                    while (i <= m.End)
                    {
                        RegisterRefModel regRef = model.GetRefFromOffset(i);
                        if (i + regRef.Register.Qubits.Count < m.End + 2)
                        {
                            builder.AppendFormat("{0}.Measure();\n", regRef.Register.Name);
                            i += regRef.Register.Qubits.Count;
                        }
                        else
                        {
                            builder.AppendFormat("{0}.Measure({1});\n", regRef.Register.Name, regRef.Offset);
                            i++;
                        }
                    }
                    return(builder.ToString());
                }

            case GateName.Unitary:
                UnitaryGate u           = gate as UnitaryGate;
                string      uMatrixName = "unitary_" + column + "_" + u.Target.OffsetToRoot;
                string      matrixDef   = GenerateMatrixDefinition(uMatrixName, u.Matrix, indent);
                string      gateDef     = appendControlTarget(String.Format("Gate1({0}, ", uMatrixName), gate);
                return(String.Format("{0}\n{1}{2}", matrixDef, indent, gateDef));

            case GateName.Parametric:
                return(GenerateParametricGateCode(gate as ParametricGate, defaultRegName));

            case GateName.Composite:
                return(GenerateCompositeGateCode(gate as CompositeGate, defaultRegName));

            case GateName.Empty:
            default:
                return(String.Empty);
            }
        }
Ejemplo n.º 3
0
        public bool RunStep(IList <Gate> gates, bool runBackward = false, bool runComposite = false)
        {
            Quantum.Register root = _comp.GetSourceRoot();

            bool somethingChanged = false;
            int  i    = 0;
            int  maxI = (runComposite ? 1 : gates.Count);

            while (i < maxI)
            {
                Gate gate    = gates[i];
                int? control = null;
                if (gate.Control.HasValue)
                {
                    control = gate.Control.Value.OffsetToRoot;
                }
                switch (gate.Name)
                {
                case GateName.Hadamard:     // the same as inversion
                    root.Hadamard(gate.Target.OffsetToRoot, control);
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.SigmaX:     // the same as inversion
                    root.SigmaX(gate.Target.OffsetToRoot);
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.SigmaY:     // the same as inversion
                    root.SigmaY(gate.Target.OffsetToRoot, control);
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.SigmaZ:     // the same as inversion
                    root.SigmaZ(gate.Target.OffsetToRoot, control);
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.SqrtX:
                    if (runBackward)
                    {
                        Complex[,] m = new Complex[2, 2];
                        Complex a = new Complex(0.5, -0.5);
                        Complex b = new Complex(0.5, 0.5);
                        m[0, 0] = b;
                        m[0, 1] = a;
                        m[1, 0] = a;
                        m[1, 1] = b;
                        root.Gate1(m, gate.Target.OffsetToRoot, control);
                    }
                    else
                    {
                        root.SqrtX(gate.Target.OffsetToRoot, control);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.RotateX:
                    RotateXGate rx = gate as RotateXGate;
                    if (runBackward)
                    {
                        root.RotateX(-rx.Gamma, rx.Target.OffsetToRoot, control);
                    }
                    else
                    {
                        root.RotateX(rx.Gamma, rx.Target.OffsetToRoot, control);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.RotateY:
                    RotateYGate ry = gate as RotateYGate;
                    if (runBackward)
                    {
                        root.RotateY(-ry.Gamma, ry.Target.OffsetToRoot, control);
                    }
                    else
                    {
                        root.RotateY(ry.Gamma, ry.Target.OffsetToRoot, control);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.RotateZ:
                    RotateZGate rz = gate as RotateZGate;
                    if (runBackward)
                    {
                        root.RotateZ(-rz.Gamma, rz.Target.OffsetToRoot, control);
                    }
                    else
                    {
                        root.RotateZ(rz.Gamma, rz.Target.OffsetToRoot, control);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.PhaseKick:
                    PhaseKickGate pk = gate as PhaseKickGate;
                    if (pk.Controls.Length > 0)
                    {
                        int[] controls1 = pk.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
                        if (runBackward)
                        {
                            root.PhaseKick(-pk.Gamma, pk.Target.OffsetToRoot, controls1);
                        }
                        else
                        {
                            root.PhaseKick(pk.Gamma, pk.Target.OffsetToRoot, controls1);
                        }
                    }
                    else
                    {
                        if (runBackward)
                        {
                            root.PhaseKick(-pk.Gamma, pk.Target.OffsetToRoot);
                        }
                        else
                        {
                            root.PhaseKick(pk.Gamma, pk.Target.OffsetToRoot);
                        }
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.PhaseScale:
                    PhaseScaleGate ps = gate as PhaseScaleGate;
                    if (runBackward)
                    {
                        root.PhaseScale(-ps.Gamma, ps.Target.OffsetToRoot, control);
                    }
                    else
                    {
                        root.PhaseScale(ps.Gamma, ps.Target.OffsetToRoot, control);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.CPhaseShift:
                    CPhaseShiftGate cps = gate as CPhaseShiftGate;
                    if (cps.Controls.Length > 0)
                    {
                        int[] controls1 = cps.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
                        if (runBackward)
                        {
                            root.InverseCPhaseShift(cps.Dist, cps.Target.OffsetToRoot, controls1);
                        }
                        else
                        {
                            root.CPhaseShift(cps.Dist, cps.Target.OffsetToRoot, controls1);
                        }
                    }
                    else
                    {
                        if (runBackward)
                        {
                            root.InverseCPhaseShift(cps.Dist, cps.Target.OffsetToRoot);
                        }
                        else
                        {
                            root.CPhaseShift(cps.Dist, cps.Target.OffsetToRoot);
                        }
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.InvCPhaseShift:
                    InvCPhaseShiftGate icps = gate as InvCPhaseShiftGate;
                    if (icps.Controls.Length > 0)
                    {
                        int[] controls1 = icps.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
                        if (runBackward)
                        {
                            root.CPhaseShift(icps.Dist, icps.Target.OffsetToRoot, controls1);
                        }
                        else
                        {
                            root.InverseCPhaseShift(icps.Dist, icps.Target.OffsetToRoot, controls1);
                        }
                    }
                    else
                    {
                        if (runBackward)
                        {
                            root.CPhaseShift(icps.Dist, icps.Target.OffsetToRoot);
                        }
                        else
                        {
                            root.InverseCPhaseShift(icps.Dist, icps.Target.OffsetToRoot);
                        }
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.CNot:
                    CNotGate cn = gate as CNotGate;
                    root.CNot(cn.Target.OffsetToRoot, cn.Control.Value.OffsetToRoot);
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.Toffoli:
                    ToffoliGate t        = gate as ToffoliGate;
                    int[]       controls = t.Controls.Select <RegisterRefModel, int>(x => x.OffsetToRoot).ToArray <int>();
                    root.Toffoli(t.Target.OffsetToRoot, controls);
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.Unitary:
                    UnitaryGate u = gate as UnitaryGate;
                    if (runBackward)
                    {
                        Complex[,] m = new Complex[2, 2];
                        m[0, 0]      = Complex.Conjugate(u.Matrix[0, 0]);
                        m[0, 1]      = Complex.Conjugate(u.Matrix[1, 0]);
                        m[1, 0]      = Complex.Conjugate(u.Matrix[0, 1]);
                        m[1, 1]      = Complex.Conjugate(u.Matrix[1, 1]);
                        root.Gate1(m, gate.Target.OffsetToRoot, control);
                    }
                    else
                    {
                        root.Gate1(u.Matrix, u.Target.OffsetToRoot, control);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.Measure:
                    MeasureGate mg = gate as MeasureGate;
                    for (int j = mg.Begin; j <= mg.End; j++)
                    {
                        root.Measure(j);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.Parametric:
                    ParametricGate pg = gate as ParametricGate;
                    _comp.Evaluate(pg, runBackward);
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.Composite:
                    CompositeGate cg     = gate as CompositeGate;
                    List <Gate>   actual = _comp.GetActualGates(cg);
                    if (runBackward)
                    {
                        actual.Reverse();
                    }
                    foreach (Gate g in actual)
                    {
                        // TODO refactor RunStep() into RunGate()
                        List <Gate> toRun = new List <Gate>()
                        {
                            g
                        };
                        RunStep(toRun, runBackward, true);
                    }
                    somethingChanged = true;
                    i = gate.End + 1;
                    break;

                case GateName.Empty:
                default:
                    i++;
                    break;
                }
            }
            return(somethingChanged);
        }