
Russian: 
- Звонок получил получить счет
и пройти в нашей схеме.
И вот оно; это результат
выполнения нашей квантовой схемы.
(веселая музыка)
Здравствуйте все.
Добро пожаловать обратно в Кодирование с Qiskit.
Так традиционно, когда мы учимся
новые языки программирования,
первое приложение, которое мы пишем
это то, что называется
Приложение Hello World.
И цель этого
Приложение, чтобы показать, во-первых,
что вы установили
язык программирования правильно
на вашем компьютере и,
во-вторых, чтобы пройти через
какое регулярное приложение
цикл выглядит так.
Итак, как вы программируете приложение
и получить его к исполнению,
такого рода рабочий процесс.
Так что в этом видео, что я
надеюсь достичь показать вам
этот рабочий процесс, запустив
ваш первый Hello World
приложение в квантовой
механика с использованием Qiskit.

English: 
- Call got get counts
and pass in our circuit.
And there it is; that's the result
of executing our quantum circuit.
(funky music)
Hello, everyone.
Welcome back to Coding with Qiskit.
So traditionally when we learn
new programming languages,
the first application that we write
is what's called the
Hello World application.
And the purpose of this
application is to show, first,
that you've installed the
programming language correctly
on your computer and,
second, to walk you through
what a regular application
cycle looks like.
So how you program an application
and get it to execution,
that kind of workflow.
So in this video what I
hope to achieve is show you
that workflow by running
your first Hello World
application in quantum
mechanics using Qiskit.

Korean: 
get_counts 메소드를 불러와서
인수에 circuit을 지정합니다.
저기에 있네요; 우리가 실행한 양자회로의
결과입니다.(17번 라인의 실행 결과 18번 라인)
여러분 안녕하세요.
Qiskit 코딩에 오신 것을 환영합니다.
전통적으로... 우리가 새로운 프로그래밍 언어를 배울 때,
첫 애플리케이션으로 우리는
Hello World 를 작성합니다.
그리고 이 애플리케이션의 목적은
우선, 여러분의 컴퓨터에 프로그래밍 언어가 올바르게 
설치되었는지를 보기 위함이며
두 번째로, 일반적인 애플리케이션의 구동이
어떻게 돌아가는지 안내하기 위함입니다.
그래서... 애플리케이션을 프로그래밍하고
실행하도록 하는, 그런 워크플로를요.
그래서... 이 영상에서 제가 바라는 것은
양자 역학을 이용 한 Qiskit에서의 응용 프로그램인
여러분의 첫 Hello World 를 실행하는 것입니다.

Spanish: 
- La llamada tiene recuentos
y pasa en nuestro circuito.
Y ahí está; ese es el resultado
de ejecutar nuestro circuito cuántico.
(música funky)
Hola a todos.
Bienvenido de nuevo a Coding con Qiskit.
Así que tradicionalmente cuando aprendemos
nuevos lenguajes de programación,
la primera aplicación que escribimos
es lo que se llama el
Hola aplicación mundial.
Y el propósito de esto
la aplicación es mostrar, primero,
que has instalado el
lenguaje de programación correctamente
en tu computadora y,
segundo, guiarte
que aplicación regular
Se ve el ciclo.
Entonces, ¿cómo se programa una aplicación?
y llevarlo a la ejecución,
ese tipo de flujo de trabajo.
Entonces en este video lo que yo
espero lograr es mostrarte
ese flujo de trabajo ejecutando
tu primer hola mundo
aplicación en cuanto
Mecánica con Qiskit.

Japanese: 
get countを呼びます。
そして回路に入れます。
でました。
これが量子回路を実行した結果です。
(音楽)
みなさん、こんにちは。
Coding with Qiskit にようこそ。
私たちが新しいプログラミング言語を
学習するとき、伝統的に
最初に書くアプリケーションは
Hello World アプリケーションと呼ばれています。
このアプリケーションの目的は、
プログラミング言語が正しくインストールできているか確認し、
そして通常のアプリケーションサイクルが
どんなものか示すことです。
どのようにアプリケーションをプログラミングし、
実行するのかといったワークフローです。
このビデオで達成したいことは、
Qiskitを使った量子コンピューターの
最初のHello World アプリケーションの
実行ワークフローをお見せすることです。

Spanish: 
Entonces en el episodio anterior
te mostramos cómo instalar
Qiskit en tu computadora,
y en este episodio
lo que haremos es llevarte a
ejecuta tu primer programa cuántico.
Así que espero que ahora
Has instalado Qiskit.
Y lo que voy a hacer es que yo
tengo la ventana de mi terminal abierta,
y voy a comenzar un cuaderno Jupyter
donde comenzaré a escribir
código para ejecutar en Qiskit.
Entonces tengo mi ventana de terminal
abierto como puedes ver aquí
y voy a escribir
Jupyter Notebook y pulsa enter
y eso me da una nueva ventana de Jupyter
en el que puedo comenzar a programar.
Bien, ahora que hemos
abrió un cuaderno en blanco,
lo que vamos a hacer es
comience a escribir código en Qiskit.
Ahora para aquellos de ustedes que
están familiarizados con Python,
Qiskit está escrito en Python,
así que mucho se verá
muy familiar para ti
Y para aquellos de ustedes que
no sé, no te preocupes;
pasaremos por el
fundamentos que necesitamos
antes de construir complicado
circuitos cuánticos
Así que sigue a lo largo.
Entonces lo primero que voy a hacer
es hacer desde Qiskit
importar todo

Korean: 
이전 에피소드에서, 여러분의 컴퓨터에 Qiskit을
설치하는 방법을 보여주었습니다.
그리고 이번 에피소드에서는
우리가 할 것은 여러분들이
첫 번째 양자 프로그램을 실행하는 것입니다.
지금쯤이면 Qiskit을 설치하셨을 겁니다.
이제 제가 하려고 하는 것은 커맨드 창을 열고
Qiskit에서 실행할 코드를 작성할
주피터 노트북을 시작하는 것입니다.
여기 여러분이 보이시는 것처럼
커맨드 창을 열었습니다.
그리고 jupyter notebook 을 치고 엔터 키를 누릅니다.
그러면 새로운 주피터 창이 열리고
프로그래밍을 시작할 수 있습니다.
자, 이제 우리는 새창을 열었고
우리가 할 것은
Qiskit에서 코드 작성을 시작하는 것입니다.
Python에 익숙하신 분들을 위해
Qiskit은 Python으로 작성되었습니다.
그래서, 많은 것들이 여러분에게
친숙하게 보일 것입니다.
그리고 모르는 분들은 걱정하지 마세요
필요한 기초를 잘 헤쳐나갈 수 있을 거에요.
복잡한 양자 회로를 만들기 전에.
따라오시면 됩니다.
가장 먼저 제가 할 것은
코드(from qiskit import *)를 작성하는 것입니다.
(qiskit 패키지의 모든 모듈을 가져옴)

