The theory of learning objects allows one to create educational entities that follow an object-oriented paradigm and can be adapted e ciently for rapid creation of courses, training modules as well as textbooks. In this paper, we introduce one such repository of learning objects for the eld of quantum cryptography. These learning objects are leveraged into automatic generation of personalized and adaptive textbooks built on user preferences, learning styles, and desired learning outcomes. The textbooks are generated using the highly customizable platform of Jupyter notebooks using several digital assets, coding environments, interactive visualizations, and self-graded quizzes and tests. The presented approach is general and can be easily adopted for the development of adaptive textbooks for other disciplines.
With the potential arrival of quantum computers that can compromise cybersecurity infrastructure, interest in quantum cryptography education is rapidly increasing across institutions. The interdisciplinary nature of this area coupled with the lack of adequate course textbooks and time constraints make it challenging for instructors to design courses that meet the learning outcomes required by the various cybersecurity certifying agencies. Consequently, instructors usually resort to manually synthesizing heterogeneous, brittle, lesson plans from a variety of textbooks, which are often too rigid to accommodate students with diverse learning preferences and backgrounds and not amenable to e ectively track the required learning outcomes.
Serious games and cybersecurity learning object repositories (LORs) [
This paper presents a quantum cryptography learning object repository (QCL)
that we have developed and deployed in an LOR called Clark [
Achieving the desired learning outcomes using a large QCT without additional assistance can be challenging. Since QCTs are outcome-driven, they also include an evaluation engine to assess student performance with respect to a given outcome. In order to guide a student through the generated QCT in an e cient and challenging manner, we present a novel QCT traversal algorithm that uses student performance at each step to choose the next set of learning objects so that the desired learning outcomes can be achieved. The proposed approach has been used to synthesize various QCTs ranging from basic quantum computing fundamentals about tensor products to the entanglement based quantum key exchange protocol, E91.
The rest of the paper is organized as follows. We brie y describe related works, next. Section 2 describes the quantum cryptography learning object repository, QCL. The QCT synthesis framework is described in section 3. Section 4 describes the QCT traversal algorithm and its application to a QCT covering a non-trivial case study of tensor products used for multi-qubit quantum systems. Section 6 concludes the paper along with possible future work. 1.1
Adaptive web-based textbook generation has a long and rich history in e-learning.
Rule-based frameworks have been extensively investigated by several earlier
works to automatically synthesize course books [
Our learning repository QCL is a part of a recently developed LOR [
Quantum Cryptography Learning Object Repository: QCL 2.1
Clark is a digital library of learning objects developed mainly through funding from the National Security Agency and the National Science Foundation. It consists of learning objects that have been contributed from over fty universities across the United States on various topics in cybersecurity. A collection of learning objects, developed by some of the authors of this paper, on Quantum Computing and Cryptography is available on Clark for free download.
Clark organizes the learning objects into ve classes, based on completion
times, called nanomodules, micromodules, modules, units and courses; units,
being over 10 hours in length, often consist of collection of smaller modules and
a course consists of multiple units. Each class of learning object is accompanied
with learning outcomes that tell the user what they will achieve upon the
successful completion of the modules and exercises therein. These learning outcomes
are mapped to various cognitive levels of Bloom's taxonomy thereby providing
a learner an idea of the organization of the learning material and its complexity
and emphasis. Clark also maps various modules to di erent frameworks such as
CAE-CD and CAE-CO [
The Quantum Computing and Cryptography learning objects, in particular, are written in highly customizable Jupyter notebooks. Jupyter notebooks have become the defacto standard for quantum programming as they allow for an easy integration of mathematics, code as well as visual objects that can then interface to external APIs (such as the IBM simulator or quantum computer) with minimal e ort. Python was the chosen language for the development of these notebooks since Python is a popular language for quantum programming and well as the cybersecurity domain. While each Jupyter notebook themselves supports two types of cells - markdown and code, we further logically organize these cells into various categories. Therefore, each Jupyter notebook cell contains one of the following categories: textual explanations of topics, examples, sample code, (interactive) simulations, (interactive, self-graded) exercises, quizzes, etc. The notebooks are accompanied with nal quizzes (F-Q) that are intended to be used by instructors in a graded setting. In total, there are 28 notebooks at present that cover the basic review of linear algebra, basic quantum concepts and quantum cryptography protocols forming three units.
Figure 1 shows various categories of cells available in Jupyter notebooks in QCL on Clark. (a) Static cells with de nitions, examples and self-assessment quizzes. (b) Interactive cell with simulation of Bloch sphere.
Generating QCTs Guided by Outcomes, Preferences This section describes our procedure for generating quantum cryptography textbooks, QCTs, using the learning object repository QCL for a given set of learning outcomes, student preferences, and backgrounds.
The modules of repository QCL are available in some random order on the Clark
[
The metadata in each notebook cell of the QCL consists oflocal and global data members related to that cell and the module containing that cell, respectively. The local data members include information such as the cell-id, cell-concepts, cell-outcomes, and cell-prerequisites, i.e., outcomes that must be met in order to use this cell. The local data cell-type, can be one of { text, code, image, symbolic example, numeric example, video, widgets, quiz, auto-graded-simulation, auto-graded-quiz, code-IDE, code-IDE-wtests. Users can write Python programs and test them using a given test suite in cells of type code-IDE, and code-IDE-wtests. The numeric example, auto-graded-quiz, widget, code-IDE, code-IDE-wtests cells allow users to interact with a cell by modifying the cell contents whereas text, code, symbolic example, image, quiz, and video cells allow more limited forms of user interaction.
For example, gure (1b) depicts a Bloch sphere widget cell where users can modify values for parameters theta, phi, azimuth, and elevation using sliding scales to generate di erent qubit states visualized in the sphere. Figure 2 depicts an auto-graded-simulation cell of the BB84 quantum key exchange protocol where users can modify qubit values and orthonormal bases to orient, measure qubits and enter the resulting secret key answer to be checked for correctness.
The Boolean valued local data cell-interactive denotes whether a cell is interactive or not. A cell has to be interactive to be used to assess a learning outcome. For instance, cell depicted in 2 with the auto-grader is used in QCL to determine the outcome about users having a basic understanding of the BB84 protocol. The auto-graded quizzes, numeric-examples, and code-IDE-wtests cells in the QCL are used to determine the learning outcomes of the modules containing these cells.
The local data cell-alternates provides a list of alternate cells that are semantically equivalent to the current cell but with cell types di erent than the current cell. Alternate cells are used to adapt QCTs to student preferences and also for suggesting next cells based on student performance as described in the next section.
(a) (b)
The global data members of a cell include the containing module-title, module-outcomes, and module-prerequisites i.e., other modules whose outcomes must be achieved in order to achieve the outcomes of the current module.
As an example, the gure (3a) depicts the data members with the rst cell in the module 8 of QCL. The gure (3b) shows other QCL modules, viz. 1, 2, and 4, that are related to the module 8 along with the outcomes of the modules. 3.2
The main steps to generate a QCT from the instrumented QCL are the following. { QCL Instrumentation Pre-processing: The integrity of the QCL instrumentation is veri ed using a variety of lightweight properties such as: a) all global data in all cells in a module are identical, b) outcomes of all the cells of a module belong to the outcomes of that module, c) type checking of cells along with their alternates. Next, module and outcome dependency graphs are built from the cell data. Lastly, these graphs are veri ed using properties such as: a) absence of dangling edges and cycles, b) module dependencies are a projection of outcome dependencies and that c) there exist one or more auto-graded quiz cells (FQ) in each module that interactively evaluate all the outcomes that module. The semantically veri ed cells and the graphs are used to generate QCTs subsequently. Note that the veri cation is a one time activity that needs to be performed only when QCL repository is updated. { Identify QCL Learning Objects: Given a set of outcomes, the QCT mode, and a ranked list (of student preferences whose elements are cell types), a forest of relevant QCL learning objects are identi ed and used to generate the corresponding QCT. The building blocks of a QCT can either be QCL modules or QCL cells and this is speci ed by the QCT mode input. To build a QCT based on QCL modules, modules whose outcomes include a given input outcome are identi ed. A reverse topological sort of the module dependency graph starting with each of these modules (with ties among the modules being broken arbitrarily) produces a linear chain of modules which are then merged while obeying module dependencies to create a single chain of QCL modules. { Generating a QCT: The linear chain of modules obtained from the previous step are then organized into a hierarchy of nano-, micro- modules, units, and courses based on the estimated times to output a QCT whose successful completion is guaranteed to satisfy the input outcomes. In order to incorporate the student preferences in a QCT, for each cell in the linear chain, the cell is retained if it matches the highest ranked input student preference; otherwise we replace it by a better matching alternate cell, if one exists. Certain modules are pruned from the QCT based on student background. A QCT can also be built from QCL using individual cells instead of entire modules using a similar procedure. In this case, the outcome dependency graph is used instead of the module dependency graph. This often, leads to more focused QCTs with lesser cells taking lesser instruction time. Student background is used to prune cells as well as modules in this case as well.
Primarily, tensor products are used to develop a vector representation for quantum systems that consist of multiple quantum bits and gates. They are also useful tools in determining whether two or more quantum systems are in an entangled state or not. Since any computing system that does useful work typically works on multiple qubits at any given time, tensor products are central to the study of quantum theory. Because of their importance, we have chosen module 8, Overview of Tensor Analysis, as the running example. Consider two outcomes from this module - \8.2 Compute Tensor products" and \8.3 Implement program that computes Tensor product of two matrices". These outcomes have dependencies in QCL modules 1, 2, and 4 (see gure 3b). These four modules are depicted in the gure (4a) along with their outcomes. To generate QCTs involving these modules, rst they are instrumented and sanity checks mentioned above were performed. Next, the module and outcome dependency graphs, depicted in gure (4a) and gure (4b) were generated and statically veri ed for the properties described above to obtain well-formed QCLs and graphs.
(a) (b) Fig. 4: (a) Module dependency graph, (b) Outcome dependency graph for outcome 8.2. at cell level detail. (Note that all the dependencies including transitive dependencies are shown in the graph for clarity.)
Inputs consisting of outcome 8.2, QCT mode specifying modules as building blocks, text cell-type as the highest preference and a novice user background are used to generate a QCT that includes all of the cells of QCL module 8 along with those of the QCL modules 1, 2, and 4 on which module 8 depends. The reverse topological sorting of the module dependency creates a QCT with a linear chain of modules beginning with 12 cells of module 1, followed by 10 cells in module 2, followed by 18 cells of module 4, and ending with 11 cells of module 8. Since it is the case that either all these cells satisfy the highest preference or there exist no alternate cells that do, none of the cells in the QCT is replaced. Finally, the generated QCT is partitioned into two nanomodules (1 and 2), and 2 micromodules (4 and 8) based on estimated times.
Next, consider generating a QCT using the same inputs as above, but changing the QCT mode to use QCL cells instead of QCL modules as building blocks of QCT. The outcome dependency graph in gure (4b) is used in this case to generate the QCT consisting of only 11 QCL cells across the four QCL modules 1, 2, 4, and 8, which is shown in gure (5a). We can also generate a QCT by changing the input to specify highest preference cell-type to be a numericalexample instead of text and this will lead to the replacement cell \m8-1" by cell \m8-4" shown in gure (5b) which are the alternate cells of \m8-1". Note, here m8-1 is cell number 1 of module 8. If we were to provide the preference [ numerical-example > example > text ], then several alternate cells will be used to generate the nal QCT. The resulting linear chain in the QCT is shown in the gure (5a) with right branch showing preference as example. These cells are organized based on their estimated time into a single nanomodule.
Note that building a QCT for outcome 8.2 using QCL modules leads to QCT with 50 cells whereas we need only 11 cells if we use QCL cells to generate the QCT, which is a saving of 39 cells. 4
Dynamic QCT Traversal Using Student Performance Achieving the desired learning outcomes by serially following a QCT that is constructed solely based on dependencies can be challenging. For example, it is conceivable that students may want to study a concept in di erent contexts to achieve the required outcome; this may also involve attempting to achieve a speci ed outcome in conjunction with others. For example, an outcome \understand the basics of a quantum protocol" such as E91 may be achieved in conjunction with an outcome that requires to create a functional prototype of this protocol. Consequently, in this section, we present a novel QCT traversal algorithm that uses student performance at each outcome assessment step to choose the next set of learning objects such that the desired outcomes can be achieved in an e cient manner.
The proposed traversal algorithm works on a quiz dependency graph, Q, whose nodes are QCL auto-graded quiz cells, (recall from section 3.2 that these cells (FQ), taken together assess all the outcomes of the module containing them). The information at each node ci of Q, R(ci), is the set of outcomes that are assessed by that node. Each node ci, in Q, is assigned a node weight, vi as follows: vi = h jC(1oj)j ; oj R(ci)i. Here jC(oj)j is the number of nodes in Q that contain an unmet outcome oj for all oj that are in node ci.
There is a labeled edge (ci, cj, wi;j) in Q from node ci to cj with weight wi;j if some outcome in R(cj) depends on an outcome in R(ci). Let N Rj;i be the number of outcomes common to ci and cj and Nj;i be the number of outcomes in cj that depend on some outcome in ci. The dependency overlap between node ci and cj is, D(ci; cj) = Nji N Rji; where = 10 ceil(log(N)), is the redundancy factor and N is the number of outcomes in Q. wi;j =
Given node weights and the dependency overlap, the edge weight is given by,
Dj(Rcic;jcjj) vj .
A quiz cell dependency graph involving outcomes from the QCL modules 1, 2, 4, and 8 discussed earlier is depicted in gure 6.
The adaptive traversal through quiz cell dependency graph is achieved using the traversal algorithm given below. The proposed algorithm is presented for cell level navigation. However, it can be easily adapted to the case where student prefers module level traversal of the QCT.
Algorithm Inputs: Textbook QCT, Quiz Dependency Graph (Q) Steps: 1. Pick next node ci. If there are one or more unvisited source nodes, then choose one with the maximum node weight. Otherwise, pick the next node that has the maximum edge weight from a visited node. 2. Generate a new QCT with target outcomes R(ci) from the input QCT. 3. Assess outcomes R(ci) using the quiz cell corresponding to ci. 4. If some of outcomes in R(ci) are achieved, update Q by re-calculating the node and edge weights. Node weights are modi ed as the number of unmet outcomes change and consequently edge weights change as well. Remove nodes with 0 node weight, edges among nodes with independent or disjoint outcomes. Go to step 1 and repeat if Q is not empty. 5. If one or more outcomes R(ci) are not met, go to step 2.
The above algorithm traverses a given QCT by starting with quizzes which cover unmet outcomes that do not have any prerequisites. If there is a choice among such quizzes then those covering the largest number of unmet outcomes is chosen. The student is given a new QCT with cells related to the outcomes in the chosen quiz and their performance is evaluated on the quiz after going through the new QCT. If the student succeeds in the quiz, the graph is updated to re ect the outcomes that are already met. Then, the next quiz is chosen based on maximum edge weight, which picks a quiz with least redundancy in terms of satis ed outcomes among all candidate quizzes and has the most number of prerequisites satis ed among all the candidate quizzes. Note that all prerequisites must be met for every candidate quiz.
Example: Consider the quiz dependency graph Q in gure 6 involving the auto-graded quizzes from the QCL modules 1, 2, 4, and 8. Each node in the graph represents a quiz and its associated outcomes. The node FQ: 2:10 represents question number 10 from the nal quiz for module 2 and so on. The node weights and edge weights are calculated. The initial node weights of two base nodes FQ: 2:9 and FQ: 2:10 are 5=6 and 11=6 respectively. Hence FQ: 2:10 is chosen initially being node with maximum edge weight. After the student gains knowledge in the QCT generated, the outcome is measured by providing the quiz FQ: 2:10. Once the quiz is solved successfully, all the node weights are re-calculated and the outcomes are marked met in the other available quiz cell. Hence the value of node FQ: 2:9 is 0 once the student achieves the outcomes from FQ: 2:10 similarly, value of node FQ: 2:4 is 1/2. Next, the edge weights of the adjacent nodes are calculated as shown on the edges from FQ: 2:10 in the above gure.
The edge with maximum weight i.e, FQ: 2:11 is chosen as next best quiz for the student. Accordingly, the related QCT is generated from QCL based on the outcomes and student preferences. The procedure is repeated until the student successfully achieves all the target outcomes. 5
Conclusion In this paper, we presented a new method to generate adaptive quantum cryptography textbooks (QCT) from a repository of quantum cryptography learning objects. The textbook generation is customized based on the learning outcomes, student preferences and the background of the student. Each learning object is instrumented with metadata that is used to generate new textbooks. A case study shows that the outcome level dependency reduces the overhead of cells required to achieve a learning outcome compared to module level dependency. We also introduce an adaptive QCT traversal algorithm to further guide the students through the generated QCTs based on their performance on quizzes. This helps the student achieve the desired outcomes e ciently.
In future work, we will extend our work with reinforcement learning techniques and automate the generation of QCTs. Further, QCTs generated will be supplemented with a query engine for each lookup of learning objects for a just-in-time learning process. 5.1
This project was partly funded through National Science Foundation (NSF) award 1623380.