Q 샤프

1. 개요

Q#은 마이크로소프트에서 개발한 양자 컴퓨터를 위한 프로그래밍 언어이다. 2017년 Quantum Development Kit의 일부로 처음 출시되었으며, 양자 알고리즘을 구현하고 큐비트를 생성 및 사용할 수 있는 기능을 제공한다. Q#은 큐비트 연산, 양자 시뮬레이터, .NET 언어와의 상호 운용성을 지원하며, 코드 격리를 위해 `namespace`를 사용하고 C# 및 F#과 유사한 구문을 갖는다. 마이크로소프트는 Q# 개발을 위해 QIR (Quantum Intermediate Representation)을 개발하고 Quantum Development Kit를 오픈 소스로 공개했다.

2. 역사

마이크로소프트는 자사의 양자 컴퓨팅 연구를 기반으로 Q#를 개발했다. 초기 마이크로소프트 리서치 내에는 양자 회로 구성을 연구하는 QuArC 팀과 위상 양자 컴퓨팅을 연구하는 Station Q 팀이 있었다.

2017년 9월 26일, 마이크로소프트 이그나이트 행사에서 양자 컴퓨터용 새 프로그래밍 언어 출시 계획이 발표되었고, 같은 해 12월 11일, 마이크로소프트는 Quantum Development Kit의 일부로 Q#을 정식 출시했다.

이후 빌드 2019에서는 Q# 컴파일러 및 시뮬레이터를 포함한 Quantum Development Kit 전체를 오픈 소스로 공개한다고 발표하며 기술 접근성을 높였다. 2023년에는 Q#과 양자 프로세서 간의 공통 인터페이스 역할을 하는 Quantum Intermediate Representation (QIR)을 개발하고, Q# 코드를 QIR로 변환하는 컴파일러 확장 기능도 함께 발표했다.

Q#은 C#과 같은 다른 범용 프로그래밍 언어에서 호출되도록 설계된 도메인 특화 언어이다. 현재 Q# 언어 개발은 베티나 하임이 이끌고 있다.

2.1. 마이크로소프트의 양자 컴퓨팅 연구

역사적으로 마이크로소프트 리서치는 양자 컴퓨팅에 관심을 가진 두 개의 팀을 운영했다. 하나는 워싱턴 주 레드먼드에 위치한 QuArC 팀으로, 크리스타 스보레가 이끌며 양자 회로 구성을 연구했다. 다른 하나는 산타바바라에 처음 위치했던 Station Q로, 마이클 프리드먼의 주도 하에 위상 양자 컴퓨팅을 연구했다.

2017년 9월 26일, 마이크로소프트 이그나이트 기조 연설에서 마이크로소프트는 양자 컴퓨터를 위해 특별히 설계된 새로운 프로그래밍 언어 출시 계획을 발표했다. 이후 2017년 12월 11일, 마이크로소프트는 Quantum Development Kit의 일부로 Q#을 정식 출시했다.

빌드 2019 행사에서는 Q# 컴파일러 및 시뮬레이터를 포함한 Quantum Development Kit 전체를 오픈 소스로 공개할 것이라고 발표하며 기술 개방성을 강조했다.

Q# 지원을 강화하기 위해 마이크로소프트는 2023년에 프로그래밍 언어와 대상 양자 프로세서 간의 공통 인터페이스 역할을 하는 Quantum Intermediate Representation (QIR)을 개발했다. 또한, Q#에서 QIR을 생성하는 컴파일러 확장 기능도 함께 발표했다.

현재 Q# 언어 개발은 베티나 하임이 이끌고 있다.

2.2. Q# 출시 및 오픈 소스화

2017년 9월 26일, 마이크로소프트 이그나이트 기조 연설에서 마이크로소프트는 양자 컴퓨터를 위해 특별히 설계된 새로운 프로그래밍 언어를 출시할 것이라고 발표했다. 이후 2017년 12월 11일, 마이크로소프트는 Quantum Development Kit의 일부로 Q#을 출시했다.

빌드 2019에서 마이크로소프트는 Q# 컴파일러 및 시뮬레이터를 포함하여 Quantum Development Kit를 오픈 소스로 공개할 것이라고 발표했다.