Russian: 
Так в предыдущем эпизоде
мы показали вам, как установить
Qiskit на вашем компьютере,
и в этом эпизоде
что мы сделаем, это чтобы вы
запустите вашу первую квантовую программу.
Так что, надеюсь, сейчас
Вы установили Qiskit.
И что я собираюсь сделать, это я
открыть окно моего терминала,
и я собираюсь начать ноутбук Jupyter
где я начну писать
код для выполнения в Qiskit.
Итак, у меня есть окно терминала
открыть, как вы можете видеть здесь
и я собираюсь написать
Jupyter Notebook и нажмите ввод
и это дает мне новое окно Jupyter
на котором я могу начать программирование.
Хорошо, теперь, когда мы
открыл пустой блокнот,
что мы собираемся сделать, это
начать писать код в Qiskit.
Теперь для тех из вас, кто
знакомы с Python,
Qiskit написан на Python,
так много будет выглядеть
очень знакомый вам
И для тех из вас, что
не знаю, не волнуйся;
мы пройдем через
основы, которые нам нужны
до строительства сложного
квантовые схемы.
Так что следуйте.
Итак, первое, что я собираюсь сделать
это делать из Qiskit
импортировать все

English: 
So in the previous episode
we showed you how to install
Qiskit on your computer,
and in this episode
what we'll do is get you to
run your first quantum program.
So hopefully by now
you've installed Qiskit.
And what I'm going to do is I
have my terminal window open,
and I'm going to start a Jupyter Notebook
where I'll start writing
code to execute in Qiskit.
So I have my terminal window
open as you can see here
and I'm going to write
Jupyter Notebook and hit enter
and that gives me a new Jupyter window
on which I can start programming.
Okay, so now that we've
opened a blank notebook,
what we're going to do is
start writing code in Qiskit.
Now for those of you who
are familiar with Python,
Qiskit is written in Python,
so a lot of it will look
very familiar to you.
And for those of you that
don't know, don't worry;
we'll get through the
fundamentals that we need
before building complicated
quantum circuits.
So follow along.
So the first thing that I'm going to do
is to do from Qiskit
import everything.

Japanese: 
前のエピソードでは
Qiskitをあなたのコンピューターにインストール
する方法をお見せしました。
このエピソードでは、あなたの最初の
量子プログラムを実行させます。
ですので、Qiskitをインストールしておいてください。
ターミナルウィンドウを開いて、
Jupyter notebookを開始します。
ここでQiskitのコードを書き始めます。
ご覧のようにターミナルウィンドウを開きました。
jupyter notebookと書いてエンターを押すと
新しいJupyterのウィンドウが開くので、
ここでプログラミングを開始できます。
では、新しいnotebookを開きます。
そこでQiskitでコードを書き始めることができます。
Pythonに精通している人には、
QiskitはPythonで書かれているので
その多くは、とても親しみやすいものになります。
Pythonを知らない人も心配しないでください。
複雑な量子回路を構築する前に
必要となる基本的な事柄を学んでいきます。
ですので続けてください。
はじめに行うのは、
Qiskitから全てを
Importすることです。

Russian: 
Как только я импортировал все из Qiskit,
следующая часть должна построить
квантовый контур.
И построить эту квантовую схему,
как я и обещал мы едем
строить два кубита
квантовая схема; И что
Я собираюсь сделать это первым
создать двухкубитовый квантовый регистр,
а потом я собираюсь
построить два классических бита
классический регистр, чтобы я мог взять
измерения от этих квантовых битов.
Если я могу просто лучше напечатать.
Итак, теперь мы построили квантовый регистр
и классический регистр,
и теперь мы можем построить
Схема с использованием этих двух.
(веселая музыка)
Теперь мы создали квантовую схему.
И в любой момент
мы модифицируем схему,
если вы хотите посмотреть на что
схема выглядит так,
Вы можете сделать это
делаем следующее.
(веселая музыка)
Я сделаю здесь одну строчку, так что
что мы можем видеть наши рисунки.

Korean: 
Qiskit에서 모든 것을 import 하면
다음은 양자 회로를 구축하는 것입니다.
이 양자 회로를 만들려면,
제가 언급한대로,
2 큐비트 양자회로를 구축할 겁니다.
그래서 처음으로 제가 할 것은
2 큐비트 양자 레지스터(register)를 만들고 나서,
2개의 고전(classical) 비트를 만들겁니다.
고전 레지스터는
이들 양자 비트에서 측정한 값을 가져가도록 합니다.
내가 더 잘 칠 수 있다면...(타이핑을)
이제 양자 레지스터와
클래식 레지스터를 만들었고,
이제 이 둘을 사용하는 회로를 구축할 겁니다.
이제 우리는 양자 회로를 만들었습니다.
그리고 회로를 수정하다가,
여러분들이 이 회로가
어떻게 생겼는지를 보고 싶으시다면,
다음과 같이 하면 됩니다.
제가 그림을 볼 수 있도록
여기에... 한 줄의 코드를 작성하고

Japanese: 
Qiskitから全てをImportしたら、
量子回路を構築するパートになります。
量子回路を構築するために
2量子ビット回路を構築します。
最初に
2量子ビットレジスターを作成して
2古典ビットを作成します。
古典レジスターは量子ビットからの
測定結果を入れるものです。
もっとタイプが上手だったら良かったのに。
これで量子レジスターと
古典レジスターを構築できたので
これらを使って回路を構築できます。
(音楽)
量子回路を構築しました。
回路を修正した時、
回路がどのように見えるかを見たい場合は、
次のようにして描画できます。
(音楽)
ここでこの1行を入れると、
描画を見れるようになります。

English: 
Once I've imported everything from Qiskit,
the next part is to build
the quantum circuit.
And to build this quantum circuit,
as I promised we're going
to be building a two qubit
quantum circuit; so what
I am going to do is first
to create a two qubit quantum register,
and then I'm going to
build a two classical bit
classical register so that I can take
measurements from these quantum bits.
If I can just type better.
So now we've built a quantum register
and a classical register,
and now we can build a
circuit using those two.
(funky music)
Now we've created a quantum circuit.
And at any point that
we modify the circuit,
if you want to look at what
the circuit looks like,
you can draw it out by
doing the following.
(funky music)
I'll do this one line here, so
that we can see our drawings.

Spanish: 
Una vez que importé todo de Qiskit,
la siguiente parte es construir
El circuito cuántico.
Y para construir este circuito cuántico,
como prometí vamos
estar construyendo un dos qubit
circuito cuántico; Y qué
Voy a hacer es primero
para crear un registro cuántico de dos qubits,
y luego voy a
construir un bit de dos clásicos
registro clásico para que pueda tomar
mediciones de estos bits cuánticos.
Si solo puedo escribir mejor.
Entonces ahora hemos construido un registro cuántico
y un registro clásico,
y ahora podemos construir un
circuito usando esos dos.
(música funky)
Ahora hemos creado un circuito cuántico.
Y en cualquier punto que
modificamos el circuito,
si quieres ver qué
el circuito se ve como
puedes sacarlo
haciendo lo siguiente.
(música funky)
Haré esta línea aquí, así que
que podemos ver nuestros dibujos

Russian: 
А потом я просто сделаю Circuit.
Итак, как вы можете видеть, что мы
есть два квантовых бита
в цепи и два
классические биты в схеме.
Квантовые биты равны нулю
суб ноль и Q ноль суб один,
и классические биты равны нулю
к югу от нуля и к нулю к югу один.
Хорошо, теперь эта схема
не очень интересно.
Там не так уж много
интересные вещи здесь происходят.
Там нет ворот, поэтому
что мы собираемся сделать
в настоящее время создать
ворота в цепь.
Таким образом, чтобы создать запутанность,
первый шаг - применить то, что известно
как ворота Адамара на первый кубит.
И так, что я собираюсь
сделать это схема.
что для краткости H, и я собираюсь
применить его на первом кубите.
Итак, как только мы сделали это, снова
Вы можете применить свою функцию рисования.
И на этот раз, что я иду
сделать, это показать вам путь
сделать лучший сюжет вашей схемы

