Öğretici: Içinde Grover arama algoritmasını uygulama Q#

Makale
13.01.2025

Bu öğreticide, arama tabanlı sorunları çözmek için Grover Q# algoritması uygulayacaksınız. Grover algoritmasının arkasındaki teorinin derinlemesine açıklaması için grover algoritması teorisine bakın.

Bu öğreticide şunları yaptınız:

Bir arama sorunu için Grover algoritmasını tanımlama
uygulamasında Grover algoritmasını uygulama Q#

İpucu

Kuantum bilişim yolculuğunuzu hızlandırmak istiyorsanız Azure Quantum web sitesinin benzersiz bir özelliği olan Azure Quantum ile kod bölümüne bakın. Burada yerleşik Q# örnekleri veya kendi Q# programlarınızı çalıştırabilir, istemlerinizden yeni Q# kod oluşturabilir, kodunuzu tek tıklamayla Web için VS Code'da açıp çalıştırabilir ve Copilot'a kuantum bilişimi hakkında sorular sorabilirsiniz.

Önkoşullar

Kod örneğini Azure Quantum'daki Copilot'ta çalıştırmak için:
- Microsoft (MSA) e-posta hesabı.
Visual Studio Code'da kod örneğini geliştirmek ve çalıştırmak için:
- Visual Studio Code'un en son sürümü veya Vs Code'un Web'de açılması.
- Azure Quantum Development Kit uzantısının en son sürümü. Yükleme ayrıntıları için bkz. QDK uzantısını ayarlama.

Sorunu tanımlama

Grover algoritması, kuantum bilişimindeki en ünlü algoritmalardan biridir. Çözdüğü sorunun türü genellikle "veritabanında arama" olarak adlandırılır, ancak bunu arama sorunu açısından düşünmek daha doğru olur.

Herhangi bir arama sorunu, $x$ $x a r a m a ö ğ e l e r i n i k a b u l e d e n b i r s o y u t i ş l e v$ f(x) $i l e m a t e m a t i k s e l o l a r a k f o r m ü l e e d i l e b i l i r .$ x $ö ğ e s i a r a m a s o r u n u n u n ç ö z ü m ü y s e$ f(x)=1 $.$ x $ö ğ e s i b i r ç ö z ü m d e ğ i l s e$ f(x)=0 $. A r a m a s o r u n u,$ f(x_0)=1 $g i b i$ x_0$ herhangi bir öğeyi bulmaktan oluşur.

Bu nedenle, herhangi bir arama sorununu şu şekilde formüle edebilirsiniz: klasik bir işlev $f (x) : {0, 1}^{n} \to {0, 1}$ , burada $n$ , arama alanının bit boyutu olduğunda, $f (x_{0}) = 1$ için bir giriş $x_{0}$ bulun.

Grover algoritmasını kullanarak arama sorununu çözmek için şunları yapmanız gerekir:

Sorunu Grover'ın görevi biçimine dönüştürün. Örneğin Grover algoritmasını kullanarak bir tamsayı $M$ faktörlerini bulmak istediğinizi varsayalım. $r \neq 0$ ve $r$ $M / x$ değerinin geri kalanıysa $f_{M} (x) = 1 [r],$ işlevi 1[r]=1r=1[r]=0 $i ş l e v i o l u ş t u r a r a k t a m s a y ı ç a r p a n l a ş t ı r m a s o r u n u n u G r o v e r^{'} ı n g ö r e v i n e d ö n ü ş t ü r e b i l i r s i n i z . B u ş e k i l d e,$ f_M(x_i)=1 $d e ğ e r i n i o l u ş t u r a n$ x_i $t a m s a y ı l a r ı$ M$ faktörlerini oluşturur ve sorunu Grover'ın görevine dönüştürmüş olursunuz.
Grover görevinin işlevini kuantum kahini olarak uygulayın. Grover algoritmasını uygulamak için Grover'ınızın görevinin $f (x)$ işlevini kuantum kahini olarak uygulamanız gerekir.
Görevi çözmek için grover algoritmasını kahininizle birlikte kullanın. Kuantum kahininiz olduktan sonra sorunu çözmek ve çıkışı yorumlamak için grover'ınızın algoritma uygulamasına takabilirsiniz.