2.3. QIR (Quantum Intermediate Representation) 개발

Q#을 지원하기 위해 마이크로소프트는 2023년에 프로그래밍 언어와 대상 양자 프로세서 간의 공통 인터페이스로 Quantum Intermediate Representation (QIR)을 개발했다. 또한 회사는 Q#에서 QIR을 생성하는 컴파일러 확장을 발표했다.

2.4. Q# 언어 개발 노력

역사적으로 마이크로소프트 리서치는 양자 컴퓨팅에 관심을 가진 두 개의 팀을 운영했다. 하나는 워싱턴 주 레드먼드에 위치한 QuArC 팀으로, 크리스타 스보레가 이끌며 양자 회로 구성을 연구했다. 다른 하나는 초기에 산타바바라에 위치했던 Station Q로, 마이클 프리드먼이 이끌며 위상 양자 컴퓨팅을 연구했다.

2017년 9월 26일, 마이크로소프트 이그나이트 기조 연설에서 마이크로소프트는 양자 컴퓨터를 위해 특별히 설계된 새로운 프로그래밍 언어 출시 계획을 발표했다. 이후 2017년 12월 11일, 마이크로소프트는 Quantum Development Kit의 일부로 Q#을 공식 출시했다.

빌드 2019 행사에서는 Q# 컴파일러 및 시뮬레이터를 포함한 Quantum Development Kit를 오픈 소스로 공개한다고 발표하며 개발 생태계 확장에 기여했다.

Q#을 더욱 효과적으로 지원하기 위해, 마이크로소프트는 2023년에 프로그래밍 언어와 대상 양자 프로세서 간의 공통 인터페이스 역할을 하는 Quantum Intermediate Representation (QIR)을 개발했다. 또한 Q# 코드를 QIR로 변환하는 컴파일러 확장 기능도 함께 발표했다.

현재 Q# 언어 개발은 베티나 하임이 주도하고 있다.

3. 특징

Q#은 마이크로소프트가 양자 컴퓨팅 알고리즘을 위해 개발한 도메인 특화 언어이다. 2017년 12월, Quantum Development Kit (QDK)의 프리뷰 버전과 함께 처음 공개되었다.

주요 특징은 알고리즘 구현을 위해 큐비트를 생성하고 사용할 수 있다는 점이다. 이를 통해 얽힘이나 중첩과 같은 양자 현상을 다루는 연산을 수행할 수 있다. Q#은 C#과 같은 다른 범용 프로그래밍 언어에서 호출되도록 설계되었지만, 자체적으로도 기본적인 제어 구문과 데이터 형식을 갖추고 있다.

향후 Q#과 함께 제공될 하드웨어 스택은 큐비트를 토폴로지 큐비트로 구현할 것으로 예상된다.

3.1. 큐비트 연산

Q#의 주요 특징은 알고리즘 구현을 위해 큐비트를 생성하고 사용할 수 있다는 점이다. 결과적으로 Q#은 얽힘 상태를 만들기 위해 제어 NOT 게이트를 사용하고, 중첩 상태를 구현하기 위해 Hadamard 게이트를 사용하는 기능을 핵심적으로 제공한다. 또한 토폴리 게이트, 파울리 X, Y, Z 게이트를 포함한 다양한 양자 논리 게이트들을 여러 연산에 활용할 수 있다. 사용 가능한 게이트의 전체 목록은 양자 논리 게이트 문서에서 확인할 수 있다.

3.2. 양자 시뮬레이터

퀀텀 개발 키트에는 Q#을 실행하고 30개의 논리적인 큐비트를 시뮬레이션할 수 있는 양자 시뮬레이터가 포함되어 있다. 양자 시뮬레이터를 호출하기 위해서는 일반적으로 C#과 같은 다른 .NET 프로그래밍 언어가 사용된다. 이 언어는 시뮬레이터에 대한 고전적인 입력 데이터를 제공하고 시뮬레이터로부터 고전적인 출력 데이터를 읽는 역할을 한다.

3.3. .NET 언어와의 상호 운용성