Spanish: 
Y luego haré circuit.draw.
Como pueden ver, lo que nosotros
tener es dos bits cuánticos
en el circuito y dos
bits clásicos en el circuito.
Los bits cuánticos son Q cero
sub cero y Q cero sub uno,
y los bits clásicos son C cero
sub cero y C cero sub uno.
Muy bien, ahora este circuito
No es muy interesante.
No hay demasiados
Cosas interesantes que suceden aquí.
No hay puertas, entonces
que vamos a hacer
ahora es construir el
puertas al circuito.
Entonces, para crear enredos,
el primer paso es aplicar lo que se conoce
como una puerta Hadamard en el primer qubit.
Y entonces lo que voy a hacer
do is circuit.hadamart,
que es H para abreviar, y voy a
aplícalo en el primer qubit.
Entonces, una vez que hayamos hecho eso, nuevamente,
Puedes aplicar tu función de dibujo.
Y esta vez lo que voy
hacer es mostrarte un camino
para hacer una mejor trama de su circuito

Korean: 
circuit.draw() 메소드를 수행합니다.
여러분이 보시는 것처럼,
회로는 2개의 큐비트와
2개의 고전적인 비트를 가지고 있습니다.
큐비트들은 q0_0와 q0_1 이며,
고전적인 비트들은
c0_0와 c0_1 입니다.
좋아요, 이제 이 회로는 별로 재미가 없네요.
여기에는 재미있는 것들이 많이 없네요.
게이트들도 없고, 이제 우리가 할 것은,
회로에 게이트들을 구축하는 것입니다.
얽힘(entanglement)을 만들기 위해서,
첫 번째 단계는 첫번째 큐비트(q0_0)에
아다마르(Hadamard) 게이트를 적용하는 것입니다.
그래서 이제 제가 하려는 것은
circuit.h() method를,
짧게 하면 H를,
첫 번째 큐비트에 적용하는 것입니다.
circuit.h(qr[0])
이렇게 작성하고 나서,
다시, 회로를 그려보도록 하겠습니다.
그리고 이번에는 회로를 더 나은 방법으로
plot 하는 것을 보여드리겠습니다.

English: 
And then I'll just do circuit.draw.
So as you can see, what we
have is two quantum bits
in the circuit and two
classical bits in the circuit.
The quantum bits are Q zero
sub zero and Q zero sub one,
and the classical bits are C zero
sub zero and C zero sub one.
All right, now this circuit
is not very interesting.
There aren't too many
interesting things going on here.
There are no gates, so
what we're going to do
is now build up the
gates into the circuit.
So in order to create entanglement,
the first step is to apply what's known
as a Hadamard gate onto the first qubit.
And so what I'm going to
do is circuit.hadamart,
which is H for short, and I'm going to
apply it on the first qubit.
So once we've done that, again,
you can apply your drawing function.
And this time what I'm going
to do is show you a way
to make a better plot of your circuit

Japanese: 
circuit.draw() と入れます。
ご覧のように、回路に2量子ビットと
回路に2古典ビットがあることがわかります。
量子ビットはq0_0とq0_1で
古典ビットはc0_0と
c0_1です。
では、この回路は全然面白くありませんね。
面白いことは行われていません。
ゲートが一つもないので、
回路にゲートを構築しましょう。
エンタングルメントを作るための
最初のステップは
1つ目の量子ビットにアダマールゲートと
呼ばれているものを適用することです。
circuit.h()として、
アダマールのhです。
最初の量子ビットに適用します。
これを行なったら、再び
描画機能を適用します。
今回は、量子回路をより良く見せる
方法を使います。

Japanese: 
テキストベースの代わりに
matplotlibのものを使います。
アダマールゲートを1番目の量子ビットに
適用したので、Hが表示されます。
次に、２つの量子ビットを操作する
制御Xを作ります。
次のようにします。
(音楽)
この2つの量子ビットの操作は、
論理ifに似ているため、
if文（もしAならB）の量子版になります。
コントロール・ビットは
1つ目の量子ビットになります。
この操作のターゲット・ビットは
2個目の量子ビットです。
ではやってみましょう。
この回路がどのように見えるか見てみましょう。
(音楽)
こうです。
量子回路はアダマールゲートと
制御Xで構成されています。
ここでのアイディアは、この二つのシンプルな操作で
エンタングルメントを作ることです。
q0_0とq0_1の間に。

Spanish: 
en lugar de usar algo
eso es basado en texto
usar algo que
parcelas en matplotlib.
Entonces ahora que tienes un
Puerta Hadamard aplicada
hasta el primer qubit, tú
mira esa H que apareció.
Luego crearemos un qubit de dos
operación llamada X controlada,
y eso se hace haciendo lo siguiente.
(música funky)
Esta operación de dos qubits
es como un lógico si,
entonces va a ser el
versión cuántica de si esto,
entonces eso; y el control es
va a ser el primer qubit
Y el objetivo de esa operación
va a ser el segundo qubit, lo siento.
Y ahi vamos.
Veamos cómo se ve nuestro circuito.
(música funky)
Aquí vamos.
Ahora nuestro circuito cuántico está compuesto
de una puerta Hadamard y
un controlado (murmullos).
Y la idea aquí es ahora con
estas dos operaciones simples,
somos capaces de generar enredos
entre Q cero sub cero
y Q cero sub uno.

English: 
instead of using something
that's text based
to use something that
plots out in matplotlib.
So now that you have a
Hadamard gate applied
to the first qubit, you
see that H that showed up.
We're going to then create a two qubit
operation called a controlled X,
and that's done by doing the following.
(funky music)
This two qubit operation
is like a logical if,
so it's going to be the
quantum version of if this,
then that; and the control is
going to be the first qubit.
And the target of that operation
is going to be the second qubit, sorry.
And there we go.
Let's look at how our circuit looks.
(funky music)
There we go.
Now our quantum circuit is composed
of a Hadamard gate and
a controlled (mumbles).
And the idea here is now with
these two simple operations,
we're able to generate entanglement
between Q zero sub zero
and Q zero sub one.

Russian: 
вместо того, чтобы использовать что-то
это на основе текста
использовать то, что
сюжеты в матплотлиб.
Итак, теперь у вас есть
Ворота Адамара применяются
на первый кубит, вы
увидеть, что H, который появился.
Мы собираемся затем создать два кубита
операция называется контролируемым X,
и это делается следующим образом.
(веселая музыка)
Это две операции кубита
это логично, если,
так что это будет
квантовая версия если это,
тогда это; и контроль
будет первый кубит.
И цель этой операции
будет второй кубит, извините.
И там мы идем.
Давайте посмотрим, как выглядит наша схема.
(веселая музыка)
Там мы идем.
Теперь наша квантовая схема состоит
ворот Адамара и
контролируемый (бормочет).
И идея здесь сейчас с
эти две простые операции,
мы можем создать запутанность
между Q ноль к югу от нуля
и Q ноль к югу один.