Grover algoritması

Arama sorunu için $N = 2^{n}$ uygun öğeler olduğunu ve her öğeye $0$ olan bir tamsayı atanarak $N - 1$ olarak dizine alındıklarını varsayalım. Algoritmanın adımları şunlardır:

$| 0 ⟩$ durumunda başlatılan $n$ kubitlerin bir yazmaç ile başlayın.
Yazmaçtaki her kubite $H$ uygulayarak kaydı tekdüzen bir süper konuma hazırlayın: $| ψ ⟩ = \frac{1}{N^{1 / 2}} \sum_{x = 0}^{N - 1} | x ⟩$
Aşağıdaki işlemleri yazmaç $N_{optimal}$ kez uygulayın:
1. Çözüm öğeleri için $- 1$ koşullu aşama değişimi uygulayan aşama kahini $O_{f}$ .
2. Yazmaçtaki her kubite $H$ uygulayın.
3. $| 0 ⟩$ dışındaki her hesaplama temeli durumuna $- 1$ koşullu faz kaydırması olan $- O_{0}$ uygulayın.
4. Yazmaçtaki her kubite $H$ uygulayın.
Çok yüksek olasılıkla çözüm olan bir öğenin dizinini elde etmek için yazmaç değerini ölçün.
Geçerli bir çözüm olup olmadığını görmek için öğeyi denetleyin. Aksi takdirde yeniden başlayın.

Grover algoritmasının kodunu Q#

Bu bölümde, içinde algoritmanın Q#nasıl uygulanılacağı açıklanır. Grover algoritması uygulanırken dikkate alınması gereken birkaç şey vardır. İşaretli durumunuzun ne olduğunu, bu durumu nasıl yansıtabileceğinizi ve algoritmayı çalıştıracak yineleme sayısını tanımlamanız gerekir. Grover görevinin işlevini uygulayan kahini de tanımlamanız gerekir.

İşaretli durumu tanımlama

İlk olarak, aramada bulmaya çalıştığınız girişi tanımlarsınız. Bunu yapmak için Grover algoritmasından b, c ve d adımlarını uygulayan bir işlem yazın.

Bu adımlar birlikte Grover'ın $- H^{\otimes n} O_{0} H^{\otimes n}$ difüzyon işleci olarak da bilinir.

operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {
    Message("Reflecting about marked state...");
    use outputQubit = Qubit();
    within {
        // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that
        // toggling it results in a (-1) phase.
        X(outputQubit);
        H(outputQubit);
        // Flip the outputQubit for marked states.
        // Here, we get the state with alternating 0s and 1s by using the X
        // operation on every other qubit.
        for q in inputQubits[...2...] {
            X(q);
        }
    } apply {
        Controlled X(inputQubits, outputQubit);
    }
}

İşlem, ReflectAboutMarked değişen sıfırlar ve birlerle işaretlenmiş temel durumu yansıtır. Bunu yapmak için Grover'ın difüzyon işlecini giriş kubitlerine uygular. İşlem, outputQubit $X$ ve $H$ geçitleri uygulanarak $| - ⟩ = \frac{1}{\sqrt{2}} (| 0 ⟩ - | 1 ⟩)$ durumunda başlatılan yardımcı bir kubit kullanır. İşlem daha sonra $X$ geçidini yazmaçtaki diğer tüm kubitlere uygular ve bu da kubitin durumunu çevirir. Son olarak, kontrollü $X$ geçidini yardımcı kubite ve giriş kubitlerine uygular. Bu işlem, yalnızca tüm giriş kubitleri işaretli durumdaki $| 1 ⟩$ durumundaysa yardımcı kubiti çevirir.

En uygun yineleme sayısını tanımlama

Grover'ın araması, geçerli bir çıkışı ölçme olasılığı en yüksek olan en iyi yineleme sayısına sahiptir. Sorun $N = 2^{n}$ olası uygun öğelere sahipse ve bunların $M$ değeri soruna çözümse, en iyi yineleme sayısı şu şekildedir:

$N_{optimal} \approx \frac{π}{4} \sqrt{\frac{N}{M}}$