Q#은 C#과 같은 다른 범용 프로그래밍 언어에서 호출되도록 설계된 도메인 특화 언어이다. 양자 시뮬레이터를 호출하기 위해서는 일반적으로 C#과 같은 다른 .NET 프로그래밍 언어가 사용된다. 이 .NET 언어는 Q# 시뮬레이터에 (고전적인) 입력 데이터를 제공하고, 시뮬레이터로부터 (고전적인) 출력 데이터를 읽는 역할을 수행한다.

4. 사용법

(내용 없음)

4.1. 개발 환경

Q#은 비주얼 스튜디오에서 별도로 다운로드하여 사용할 수 있는 확장 기능으로 제공된다. 또한, 명령줄 또는 비주얼 스튜디오 코드에서 독립적인 도구로 실행할 수도 있다. Q#은 윈도우에서 처음 소개되었으며, macOS 및 리눅스에서도 사용할 수 있다.

퀀텀 개발 키트(Quantum Development Kit, QDK)에는 Q#을 실행하고 30개의 논리적인 큐비트를 시뮬레이션할 수 있는 양자 시뮬레이터가 포함되어 있다.

양자 시뮬레이터를 호출하기 위해서는 일반적으로 C#과 같은 다른 .NET 프로그래밍 언어가 사용된다. 이 언어는 시뮬레이터에 대한 (고전적인) 입력 데이터를 제공하고 시뮬레이터로부터 (고전적인) 출력 데이터를 읽는 역할을 한다.

5. 구문

Q#은 C#과 F#과 구문론적으로 관련이 있지만, 몇 가지 중요한 차이점도 가지고 있다. 2017년 12월 마이크로소프트에서 공개한 Quantum Development Kit (QDK)의 프리뷰 버전과 함께 발표되었다.

Q#은 C#과 같은 다른 범용 프로그래밍 언어에서 호출되도록 설계된 도메인 특화 언어이지만, 그 자체로도 범용 프로그래밍 언어에서 사용되는 몇 가지 제어 구문과 데이터 형식을 갖추고 있다. C# 및 F#과의 구체적인 유사점과 차이점은 하위 섹션에서 자세히 다룬다.

5.1. C#과의 유사점

* 코드 격리를 위해 `namespace`를 사용한다.
* 모든 구문은 세미콜론(`;`)으로 끝난다.
* 중괄호(`{}`)는 코드 블록의 범위를 지정하는 데 사용된다.
* 단일 행 주석은 `//`를 사용하여 작성한다.
* `Int`, `Double`, `String`, `Bool`과 같은 변수 데이터 형식은 C#과 유사하지만, Q#에서는 첫 글자를 대문자로 사용한다. 특히 `Int`는 64비트 정수를 나타낸다.
* 큐비트는 `using` 블록 내부에서 할당하고 해제한다.
* 람다 함수는 `=>` 연산자를 사용하여 정의한다.
* 함수나 연산의 결과는 `return` 키워드를 사용하여 반환한다.

5.2. F#과의 유사점

* 변수는 let 또는 mutable을 사용하여 선언된다.
* 일급 함수를 지원한다.
* open 키워드를 사용하여 모듈을 가져온다.
* 데이터 형식은 변수 이름 뒤에 선언된다.
* 범위 연산자로 ..를 사용한다.
* for … in 형태의 루프를 사용한다.
* 모든 연산이나 함수는 void 대신 반환 값을 가진다. 반환 값이 없는 경우 빈 튜플 ()이 반환된다.
* 레코드 데이터 형식을 정의할 때 type 대신 newtype 키워드를 사용한다.

5.3. 차이점

* 함수는 `function` 키워드를 사용하여 선언한다.
* 양자 컴퓨터에 대한 연산은 `operation` 키워드를 사용하여 선언한다.
* 여러 줄 주석이 없다.
* 예외를 발생시키는 대신 어설션을 사용한다.
* 문서는 XML 기반 문서 태그 대신 Markdown으로 작성된다.

6. 예제 코드

Q#은 양자 컴퓨팅 알고리즘을 표현하고 실행하기 위해 설계된 마이크로소프트의 오픈 소스 프로그래밍 언어이다. 실제 양자 알고리즘 구현을 돕기 위해 다양한 예제 코드가 제공되고 있다.