Korean: 
문자로 된 것(matplotlib inline)을 사용하는 것보다
matplotlib의 별칭인 mpl을 사용해서 plot 하였습니다.
이제 첫 번째 큐비트에 아다마르 게이트가 적용되었으니
여러분은 H가 나타난 것을 보실 수 있을 겁니다.
그러고 나서 우리는 controlled-X라고 불리는
2 큐비트 연산을 만들 겁니다.
다음을 따라하시면 만들 수 있습니다.
이 2 큐비트 연산은 if 조건문(논리)과 같습니다.
(각주; 이 연산의 결과는 XOR게이트와 같음)
그래서... 이건 양자버전의 if가 될 것이고,
그리고 control 은 첫번째 큐비트로 하고
(각주; cx게이트는 control과 target을 지정함.)
이 연산의 target 은
두 번째 큐비트로 합니다.
미안해요.(타이핑 실수 함)
실행해봅시다~!
회로가 어떻게 생겼는지 봅시다.
이렇게 나왔습니다.
이제 우리의 양자 회로는
Hadamard 게이트와 CNOT 게이트로 구성되었습니다.
여기서의 아이디어는 이 두가지 간단한 연산으로,
우리는 큐비트 q0_0와 q0_1 사이에
얽힘을 생성할 수 있습니다.

Korean: 
이제 우리는 Hadamard 게이트와
 controlled-X(CNOT) 게이트를 이용하여
양자회로를 만들었으니,
우리가 할 일은 바로... 양자 비트
또는 큐비트를 측정하여 이 측정치들을
고전적인 비트들에 저장할 것입니다.
그리고 우리가 할 것은
코드를 쓰는 것입니다. circuit.measure()
제가 하려는 것은 양자 레지스터 안의
큐비트를 측정한 것으로부터 결과를 얻는 것입니다.
그리고 결과들을 고전 레지스터에 저장하는 것입니다.
좋아요! 끝냈습니다.
그건 그렇고, 나타나는 output은
단순히 Jupyter Notebook과 관련있을 뿐입니다.
지금은 저것에 대해 걱정하지 않을 거구요...
측정된 여러분들의 회로는 내장되어있을 것입니다.
언제나 그렇듯이, 여러분들의 회로는
circuit.draw()를 수행하여 볼 수 있습니다.
좋아요! 이것이 우리의 회로의 최종 모습입니다.
Hardamard와 controlled X 같은
양자 게이트들이 있고
우리는 양자 회로에서 무슨 일이 일어났는지
이해할 수 있는 측정을 가지고 있습니다.

Spanish: 
Entonces ahora que hemos construido
nuestro circuito cuántico
usando esta puerta Hadamard
y controlado X puerta,
lo que vamos a hacer es
medir los bits cuánticos,
o qubits, y toma esas medidas
y almacenarlos en los pedazos clásicos.
Y lo que vamos a hacer es escribir
ese código para hacer eso, circuito.medida.
Lo que voy a hacer es tomar los resultados.
de medir los qubits
en el registro cuántico
y almacenarlos en el registro clásico.
Bien, entonces hemos hecho esto.
Por cierto, esas salidas que aparecen
simplemente están relacionados con un
peculiaridad de los cuadernos Jupyter.
No me preocuparía por ellos por ahora.
Entonces, tu circuito tiene
medidas integradas en él.
De nuevo, como siempre, puedes
mira cual es tu circuito
parece en cualquier momento
haciendo circuit.draw.
Bien, entonces esto es lo que nuestro
El circuito parece finalmente.
Tenemos nuestras operaciones cuánticas,
el Hadamard y la puerta X controlada;
y tenemos la medida
para que podamos entender
que paso en el
circuito cuántico al final.

English: 
So now that we've built
our quantum circuit
using this Hadamard gate
and controlled X gate,
what we're going to do is
measure the quantum bits,
or qubits, and take those measurements
and store them into the classical bits.
And what we're going to do is write out
that code to do that, circuit.measure.
What I'm going to do is take the results
from measuring the qubits
in the quantum register
and store them in the classical register.
Okay, so we've done this.
By the way, those outputs that show up
are simply related to a
quirk of Jupyter Notebooks.
I wouldn't worry about them for now.
So, your circuit has
measurements built into it.
Again, as always, you can
look at what your circuit
looks like at any moment
by doing circuit.draw.
Okay, so this is what our
circuit looks like finally.
We have our quantum operations,
the Hadamard and controlled X gate;
and we have the measurement
so that we can understand
what happened in the
quantum circuit at the end.

Russian: 
Итак, теперь, когда мы построили
наша квантовая схема
используя эти ворота Адамара
и контролируемые X ворота,
что мы собираемся сделать, это
измерить квантовые биты,
или кубиты, и принять эти измерения
и хранить их в классических битах.
И что мы собираемся сделать, это выписать
этот код, чтобы сделать это, circuit.measure.
Что я собираюсь сделать, это взять результаты
от измерения кубитов
в квантовом регистре
и хранить их в классическом регистре.
Итак, мы сделали это.
Кстати, те выводы, которые появляются
просто связаны с
Причуды ноутбуков Jupyter.
Я бы не беспокоился о них сейчас.
Итак, ваша схема имеет
измерения встроены в него.
Опять же, как всегда, вы можете
посмотри какая у тебя схема
выглядит в любой момент
выполнив Circuit. Draw.
Итак, это то, что наши
Схема выглядит, наконец,
У нас есть квантовые операции,
Адамар и контролируемые Х ворота;
и у нас есть измерение
чтобы мы могли понять
что случилось в
Квантовый контур в конце.

Japanese: 
アダマールゲートと制御Xを使って
量子回路を構築したので、
次は量子ビットを測定します。
そして測定結果を
古典ビットに保存します。
このコーディングは、
circuit.measure() とします。
これで、
量子レジスターの量子ビットを測定した結果が、
古典レジスターに保存されます。
できました。
ちなみに、表示される出力は、
Jupyter Notebookの出力方法になっています。
今のところ、心配することはありません。
これであなたの回路が測定されるようになりました。
再び、いつものように回路がどのように見えるか
circuit.draw を使って確認します。
これが最終的な回路の外観です。
量子オペレーターの
アダマールゲートと制御Xゲートがあり、
測定があり、
最後に量子回路で何が起きたか、
見ることができます。

English: 
So the next step is to run the circuit,
and I'm going to do two things.
The first thing I'm going to
do is run this quantum circuit
on my classical computer
and see what happens
when I simulate a quantum computer here.
And then when I'm, once I'm confident
with the quantum circuit,
what I'm going to do is
send it off to a real device at IBM
and then see the results that come out of
running this quantum
circuit on a real device.
So in order to simulate the circuit,
what I'm going to do is use
the air component of Qiskit.
The idea here is that air is
what we use when we need to do
simulations of our quantum
circuits on our local computer.
So the simulator can be imported from air
by doing air.get_backend,
and the name of the
simulator is QASM simulator.
If you're curious, the name QASM
comes from quantum assembly language.
Okay, now that we've
imported our simulator
it's time to execute the circuit.
So what I'll do is call execute.
What I'm doing is executing
the circuit that I've built