En uygun yineleme sayısını yinelemeye devam etmek, $2 N_{optimal}$ yinelemesinde neredeyse sıfır başarı olasılığına ulaşana kadar bu olasılığı azaltmaya başlar. Bundan sonra, olasılık $3 N_{optimal}$ gibi bir değere kadar yeniden büyür.

Pratik uygulamalarda genellikle probleminizi çözene kadar kaç farklı çözümü olabileceği hakkında bilginiz olmaz. Bu sorunu ele almak için etkili bir strateji, iki güçteki tahminleri aşamalı olarak artırarak (1, 2, 4, 8, 16, ..., 2^n $)$ M $ç ö z ü m s a y ı s ı n ı " t a h m i n e t m e k " t i r . B u t a h m i n l e r d e n b i r i, a l g o r i t m a n ı n$ \sqrt{\frac{N}{M}}$ civarında ortalama yineleme sayısına sahip çözümü bulmaya devam edeceği kadar yakın olacaktır.

Aşağıdaki Q# işlev, bir yazmaçtaki belirli bir kubit sayısı için en uygun yineleme sayısını hesaplar.

function CalculateOptimalIterations(nQubits : Int) : Int {
    if nQubits > 63 {
        fail "This sample supports at most 63 qubits.";
    }
    let nItems = 1 <<< nQubits; // 2^nQubits
    let angle = ArcSin(1. / Sqrt(IntAsDouble(nItems)));
    let iterations = Round(0.25 * PI() / angle - 0.5);
    return iterations;
}

İşlev, CalculateOptimalIterations yineleme sayısını hesaplamak için yukarıdaki formülü kullanır ve ardından en yakın tamsayıya yuvarlar.

Grover'ın işlemini tanımlama

Q# Grover arama algoritmasının işlemi üç girişe sahiptir:

Kubit nQubits : Intyazmaçtaki kubit sayısı. Bu kayıt, belirsiz çözümü arama sorununa kodlar. İşlemden sonra ölçülür.
En uygun yineleme sayısı, iterations : Int.
Grover görevi için aşama kahini temsil eden bir işlem phaseOracle : Qubit[] => Unit) : Result[]. Bu işlem, genel bir kubit yazmaç üzerinde birimsel dönüştürme uygular.

operation GroverSearch( nQubits : Int, iterations : Int, phaseOracle : Qubit[] => Unit) : Result[] {

    use qubits = Qubit[nQubits];
    PrepareUniform(qubits);

    for _ in 1..iterations {
        phaseOracle(qubits);
        ReflectAboutUniform(qubits);
    }

    // Measure and return the answer.
    return MResetEachZ(qubits);
}

İşlem, GroverSearch $| 0 ⟩$ durumundaki $n$ kubitlerin bir kaydını başlatır, yazmacı tekdüzen bir süper pozisyona hazırlar ve ardından Grover algoritmasını belirtilen sayıda yineleme için uygular. Aramanın kendisi, işaretlenen durum ve başlangıç durumu hakkında sürekli olarak yansıtılmasından oluşur ve bunu for döngüsü olarak yazabilirsiniz Q# . Son olarak, yazmaç ölçer ve sonucu döndürür.

Kod üç yardımcı işlemi kullanır: PrepareUniform, ReflectAboutUniformve ReflectAboutAllOnes.

All-zeros durumundaki bir yazmaç verüldüğünde, PrepareUniform işlem tüm temel durumlara göre tekdüzen bir süper konum hazırlar.

operation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {
    for q in inputQubits {
        H(q);
    }
}

''ReflectAboutAllOnes' işlemi all-one durumu hakkında yansıtır.

operation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {
    Controlled Z(Most(inputQubits), Tail(inputQubits));
}

İşlem ReflectAboutUniform , tekdüzen süper konum durumu hakkında yansıtır. İlk olarak, tekdüzen süper pozisyonu sıfıra dönüştürür. Ardından sıfır durumunu tümü bire bir durumuna dönüştürür. Son olarak, tümü bir durumunu yansıtır. tekdüzen süper konum durumu hakkında vektör alanında bir yansıma olarak geometrik olarak yorumlanabildiği için işlem çağrılır ReflectAboutUniform .

operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {
    within {
        Adjoint PrepareUniform(inputQubits);
        // Transform the all-zero state to all-ones
        for q in inputQubits {
            X(q);
        }
    } apply {
        ReflectAboutAllOnes(inputQubits);
    }
}

Son kodu çalıştırma

Artık Grover arama algoritmasının belirli bir örneğini uygulamak ve faktöring sorununu çözmek için tüm bileşenlere sahipsiniz. İşlemi tamamlamak Main için kubit sayısını ve yineleme sayısını belirterek sorunu ayarlar

operation Main() : Result[] {
    let nQubits = 5;
    let iterations = CalculateOptimalIterations(nQubits);
    Message($"Number of iterations: {iterations}");
    
    // Use Grover's algorithm to find a particular marked state.
    let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);
    return results;
}

Programı çalıştırma

Programınızı çalıştırmak için istediğiniz platformu seçin.

Azure Quantum'da Copilot
Visual Studio Code

Kodunuzu Azure Quantum'da Copilot ile ücretsiz olarak test Q# edebilirsiniz. Tek ihtiyacınız bir Microsoft (MSA) e-posta hesabıdır. Azure Quantum'daki Copilot hakkında daha fazla bilgi için bkz . Azure Quantum'u keşfetme.

Tarayıcınızda Azure Quantum'da Copilot'i açın.

Aşağıdaki kodu kopyalayıp kod düzenleyicisine yapıştırın.

import Microsoft.Quantum.Convert.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Arrays.*;
import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Diagnostics.*;

operation Main() : Result[] {
    let nQubits = 5;
    let iterations = CalculateOptimalIterations(nQubits);
    Message($"Number of iterations: {iterations}");

    // Use Grover's algorithm to find a particular marked state.
    let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);
    return results;
}

operation GroverSearch(
    nQubits : Int,
    iterations : Int,
    phaseOracle : Qubit[] => Unit) : Result[] {

    use qubits = Qubit[nQubits];

    PrepareUniform(qubits);

    for _ in 1..iterations {
        phaseOracle(qubits);
        ReflectAboutUniform(qubits);
    }

    // Measure and return the answer.
    return MResetEachZ(qubits);
}

function CalculateOptimalIterations(nQubits : Int) : Int {
    if nQubits > 63 {
        fail "This sample supports at most 63 qubits.";
    }
    let nItems = 1 <<< nQubits; // 2^nQubits
    let angle = ArcSin(1. / Sqrt(IntAsDouble(nItems)));
    let iterations = Round(0.25 * PI() / angle - 0.5);
    return iterations;
}

operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {
    Message("Reflecting about marked state...");
    use outputQubit = Qubit();
    within {
        // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that
        // toggling it results in a (-1) phase.
        X(outputQubit);
        H(outputQubit);
        // Flip the outputQubit for marked states.
        // Here, we get the state with alternating 0s and 1s by using the X
        // operation on every other qubit.
        for q in inputQubits[...2...] {
            X(q);
        }
    } apply {
        Controlled X(inputQubits, outputQubit);
    }
}

operation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {
    for q in inputQubits {
        H(q);
    }
}

operation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {
    Controlled Z(Most(inputQubits), Tail(inputQubits));
}

operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {
    within {
        // Transform the uniform superposition to all-zero.
        Adjoint PrepareUniform(inputQubits);
        // Transform the all-zero state to all-ones
        for q in inputQubits {
            X(q);
        }
    } apply {
        // Now that we've transformed the uniform superposition to the
        // all-ones state, reflect about the all-ones state, then let the
        // within/apply block transform us back.
        ReflectAboutAllOnes(inputQubits);
    }
}

İpucu

Azure Quantum'daki Copilot'tan, kod düzenleyicisinin sağ köşesindeki VS Code logosu düğmesini seçerek programınızı Web için VS Code'da açabilirsiniz.

Bellek içi simülatörü kullanarak programı çalıştırma

Bellek içi Simülatörü'ne tıklayın.
Çalıştırılacak çekim sayısını seçin ve Çalıştır'ı seçin.
Sonuçlar histogramda ve Sonuçlar alanlarında görüntülenir.
Copilot'un kodu size açıklamasını istemesi için Kodu açıkla'ya tıklayın.