아래 하위 섹션에서는 공식 마이크로소프트 Q# 라이브러리에 포함된 멀티플렉서 구현 예시를 보여준다. 이 코드는 n-큐비트 숫자 상태를 제어로 사용하여 특정 유니터리 연산을 적용하는 다중 제어 유니터리 연산을 구현하는 방법을 보여준다.

6.1. 멀티플렉서

다음 소스 코드는 공식 마이크로소프트 Q# 라이브러리 저장소의 멀티플렉서이다.

```csharp
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

namespace Microsoft.Quantum.Canon {
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Arithmetic;
open Microsoft.Quantum.Arrays;
open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Math;

/// # 요약
/// n-큐비트 숫자 상태 $\ket{j}$로 제어될 때 유니터리 $V_j$를 적용하는 다중 제어 유니터리 연산 $U$를 적용합니다.
///
/// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # 입력
/// ## unitaryGenerator
/// 첫 번째 요소 `Int`가 유니터리 개수 $N$이고, 두 번째 요소 `(Int -> ('T => () is Adj + Ctl))`
/// 가 $[0,N-1]$의 정수 $j$를 입력받아 유니터리
/// 연산 $V_j$를 출력하는 함수인 튜플입니다.
///
/// ## index
/// 리틀 엔디안 형식으로 숫자 상태 $\ket{j}$를 인코딩하는 $n$-큐비트 제어 레지스터입니다.
///
/// ## target
/// $V_j$가 작용하는 제네릭 큐비트 레지스터입니다.
///
/// # 참고
/// $2^n$ 미만으로 지정된 경우 `coefficients`는 항등 요소로 채워집니다. 이 구현은
/// $n-1$ 보조 큐비트를 사용합니다.
///
/// # 참고 문헌
/// - [ *Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su*,
/// arXiv:1711.10980](https://arxiv.org/abs/1711.10980)
operation MultiplexOperationsFromGenerator<'T>(unitaryGenerator : (Int, (Int -> ('T => Unit is Adj + Ctl))), index: LittleEndian, target: 'T) : Unit is Ctl + Adj {
let (nUnitaries, unitaryFunction) = unitaryGenerator;
let unitaryGeneratorWithOffset = (nUnitaries, 0, unitaryFunction);
if Length(index!) == 0 {
fail "MultiplexOperations failed. Number of index qubits must be greater than 0.";
}
if nUnitaries > 0 {
let auxiliary = [];
Adjoint MultiplexOperationsFromGeneratorImpl(unitaryGeneratorWithOffset, auxiliary, index, target);
}
}

/// # 요약
/// `MultiplexOperationsFromGenerator`의 구현 단계입니다.
/// # 또한 보기
/// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator
internal operation MultiplexOperationsFromGeneratorImpl<'T>(unitaryGenerator : (Int, Int, (Int -> ('T => Unit is Adj + Ctl))), auxiliary: Qubit[], index: LittleEndian, target: 'T)
: Unit {
body (...) {
let nIndex = Length(index!);
let nStates = 2^nIndex;

let (nUnitaries, unitaryOffset, unitaryFunction) = unitaryGenerator;

let nUnitariesLeft = MinI(nUnitaries, nStates / 2);
let nUnitariesRight = MinI(nUnitaries, nStates);

let leftUnitaries = (nUnitariesLeft, unitaryOffset, unitaryFunction);
let rightUnitaries = (nUnitariesRight - nUnitariesLeft, unitaryOffset + nUnitariesLeft, unitaryFunction);

let newControls = LittleEndian(Most(index!));

if nUnitaries > 0 {
if Length(auxiliary) == 1 and nIndex == 0 {
// 종료 사례

(Controlled Adjoint (unitaryFunction(unitaryOffset)))(auxiliary, target);
} elif Length(auxiliary) == 0 and nIndex >= 1 {
// 시작 사례
let newauxiliary = Tail(index!);
if nUnitariesRight > 0 {
MultiplexOperationsFromGeneratorImpl(rightUnitaries, [newauxiliary], newControls, target);
}
within {
X(newauxiliary);
} apply {
MultiplexOperationsFromGeneratorImpl(leftUnitaries, [newauxiliary], newControls, target);
}
} else {
// nIndex를 1 감소시키고 Length(auxiliary)를 1로 설정하는 재귀.
let controls = [Tail(index!)] + auxiliary;
use newauxiliary = Qubit();
use andauxiliary = Qubit[MaxI(0, Length(controls) - 2)];
within {
ApplyAndChain(andauxiliary, controls, newauxiliary);
} apply {
if nUnitariesRight > 0 {
MultiplexOperationsFromGeneratorImpl(rightUnitaries, [newauxiliary], newControls, target);
}
within {
(Controlled X)(auxiliary, newauxiliary);
} apply {
MultiplexOperationsFromGeneratorImpl(leftUnitaries, [newauxiliary], newControls, target);
}
}
}
}
}
adjoint auto;
controlled (controlRegister, ...) {
MultiplexOperationsFromGeneratorImpl(unitaryGenerator, auxiliary + controlRegister, index, target);
}
adjoint controlled auto;
}