Spanish: 
Entonces el siguiente paso es correr el circuito,
y voy a hacer dos cosas
Lo primero que voy a hacer
hacer es ejecutar este circuito cuántico
en mi computadora clásica
y mira lo que pasa
cuando simulo una computadora cuántica aquí.
Y luego cuando estoy, una vez que tengo confianza
con el circuito cuántico,
lo que voy a hacer es
enviarlo a un dispositivo real en IBM
y luego ver los resultados que salen de
corriendo este cuanto
circuito en un dispositivo real.
Entonces, para simular el circuito,
lo que voy a hacer es usar
El componente de aire de Qiskit.
La idea aquí es que el aire es
lo que usamos cuando necesitamos hacer
simulaciones de nuestra cuántica
circuitos en nuestra computadora local.
Entonces el simulador se puede importar desde el aire
haciendo air.get_backend,
y el nombre de la
simulador es el simulador QASM.
Si tienes curiosidad, el nombre QASM
proviene del lenguaje ensamblador cuántico.
Ok, ahora que hemos
importado nuestro simulador
Es hora de ejecutar el circuito.
Entonces, lo que haré es ejecutar la llamada.
Lo que estoy haciendo es ejecutar
el circuito que he construido

Japanese: 
次のステップは、回路を実行させることで、
2つのことをします。
一つ目は、この量子回路を
自分の古典コンピューターの上で実行させ、
ここで量子コンピューターをシミュレートした時に
何が起こるか見ます。
次に、
量子回路に確信を持てたら、
IBMにある実デバイスにそれを送って
実際のデバイス上でこの量子回路を動かした時の
結果を見てみます。
回路をシミュレートするためには、
QiskitのAerコンポーネントを使います。
あなたのローカルコンピューターで量子回路の
シミュレーションを行うとき
使用するのは、Aerです。
Aerからシミュレーターをインポートします。
Aer.get_backend()で
シミュレーターの名前をqasm_simulatorにします。
興味のある方向けですが、QASMという名前は、
Quantum Assembly言語が由来です。
OK。シミュレーターをインポートできたので、
回路を実行する時が来ました。
executeを実行します。
これまでに構築した回路をexecuteします。

Korean: 
다음 단계는 회로를 실행하는 것입니다.
저는 두 가지를 할 텐데요
가장 먼저, 저는 이 양자 회로를
제 고전 컴퓨터에서 실행하고
양자 컴퓨터에서 시뮬레이션 할 때
어떤 일이 일어나는 지를 볼 겁니다.
그리고 제가... 하나 확신하는 것은
이 양자 회로를
IBM의 실제 디바이스로 전달할 것입니다.
그런 다음 실제 디바이스에서
양자회로를 실행하여 나온 결과를 볼 겁니다.
그래서 회로를 시뮬레이션하기 위해서
제가 할 것은, Qiskit의 구성요소인
Aer를 사용하는 것입니다.
Aer의 아이디어는
우리가 필요하면 사용하는 Air(공기)처럼
우리의 컴퓨터에서 양자회로를
시뮬레이션 할 필요가 있을 때 사용하는 것입니다.
이 시뮬레이터는 Aer에서 가져올 수 있습니다
simulator = Aer.get_backend()
그리고 이 시뮬레이터의 이름은 'qasm_simulator'입니다.
궁금하시다면, QASM이라는 이름은
양자 어셈블리어에서 비롯됩니다.
(Quantum ASseMbly language)
좋아요, 이제 우리는
시뮬레이터를 가져 왔습니다
이제 회로를 실행할 차례입니다.
이제 제가 할 것은 execute()문을 불러오는 것 입니다.
제가 만든 회로를 실행할 것입니다.
(각주; ( )안에 circuit 입력하고)

Russian: 
Итак, следующий шаг - запустить схему,
и я собираюсь сделать две вещи.
Первое, что я собираюсь
сделать это запустить эту квантовую схему
на моем классическом компьютере
и посмотрим что получится
когда я симулирую квантовый компьютер здесь.
А потом, когда я, когда-то я уверен,
с квантовой схемой,
что я собираюсь сделать, это
отправить его на реальное устройство в IBM
а затем увидеть результаты, которые выходят из
работает этот квант
схема на реальном устройстве.
Итак, чтобы смоделировать схему,
что я собираюсь сделать, это использовать
воздушная составляющая Qiskit.
Идея в том, что воздух
что мы используем, когда нам нужно сделать
моделирование нашего кванта
схемы на нашем локальном компьютере.
Так что симулятор можно импортировать из воздуха
делая air.get_backend,
и имя
симулятор симулятор QASM.
Если вам интересно, название QASM
происходит от квантового языка ассемблера.
Хорошо, теперь, когда мы
импортировал наш симулятор
пришло время выполнить схему.
Итак, что я сделаю, так это вызову execute.
То, что я делаю, выполняет
схема, которую я построил

Korean: 
그리고 백엔드(backend)로
사용할 시뮬레이터를 입력할 겁니다.
그래서 백엔드는
제가 import한 simulator입니다.
다 됐어요.
이제 우리는 양자 회로를 처리했습니다.
문제는 그 실행으로부터
어떤 결과들이 나왔는가 하는 것입니다.
이미 우리는 양자회로를 실행하였습니다.
execute한 결과로 돌아가서 뒤에 .result를 붙이고
result 라고 부르는 변수에 할당합니다.
그래서 이제, result 변수는
회로에서 실행되어 나온 결과를 정보로 가집니다.
그럼, 결과에 어떤 내용이 있는지 살펴보겠습니다.
그래서 그렇게 하기위해서 저는
Qiskit에서  시각화 도구(visualization tools)를
 가져올 겁니다.
그래서 제가 하려는 것은
from qiskit.tools.visualization import plot_histogram
이 plot_histogram 함수를 Qiskit에서 가져온 후

Spanish: 
hasta ahora y lo que voy a usar
es el simulador como backend.
Entonces el backend en el que estoy
ejecutar es el simulador
que he importado, y eso es todo.
Entonces ahora que hemos ejecutado
nuestro circuito cuántico,
la pregunta es cuales son los resultados
que salió de esa ejecución.
Una vez que hayamos ejecutado nuestro circuito cuántico,
vamos a obtener los resultados
de vuelta haciendo .result
y asignarlos a un
variable llamada resultado.
Entonces ahora la variable resultado
contiene la información
que volvió de
ejecutando ese circuito.
Veamos qué resultado contiene.
Entonces, para hacer eso, lo que voy a hacer
es importar herramientas de visualización de Qiskit.
Entonces, lo que voy a hacer es de
qiskit.tools.visualization
importar plot_histogram.
Una vez que tenga esta trama
función de histograma importada

Russian: 
до сих пор и что я буду использовать
это симулятор в качестве бэкэнда.
Так что бэкэнд, на котором я
выполнение симулятор
что я импортировал, и все тут.
Итак, теперь, когда мы выполнили
наша квантовая схема,
вопрос в том, каковы результаты
что вышло из этой казни.
Как только мы выполнили нашу квантовую схему,
давайте получим результаты
вернуться, делая .result
и назначить их
переменная называется результатом.
Итак, теперь переменная результата
содержит информацию
который вернулся из
выполнение этой схемы.
Давайте посмотрим, что содержит сам результат.
Так что делать то, что я собираюсь сделать
импорт инструментов визуализации из Qiskit.
Так что я собираюсь сделать из
qiskit.tools.visualization
импорт plot_histogram.
Однажды у меня есть этот сюжет
импортированная функция гистограммы