Quantinuum Öykünücüsünü kullanarak programı çalıştırın

Ayrıca programınızı ücretsiz Quantinuum Öykünücüsünesunabilirsiniz. Öykünücü, 20 kubitli bir kuantum bilgisayarın simülasyonunu oluşturur.

In-Memory Simülatörü açılan listeden seçin ve Quantinuum Öykünücüsüseçin.
Çekim sayısını seçin (şu anda 20 ile sınırlıdır) ve Çalıştır'ı seçin.

Visual Studio Code'u açın ve Yeni Metin Dosyası Oluştur'u > seçerek yeni bir dosya oluşturun.
Dosyayı GroversAlgorithm.qs olarak kaydedin. Bu dosya, programınızın kodunu içerir Q# .

Aşağıdaki kodu dosyaya GroversAlgorithm.qs kopyalayın.


import Microsoft.Quantum.Convert.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Arrays.*;
import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Diagnostics.*;


operation Main() : Result[] {
    let nQubits = 5;
    let iterations = CalculateOptimalIterations(nQubits);
    Message($"Number of iterations: {iterations}");

    // Use Grover's algorithm to find a particular marked state.
    let results = GroverSearch(nQubits, iterations, ReflectAboutMarked);
    return results;
}

operation GroverSearch(
    nQubits : Int,
    iterations : Int,
    phaseOracle : Qubit[] => Unit) : Result[] {

    use qubits = Qubit[nQubits];

    PrepareUniform(qubits);

    for _ in 1..iterations {
        phaseOracle(qubits);
        ReflectAboutUniform(qubits);
    }

    // Measure and return the answer.
    return MResetEachZ(qubits);
}

function CalculateOptimalIterations(nQubits : Int) : Int {
    if nQubits > 63 {
        fail "This sample supports at most 63 qubits.";
    }
    let nItems = 1 <<< nQubits; // 2^nQubits
    let angle = ArcSin(1. / Sqrt(IntAsDouble(nItems)));
    let iterations = Round(0.25 * PI() / angle - 0.5);
    return iterations;
}

operation ReflectAboutMarked(inputQubits : Qubit[]) : Unit {
    Message("Reflecting about marked state...");
    use outputQubit = Qubit();
    within {
        // We initialize the outputQubit to (|0⟩ - |1⟩) / √2, so that
        // toggling it results in a (-1) phase.
        X(outputQubit);
        H(outputQubit);
        // Flip the outputQubit for marked states.
        // Here, we get the state with alternating 0s and 1s by using the X
        // operation on every other qubit.
        for q in inputQubits[...2...] {
            X(q);
        }
    } apply {
        Controlled X(inputQubits, outputQubit);
    }
}

operation PrepareUniform(inputQubits : Qubit[]) : Unit is Adj + Ctl {
    for q in inputQubits {
        H(q);
    }
}

operation ReflectAboutAllOnes(inputQubits : Qubit[]) : Unit {
    Controlled Z(Most(inputQubits), Tail(inputQubits));
}

operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {
    within {
        // Transform the uniform superposition to all-zero.
        Adjoint PrepareUniform(inputQubits);
        // Transform the all-zero state to all-ones
        for q in inputQubits {
            X(q);
        }
    } apply {
        // Now that we've transformed the uniform superposition to the
        // all-ones state, reflect about the all-ones state, then let the
        // within/apply block transform us back.
        ReflectAboutAllOnes(inputQubits);
    }
}

Programı çalıştırmadan önce profilin Sınırsıztargetayarlandığından emin olun. Görünüm - Komut Paleti'ni>, QIR'yi arayın, öğesini seçin ayarlayın ve ardından : sınırsız'ıQ#target.
Programınızı çalıştırmak için işlemin üst kısmındaki komut listesinde Çalıştır'ıMainveya Ctrl+F5 tuşlarına basın. Varsayılan olarak, derleyici işlemi veya işlevi varsayılan simülatörde çalıştırır Main .
Çıkışınız terminaldeki hata ayıklama konsolunda görünür.

Not

target Profil Sınırsız olarak ayarlanmamışsa, programı çalıştırdığınızda bir hata alırsınız.

Diğer Q# öğreticileri keşfedin:

Kuantum dolanıklığı , kubitleri işleyen ve ölçen ve süper pozisyon ile dolanıklığın etkilerini gösteren bir Q# programın nasıl yazıldığını gösterir.
Kuantum rastgele sayı oluşturucu , süper pozisyondaki kubitlerden rastgele sayılar oluşturan bir Q# programın nasıl yazıldığını gösterir.
Quantum Fourier Transform , belirli kubitleri doğrudan ele alan bir Q# programın nasıl yazıldığını keşfeder.
Kuantum Kataları, kuantum bilişimi ve programlama öğelerini aynı anda öğretmeyi amaçlayan kendi hızındaki öğreticiler ve Q# programlama alıştırmalarıdır.

Ek kaynaklar

Belgeler

Öğretici: Kuantum Rastgele Sayı Oluşturucu oluşturma - Azure Quantum

Q# Kuantum rastgele sayı oluşturucu oluşturarak süper pozisyon gibi temel kuantum kavramlarını gösteren bir proje oluşturun.
Öğretici: Q\ dilinde Quantum Fourier Dönüşümü # - Azure Quantum

Bu öğreticide, tek kubit düzeyinde çalışan bir kuantum programı yazmayı ve simülasyonunu yapmayı öğrenin.
Öğretici: Ile Kuantum Dolanıklığı Q# - Azure Quantum

Bu öğreticide Q# , kubitlerin süper konumunu ve dolanıklığını gösteren bir kuantum programı yazın.
Hızlı Başlangıç: Program Oluşturma Q# - Azure Quantum

Bu makalede Quantum Geliştirme Seti ve Visual Studio Code kullanarak ilk Q# programınızı nasıl oluşturacağınız açıklanmaktadır.
Ile Kuantum Devrelerini Görselleştirme Q# - Azure Quantum

VS Code, Python ve Jupyter Notebook'ları kullanarak kuantum bağlantı hattı diyagramlarıyla kuantum algoritmalarını görsel olarak nasıl temsil etmeyi öğrenin.
Azure Quantum'da Kuantum Programlarında Hata Ayıklama ve Test Etme - Azure Quantum

Kuantum programlarını test etmek ve hatalarını ayıklamak için birim testlerini, olguları ve onayları ve döküm işlevlerini kullanmayı öğrenin.
Visual Studio Code'daki Q# özellikleri - Azure Quantum

VS Code için Azure Quantum Geliştirme Seti uzantısına dahil edilen özellikler hakkında bilgi edinin.
Projeleri ve Özel Kitaplıkları Geliştirme ve Yönetme Q# - Azure Quantum

Birden çok kaynak dosya kullanan bir Q# proje tanımlamayı ve projelerinizi yeniden kullanılabilir özel kitaplıklar olarak kullanmayı öğrenin.

Eğitim

Modül

Azure Quantum Geliştirme Seti'ni kullanarak ilk Q# programınızı oluşturma - Training

Bir kuantum rastgele sayı oluşturucu derleyerek Q# ile programlamaya başlayın.

The future is yours

Aracılığıyla paylaş

Öğretici: Içinde Grover arama algoritmasını uygulama Q#

Önkoşullar

Sorunu tanımlama

Grover algoritması

Grover algoritmasının kodunu Q#

İşaretli durumu tanımlama

En uygun yineleme sayısını tanımlama

Grover'ın işlemini tanımlama

Son kodu çalıştırma

Programı çalıştırma

Bellek içi simülatörü kullanarak programı çalıştırma

Quantinuum Öykünücüsünü kullanarak programı çalıştırın

Geri Bildirim

Ek kaynaklar

The future is yours

Aracılığıyla paylaş

Öğretici: Içinde Grover arama algoritmasını uygulama Q#

Önkoşullar

Sorunu tanımlama

Grover algoritması

Grover algoritmasının kodunu Q#

İşaretli durumu tanımlama

En uygun yineleme sayısını tanımlama

Grover'ın işlemini tanımlama

Son kodu çalıştırma

Programı çalıştırma

Bellek içi simülatörü kullanarak programı çalıştırma

Quantinuum Öykünücüsünü kullanarak programı çalıştırın

İlgili içerik

Geri Bildirim

Ek kaynaklar