/// # 요약
/// n-큐비트 숫자 상태 $\ket{j}$로 제어될 때 유니터리 $V_j$를 적용하는 다중 제어 유니터리 연산 $U$를 적용합니다.
///
/// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # 입력
/// ## unitaryGenerator
/// 첫 번째 요소 `Int`가 유니터리 개수 $N$이고, 두 번째 요소 `(Int -> ('T => () is Adj + Ctl))`
/// 가 $[0,N-1]$의 정수 $j$를 입력받아 유니터리
/// 연산 $V_j$를 출력하는 함수인 튜플입니다.
///
/// ## index
/// 리틀 엔디안 형식으로 숫자 상태 $\ket{j}$를 인코딩하는 $n$-큐비트 제어 레지스터입니다.
///
/// ## target
/// $V_j$가 작용하는 제네릭 큐비트 레지스터입니다.
///
/// # 참고
/// $2^n$ 미만으로 지정된 경우 `coefficients`는 항등 요소로 채워집니다. 이 버전은
/// n-제어 유니터리 연산자를 반복하여 직접 구현됩니다.
operation MultiplexOperationsBruteForceFromGenerator<'T>(unitaryGenerator : (Int, (Int -> ('T => Unit is Adj + Ctl))), index: LittleEndian, target: 'T)
: Unit is Adj + Ctl {
let nIndex = Length(index!);
let nStates = 2^nIndex;
let (nUnitaries, unitaryFunction) = unitaryGenerator;
for idxOp in 0..MinI(nStates,nUnitaries) - 1 {
(ControlledOnInt(idxOp, unitaryFunction(idxOp)))(index!, target);
}
}

/// # 요약
/// n-큐비트 숫자 상태 $\ket{j}$로 제어될 때 유니터리 $V_j$를 적용하는 다중 제어 유니터리 연산 $U$를 반환합니다.
///
/// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # 입력
/// ## unitaryGenerator
/// 첫 번째 요소 `Int`가 유니터리 개수 $N$이고, 두 번째 요소 `(Int -> ('T => () is Adj + Ctl))`
/// 가 $[0,N-1]$의 정수 $j$를 입력받아 유니터리
/// 연산 $V_j$를 출력하는 함수인 튜플입니다.
///
/// # 출력
/// `unitaryGenerator`로 설명된 유니터리를 적용하는 다중 제어 유니터리 연산 $U$입니다.
///
/// # 또한 보기
/// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator
function MultiplexerFromGenerator(unitaryGenerator : (Int, (Int -> (Qubit[] => Unit is Adj + Ctl)))) : ((LittleEndian, Qubit[]) => Unit is Adj + Ctl) {
return MultiplexOperationsFromGenerator(unitaryGenerator, _, _);
}