English: 
so far and what I'll be using
is the simulator as a backend.
So the backend on which I'm
executing is the simulator
that I've imported, and that's it.
So now that we've executed
our quantum circuit,
the question is what are the results
that came out of that execution.
Once we've executed our quantum circuit,
let's get the results
back by doing .result
and assign them to a
variable called result.
So now the result variable
holds the information
that came back from
executing that circuit.
Let's look at what result itself contains.
So to do that what I'm going to do
is import visualization tools from Qiskit.
So what I'm going to do is from
qiskit.tools.visualization
import plot_histogram.
Once I have this plot
histogram function imported

Japanese: 
バックエンドとしてシミュレーターを使います。
実行するバックエンドは
インポートしたシミュレーターを指定して
このようにします。できました。
これで、量子回路を実行しました。
この実行によって何が結果として
出力されるでしょうか。
量子回路を実行したら、
.resultをつけて結果をもらいましょう。
result変数に結果を入れます。
これで、result 変数には、
回路の実行から返された情報が
保持されます。
結果自体に含まれるものを見てみましょう。
これをするために、
Qiskitから描画ツールをインポートします。
つまり、
from qiskit.tools.visualization
import plot_histogram とします。
このヒストグラムをプロットする機能を

Russian: 
из Qiskit, что я собираюсь
сделать, это взять этот результат,
позвоните .get_counts
и пройти в нашей схеме.
И вот оно; это результат
выполнения нашей квантовой схемы.
Итак, как вы можете видеть, мы получаем примерно 50%
или с вероятностью 0,5, ноль ноль.
И с почти 0,5 вероятности, один.
Итак, эти маленькие ошибки
потому что мы бежим
ограниченное количество
кадры на нашей симуляции
вместо бесконечного количества выстрелов.
Теперь, когда мы уверены
что делает наша схема
что мы ожидаем, давайте работать
это на квантовом компьютере
в IBM и посмотрим, что произойдет.
Так в предыдущем
видео, которое вы узнали, как
взять свой токен API от
квантовый опыт IBM
и сохранить его на свой
компьютер, чтобы вы могли
получить доступ к квантовым устройствам IBM.
Итак, давайте загрузим наш аккаунт здесь.
Итак, я собираюсь написать
из IBMQ.load_account.
Итак, как только наша учетная запись загружена,

Japanese: 
Qiskitからインポートしたら、結果を得るために
result.get_counts で
回路を代入します。
結果がでました。
量子回路を実行した結果です。
ご覧のように、およそ50%または
0.5の確率で00を、そして
ほぼ0.5の確率で11を得ました。
この小さなエラーの原因は、
シミュレーションで有限のショット数を
実行したためです。
無限のショット数の代わりに。
さて、我々の回路が期待通りに
動く確信が持てたので、
IBMにある量子コンピューターで実行して
何が起こるか見てみましょう。
前回のビデオで、
APIトークンをIBM Quantum Experienceから
取ってきて、
あなたのコンピューターに保存する方法を
学んだので、
IBMの量子デバイスにアクセスできますね。
では、ここでアカウントをロードしましょう。
IBMQ.load_account() と書きます。
OK。アカウントがロードされたら、

English: 
from Qiskit, what I'm going
to do is take that result,
call .get_counts
and pass in our circuit.
And there it is; that's the result
of executing our quantum circuit.
So as you can see, we get roughly 50%
or with 0.5 probability, zero zero.
And with almost 0.5 probability, one one.
So these small errors
are because we're running
a limited number of
shots on our simulation
instead of an infinite number of shots.
Now that we're confident
that our circuit is doing
what we expect, let's run
it on a quantum computer
at IBM and see what happens.
So in the previous
video you learned how to
take your API token from
the IBM quantum experience
and save it on your
computer so that you can
access IBM's quantum devices.
So let's load our account here.
So I'm going to write
out IBMQ.load_account.
Okay, so once our account is loaded,

Korean: 
제가 하려는 것은
result.
result.get_counts()를 호출하는 것입니다.
인수로 circuit을 입력하고
실행하면;
저것이 바로 우리의 양자회로의 실행 결과입니다.
여러분들이 보시다시피, 대략 50 %
또는 0.5의 확률로 00 state가 됩니다.
그리고 거의 0.5의 확률로 11 state가 됩니다.
이 작은 오류들은 우리가 실행할 때
무한한 수의 시도 대신에
제한된 수의 시도를 시뮬레이션 했기 때문입니다.
이제 우리 회로가 기대한 대로 작동하고 있다고
확신하게 되었으니,
IBM의 양자 컴퓨터에서 실행하고
어떤 일이 일어나는지 봅시다.
그래서 이전의 비디오에서
여러분은 IBM Q Experience에서
API Token을 가져오는 것과
그리고 여러분의 컴퓨터에
그것들을 저장하여
IBM의 양자 디바이스에 액세스하는 것을 배웠습니다.
그래서 여기에 계정을 불러오겠습니다.
코드를 작성하겠습니다.
IBMQ.load_account()
네. 일단 계정이 로드되면

Spanish: 
de Qiskit, a lo que voy
hacer es tomar ese resultado,
llame a .get_counts
y pasa en nuestro circuito.
Y ahí está; ese es el resultado
de ejecutar nuestro circuito cuántico.
Como puede ver, obtenemos aproximadamente el 50%
o con 0.5 probabilidad, cero cero.
Y con casi 0.5 de probabilidad, uno.
Entonces estos pequeños errores
son porque estamos corriendo
un número limitado de
disparos en nuestra simulación
en lugar de un número infinito de disparos.
Ahora que tenemos confianza
que nuestro circuito está haciendo
lo que esperamos, corramos
en una computadora cuántica
en IBM y ver qué pasa.
Entonces en el anterior
video que aprendiste a
toma tu token API de
la experiencia cuántica de IBM
y guárdalo en tu
computadora para que puedas
acceder a los dispositivos cuánticos de IBM.
Así que carguemos nuestra cuenta aquí.
Entonces voy a escribir
fuera IBMQ.load_account.
Bien, una vez que se cargue nuestra cuenta,

Korean: 
우리는 코드를 실행할 디바이스를 선택할 준비가 되었고
결과를 얻을 수 있습니다.
계정을 로드하면
provider = IBMQ.get_provider()를 작성하고,
( )안에는 'ibm-q'를 입력하고 Shift+Enter를 누르세요.
그리고 나서 qcom =
qcom = provider.get_backend() 입니다.
( )에는 디바이스의 이름을 입력할 건데
IBMQ_16_melbourne을 입력합니다.
이것은 그냥 우리의 디바이스의 이름입니다.(코드명)
장치는 실제로 맬버른의 어디에도 위칳ㅎ하지 않습니다
그리고 job =
우리가 만든 회로를
job = execute(citcuit, )
qcomp라 불리는 백엔드에서 실행
job = execute(circuit, backend = qcomp)
여기 띄어쓰기를 지우겠습니다
그리고 circuit의 오탈자를 바꾸고
이제 할 것은....

English: 
we're ready to choose the device on which
to run our code and then
to continue to get results.
So once I've loaded my account,
I am going to say provider is
equal to IBMQ.get_provider.
And I'm going to say the provider
is IBM-Q, hit Shift Enter,
and then I'm going to
say the quantum computer
with which we're working
is provider.get_backend.
The name of that particular device
we'll be working with
is IBMQ_16_melbourne.
This is just what we name our devices.
The device isn't actually
located anywhere in Melbourne.
We're going to say the job is
execute the circuit that we've built
on the backend, which is called qcomp.
We're going to remove these spaces
and spell circuit properly
and then I am going to say

Japanese: 
デバイスを選択することができます。
コードを実行し、結果を得るためのデバイスです。
私は、自分のアカウントをロードしているので、
provider = IBMQ.get_provider()として、
プロバイダーを'ibm-q'として、
シフト＋エンターを押します。
そして、作業する量子コンピューターとして
qcomp = provider.get_backend()として、
作業する特定のデバイスの名前、
IBMQ_16_melbourne を入れます。
これは我々のデバイスの名前であって、
このデバイスは、実際のメルボルンにはありません。
job = execute()に
構築したcircuitを入れ、
backendとしてqcompを入れます。
スペースを削除して
circuitのスペルを正して、

Russian: 
мы готовы выбрать устройство, на котором
запустить наш код, а затем
продолжать получать результаты.
Итак, как только я загрузил свой аккаунт,
Я собираюсь сказать, что поставщик
равно IBMQ.get_provider.
И я собираюсь сказать, провайдер
это IBM-Q, нажмите Shift Enter,
а потом я собираюсь
скажем квантовый компьютер
с которым мы работаем
является Provider.get_backend.
Название этого конкретного устройства
мы будем работать с
это IBMQ_16_melbourne.
Это то, что мы называем нашими устройствами.
Устройство на самом деле не
расположен в любом месте в Мельбурне.
Мы собираемся сказать, что работа
выполнить схему, которую мы построили
на бэкэнде, который называется qcomp.
Мы собираемся удалить эти пробелы
и схема заклинания правильно
а потом я собираюсь сказать

Spanish: 
estamos listos para elegir el dispositivo en el que
para ejecutar nuestro código y luego
para seguir obteniendo resultados.
Entonces, una vez que haya cargado mi cuenta,
Voy a decir que el proveedor es
igual a IBMQ.get_provider.
Y voy a decir el proveedor
es IBM-Q, presione Shift Enter,
y luego voy a
dice la computadora cuántica
con el que estamos trabajando
es provider.get_backend.
El nombre de ese dispositivo en particular.
estaremos trabajando con
es IBMQ_16_melbourne.
Esto es justo lo que llamamos nuestros dispositivos.
El dispositivo no es realmente
ubicado en cualquier lugar de Melbourne.
Vamos a decir que el trabajo es
ejecutar el circuito que hemos construido
en el backend, que se llama qcomp.
Vamos a eliminar estos espacios
y deletrear circuito correctamente
y luego voy a decir

Japanese: 
from qiskit.tools.monitor
import job_monitorと入れます。
このjobが実際のデバイスにサブミットされたら
これらのデバイスはパブリックデバイスなので、
順番待ちがあります。
ですので、job monitorが
開始した現在のjobの引数を取得して、
jobがキューに追加されたことがわかります。
実際には、キューの2番目のjobです。
その時の量子デバイスの混雑状況によっては、
jobに数分かかる場合があります。
job has successfully run のメッセージが出たら
result = job.result()と入れます。
次に結果をプロットするために
plot_histogram()で
result.get_count()に
circuitを引数として入れます。
この結果と

Russian: 
от qiskit.tools.monitor
импорт job_monitor.
Итак, идея в том, что
эти вакансии представлены
к реальным устройствам и потому, что они
общедоступные устройства, есть очередь.
Так что работа монитора позволяет
мне сказать job_monitor
принимая в аргументе
текущая работа, которую мы начали,
и мы видим, что работа сейчас стоит в очереди.
И, по сути, это работа
номер два в очереди.
В зависимости от того, насколько занят
квантовые устройства в то время,
работа может занять несколько минут.
И как только вы получите это сообщение, что работа
успешно запущен, вы
Можно сказать, что результат - job.result.
Далее мы наметим результат, сказав
plot_histogram
результата.got_count
и я пройду в
Схема в качестве аргумента.
Итак, глядя на эти результаты, давайте сравним

English: 
from qiskit.tools.monitor
import job_monitor.
So the idea here is that
these jobs are submitted
to the real devices and because they're
public devices, there's a queue.
So the job monitor allows
me to say job_monitor
taking in the argument of the
current job that we started,
and we see that the job is queued now.
And, in fact, it's job
number two in the queue.
Depending on how busy the
quantum devices are at the time,
the job might take a few minutes.
And once you get this message that the job
has successfully run, you
can say result is job.result.
Next we'll plot the result by saying
plot_histogram
of the result.got_count
and I'll pass in the
circuit as an argument.
So looking at these results, let's compare