/// # 요약
/// n-큐비트 숫자 상태 $\ket{j}$로 제어될 때 유니터리 $V_j$를 적용하는 다중 제어 유니터리 연산 $U$를 반환합니다.
///
/// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # 입력
/// ## unitaryGenerator
/// 첫 번째 요소 `Int`가 유니터리 개수 $N$이고, 두 번째 요소 `(Int -> ('T => () is Adj + Ctl))`
/// 가 $[0,N-1]$의 정수 $j$를 입력받아 유니터리
/// 연산 $V_j$를 출력하는 함수인 튜플입니다.
///
/// # 출력
/// `unitaryGenerator`로 설명된 유니터리를 적용하는 다중 제어 유니터리 연산 $U$입니다.
///
/// # 또한 보기
/// - Microsoft.Quantum.Canon.MultiplexOperationsBruteForceFromGenerator
function MultiplexerBruteForceFromGenerator(unitaryGenerator : (Int, (Int -> (Qubit[] => Unit is Adj + Ctl)))) : ((LittleEndian, Qubit[]) => Unit is Adj + Ctl) {
return MultiplexOperationsBruteForceFromGenerator(unitaryGenerator, _, _);
}

/// # 요약
/// AND 게이트 체인을 계산합니다.
///
/// # 설명
/// 임시 결과를 계산하기 위한 보조 큐비트는 명시적으로 지정해야 합니다.
/// 해당 레지스터의 길이는 제어가 최소 2개 있으면 `Length(ctrlRegister) - 2`이고, 그렇지 않으면 길이는 0입니다.
internal operation ApplyAndChain(auxRegister : Qubit[], ctrlRegister : Qubit[], target : Qubit)
: Unit is Adj {
if Length(ctrlRegister) == 0 {
X(target);
} elif Length(ctrlRegister) == 1 {
CNOT(Head(ctrlRegister), target);
} else {
EqualityFactI(Length(auxRegister), Length(ctrlRegister));
let controls1 = ctrlRegister[0..0] + auxRegister;
let controls2 = Rest(ctrlRegister);
let targets = auxRegister + [target];
ApplyToEachA(ApplyAnd, Zipped3(controls1, controls2, targets));
}
}
}

7. 자료 및 참고 문헌

마이크로소프트는 Q# 학습과 개발을 돕기 위해 다양한 자료를 제공하고 있다. 공식 문서, 깃허브 저장소의 샘플 코드와 학습 자료(Quantum Katas), 그리고 Codeforces와 같은 플랫폼에서 개최된 코딩 콘테스트 관련 자료 등을 통해 Q#을 학습할 수 있다.

7.1. 공식 문서

Q#에 대한 자료는 아직 많지 않지만, 공식 문서는 다음 링크에서 확인할 수 있다.
* [https://docs.microsoft.com/en-us/quantum/?view=qsharp-preview Microsoft Developer Network: Q#]

[https://github.com/Microsoft/Quantum/ Microsoft Quantum Github 저장소]에는 다양한 양자 알고리즘과 테스트를 구현한 샘플 프로그램들이 많이 있다.

마이크로소프트는 Codeforces에서 [https://web.archive.org/web/20181119064628/https://codeforces.com/msqs2018 Microsoft Q# 코딩 경진대회]를 개최하기도 했다. 이 대회 관련 자료와 튜토리얼, 문제 풀이 등은 블로그 게시물을 통해 제공되었다.

또한 마이크로소프트는 GitHub에 Q# 학습을 위한 연습 문제 모음인 [https://github.com/Microsoft/QuantumKatas Quantum Katas]를 제공하고 있다. 여기에는 학습 자료 링크와 문제 해결 방법 등이 포함되어 있다.

7.2. GitHub 저장소

마이크로소프트는 Q# 관련 자료를 깃허브 저장소를 통해 제공하고 있다.

* [[https://github.com/Microsoft/Quantum/ Microsoft Quantum Github repository]]: 다양한 양자 알고리즘과 해당 테스트를 구현하는 샘플 프로그램의 대규모 모음이다.
* [[https://github.com/Microsoft/QuantumKatas microsoft/QuantumKatas]]: Q# 학습을 돕기 위한 일련의 학습 연습 모음이다. 자료 링크와 문제 해결 방법이 포함되어 있다.

7.3. 코딩 콘테스트

마이크로소프트는 Codeforces에서 Microsoft Q# Coding Contest - Codeforces라는 양자 코딩 콘테스트를 개최했다. 이 콘테스트에서는 관련 자료와 튜토리얼, 그리고 문제에 대한 자세한 해결책을 함께 제공하여 참가자들의 이해를 도왔다.