Korean: 
qiskit.tools.monitor 에서
job_monitor 모듈을 가져오겠습니다.
여기서의 컨셉은, 이 job 들은 실제 device에 제출됩니다
이 장치들은 공용 장치이기 때문에,
대기열이 있습니다.
그래서 job_monitor는
현재 시작하려는 job을 인수로 가지고
(Shift+Enter)
이제 job이 대기열에 걸린 걸 볼 수 있습니다.
그리고, job은 대기열의 2번째에 있습니다.
job을 할 때, 양자 장치가 얼마나 바쁜지에 따라
몇 분이 걸릴 수도 있습니다.
그리고 이 메시지를 받으면
(Job Status: job has successfully run)
job이 성공적으로 실행되었고,
result 는  job.result() 이 됩니다.
다음은 plot_histogram으로 result를 plot 할 겁니다
plot_histogram(
result.get_counts를 전달인자로
plot_histogram(result.get_counts(
plot_histogram(result.get_counts(circuit))
그러면 이 결과들을 보고, 비교해봅시다.

Spanish: 
de qiskit.tools.monitor
import job_monitor.
Entonces la idea aquí es que
estos trabajos son enviados
a los dispositivos reales y porque son
dispositivos públicos, hay una cola.
Entonces el monitor de trabajo permite
yo decir job_monitor
tomando en el argumento de la
trabajo actual que comenzamos,
y vemos que el trabajo está en cola ahora.
Y, de hecho, es trabajo
número dos en la cola.
Dependiendo de qué tan ocupado el
los dispositivos cuánticos están en ese momento,
el trabajo puede demorar unos minutos.
Y una vez que recibes este mensaje de que el trabajo
se ha ejecutado con éxito, usted
puede decir que el resultado es job.result.
A continuación, trazaremos el resultado diciendo
plot_histogram
del resultado.got_count
y voy a pasar en el
circuito como argumento.
Mirando estos resultados, comparemos

Japanese: 
シミュレーターの結果と比較してみましょう。
二つの間の違いは、
シミュレーターの場合は、00と11のみの結果ですが、
実際の量子デバイスでコードを実行した際は、
小さい数で結果として
01と10も現れるということです。
結果の大部分は
00と11の状態ですが。
なぜこれが起こるか少し考えてみましょう。
シミュレーションと
実際の量子デバイスで実行した場合の違いは
シミュレーターは完璧な量子デバイスをシミュレートすることです。
一方、実際の量子デバイスは、
小さな量子エラーの影響を受けやすいのです。
この量子エラーは、日々、改善されています。
技術の向上に伴って。
そのため、これらのエラーのカウントが
どんどん低くなり、
結果が理想的なシミュレーションに
ますます近づくことが予想されます。
しかし、ご覧の通り
現在のところ、デバイスは完璧ではないので、
結果に違いが見られます。
我々のノートパソコンでシミュレートした

English: 
how they look against what
we saw with a simulator.
So you see the difference
between the two is that
in a simulated case, you only
got zero zero and one one,
but when the code was run
on a real quantum device,
we also had a small number of results
showing up in zero one and one zero.
Even though the majority
of results are still
at the zero zero state
and the one one state.
So let's think a little
bit about why that happens.
The difference between the
simulated case and the code
that was run on the real quantum device
is that the simulator simulates
a perfect quantum device.
In the meantime, the real quantum device
is susceptible to small quantum errors.
These quantum errors are
getting improved every day
as a result of the technology improving.
So we expect to see these
counts getting lower
and lower and the results getting closer
and closer to the ideal simulations.
However, as you can see here,
the devices are not perfect today,
and that is why you see
a difference in results,
a small change from what you see

Russian: 
как они выглядят против чего
мы видели с симулятором.
Итак, вы видите разницу
между двумя является то, что
в смоделированном случае вы только
получил ноль ноль и один,
но когда код был запущен
на реальном квантовом устройстве,
у нас также было небольшое количество результатов
показывая в ноль один и один ноль.
Хотя большинство
результатов все еще
в состоянии ноль ноль
и единый штат.
Итак, давайте немного подумаем
Немного о том, почему это происходит.
Разница между
смоделированный случай и код
который был запущен на реальном квантовом устройстве
в том, что симулятор имитирует
идеальное квантовое устройство.
А пока настоящий квантовый прибор
подвержен малым квантовым ошибкам.
Эти квантовые ошибки
улучшается каждый день
в результате совершенствования технологии.
Итак, мы ожидаем увидеть эти
рассчитывает становится ниже
и ниже, и результаты становятся ближе
и ближе к идеальному моделированию.
Однако, как вы можете видеть здесь,
устройства не идеальны сегодня,
и вот почему вы видите
разница в результатах,
небольшое изменение от того, что вы видите

Spanish: 
cómo se ven contra qué
Vimos con un simulador.
Entonces ves la diferencia
entre los dos es que
en un caso simulado, solo tú
tengo cero cero y uno uno
pero cuando se ejecutó el código
en un dispositivo cuántico real,
también tuvimos un pequeño número de resultados
apareciendo en cero uno y uno cero.
Aunque la mayoría
de resultados todavía
en el estado cero cero
y el un estado.
Así que pensemos un poco
poco sobre por qué sucede eso.
La diferencia entre el
caso simulado y el código
que se ejecutó en el dispositivo cuántico real
es que el simulador simula
Un dispositivo cuántico perfecto.
Mientras tanto, el dispositivo cuántico real
es susceptible a pequeños errores cuánticos.
Estos errores cuánticos son
mejorando todos los días
Como resultado de la mejora de la tecnología.
Así que esperamos ver estos
cuenta cada vez más bajo
y baja y los resultados se acercan
y más cerca de las simulaciones ideales.
Sin embargo, como puedes ver aquí,
los dispositivos no son perfectos hoy,
y es por eso que ves
una diferencia en resultados,
un pequeño cambio de lo que ves

Korean: 
시뮬레이터로 본 것과 비교해서 어떻게 보이시나요
두 개 사이에 차이점이 보입니다.
시뮬레이션의 경우, 00과 11 상태만 있습니다.
그러나 이 코드가 실제 양자 디바이스에서 실행될 때,
01과 10으로 표시된
적은 수의 결과들도 있습니다.
그럴지라도, 00 state와 11 state는
주된 결과입니다.
왜 이런 결과가 되었는지 조금 생각해봅시다.
시뮬레이션한 케이스와 실제 양자 디바이스에서
실행된 것의 차이는
시뮬레이터는 완벽한 양자 디바이스로
시뮬레이션 한다는 것입니다.
한편, 실제 양자 장치는
작은 양자 에러들에 민감하다는 것입니다.
이 양자 오류들은 양자 기술 향상의 결과로
매일 개선되고 있습니다.
그래서 저희는 이 수치들이 점점 낮아지고
결과가 이상적인 시뮬레이션에 가까워지기를
기대하고 있습니다.
그러나, 여러분들이 보시는 것처럼
오늘날의 장치는 완벽하지 않습니다.
그게 바로, 여러분의 노트북에서 시뮬레이션한
완벽한 양자 컴퓨터와의 작은 변화인

Russian: 
с идеальным квантом
компьютер моделируется на нашем ноутбуке.
Так что у вас есть это.
Мы прошли от начала до конца
в создании нашего первого кванта
Приложение Hello World.
Так что теперь вопрос становится
куда мы идем отсюда?
Хотите увидеть больше
сосредоточиться на квантовых играх,
квантовые приложения,
сами устройства?
Хотите узнать больше о
как эти приложения приходят в промышленность?
Куда мы отправимся отсюда?
Дайте нам знать в комментариях внизу,
и мы увидимся в следующем видео.
(веселая музыка)

Spanish: 
con el cuanto perfecto
computadora simulada en nuestra computadora portátil.
Entonces ahí lo tienes.
Hemos ido de principio a fin
en la creación de nuestro primer cuanto
Hola aplicación mundial.
Entonces ahora la pregunta se convierte
¿A dónde vamos desde aquí?
Te gustaria ver mas
centrarse en juegos cuánticos,
aplicaciones cuánticas,
los dispositivos mismos?
¿Quieres saber más sobre
¿Cómo vienen estas aplicaciones en la industria?
¿A dónde vamos desde aquí?
Háganos saber en los comentarios a continuación,
y nos vemos en el próximo video.
(música funky)

Japanese: 
完璧な量子コンピューターとの間に
少し違いが見られます。
これが得られた結果です。
私たちは、最初の量子Hello World
アプリケーションの作成を
初めから最後まで行ってきました。
次は、ここからどこに進みますか？
あなたは量子ゲームにフォーカスしたいですか？
それとも量子アプリケーション、またはデバイス？
これらのアプリケーションがどのように
業界で活用できるについて詳しく知りたいですか？
どこに進みますか？
下にぜひコメントを残してください。
そしてまた次のビデオでお会いしましょう。
(音楽)

English: 
with the perfect quantum
computer simulated on our laptop.
So there you have it.
We've gone from start to finish
in creating our first quantum
Hello World application.
So now the question becomes
where do we go from here?
Would you like to see more
focus on quantum games,
quantum applications,
the devices themselves?
Would you like to learn more about
how these applications come in industry?
Where do we go from here?
Let us know in the comments down below,
and we'll see you in the next video.
(funky music)

Korean: 
결과의 차이를 발견하는 이유 입니다.
여러분은 이제 알고있습니다.
우리는 첫번째 Hello World 양자 애플리케이션을
만들기 위해서 처음부터 끝까지 진행했습니다.
그래서 이제... 여기서 어디로 가야할까요?
양자 게임, 양자 애플리케이션, 장치 자체에
더 알아보고 싶으십니까?
이러한 응용 프로그램들이
어떻게 업계에 제공되는지에 대해 알고 싶으신가요?
어디로 가면 좋을까요?
아래에 댓글을 남겨주세요
다음 비디오에서 뵙겠습니다.
backend_overview()
