Documentation Updates

docs/make.jl

@@ -30,6 +30,8 @@ function main()
         "Properties and Backgrounds" => "propbackgrounds.md",
         "Symbolic Expressions" => "symbolics.md",
         "Tagging and Querying" => "tag_query.md",
+        "Backend Simulators" => "backendsimulator.md",
+        "Discrete Event Simulator" => "discreteeventsimulator.md",
         "Visualizations" => "visualizations.md",
     ],
     "How-To Guides" => [

docs/src/backendsimulator.md

@@ -0,0 +1,16 @@
+# [Backend Simulators](@id backend)
+
+```@meta
+DocTestSetup = quote
+    using QuantumSavory
+end
+```
+The simulation of quantum dynamics in QuantumSavory can be done through many different backend simulators, depending on the tradeoff between performance and generality that the user needs. By default, it comes with two included simulators: `QuantumClifford` and `QuantumOptics`, but others can be plugged in through our universal quantum register interface.
+
+# QuantumClifford - Stabilizer Formalism
+
+QuantumClifford leverages stabilizer states and Clifford gates — highly structured operations that can be simulated more efficiently than arbitrary quantum processes. It uses the tableaux formalism with the destabilizer improvements, as implemented in the [`QuantumClifford`](https://qc.quantumsavory.org/stable/) library. Simulations run in polynomial time, enabling very fast computations. However, adding non-Clifford elements breaks this efficiency, making the simulation more complex and slower.
+
+# QuantumOptics - State Vector Formalism
+
+QuantumOptics uses a fully general state vector (wavefunction) representation. This approach, provided by the ['QuantumOptics'](https://qojulia.org/) library, can handle any quantum operation or state without the structural restrictions of stabilizer methods. While this generality is powerful, it quickly becomes computationally expensive as the number of qubits grows — memory and time requirements scale exponentially. Consequently, simulating large systems with the state vector formalism becomes impractically slow compared to stabilizer-based methods.

docs/src/discreteeventsimulator.md

@@ -0,0 +1,17 @@
+# [Discrete Event Simulator](@id sim)
+
+```@meta
+DocTestSetup = quote
+    using QuantumSavory
+end
+```
+
+## Overview
+
+Simulating quantum processes requires robust tools for **Discrete Event Simulation**. In QuantumSavory, we use `ConcurrentSim.jl` and `ResumableFunctions.jl` to model complex, asynchronous processes.
+
+This simulation framework enables protocols to handle dynamic interactions, such as waiting for resources to become available.
+
+### **ConcurrentSim.jl** and **ResumableFunctions.jl**
+
+QuantumSavory discrete event simulations are based on [`ConcurrentSim.jl`](https://github.com/JuliaDynamics/ConcurrentSim.jl). A process is defined as a `@resumable` function that yields events, allowing for efficient resource allocation and the expression of protocols that pause until specific conditions are met. These features are essential for implementing waiting mechanisms, such as waiting for messages or changes in a quantum state.

docs/src/howto/repeatergrid/repeatergrid.md

@@ -49,7 +49,7 @@ The Swapper Protocol is initialized with a custom predicate function which is th
 
 This predicate function encodes most of the "logic" a local node will be performing.
 
-The custom predicate function shown above is parametrized with `net` and `c_node` along with the keyword argument `low`, when initializing the Swapper Protocol. This predicate function `Int->Bool` selects the target remote nodes for which a swap is appropriate. The arguments are:
+The custom predicate function shown above is parameterized with `net` and `c_node` along with the keyword argument `low`, when initializing the Swapper Protocol. This predicate function `Int->Bool` selects the target remote nodes for which a swap is appropriate. The arguments are:
 
 - `net`: The network of register nodes representing the graph structure, an instance of `RegisterNet`.
 

docs/src/index.md

@@ -8,7 +8,7 @@ end
 
 A multi-formalism simulator for noisy quantum communication and computation hardware with support for symbolic algebra, multiple simulation backends, a variety of noise models, discrete event simulation, optimization, and visualization.
 
-We are also preparing a [getting started manual](@ref manual).
+To install QuantumSavory, see: [getting started manual](@ref manual).
 
 The rest of the documentation is [structured](https://diataxis.fr/) as follows:
 
@@ -19,7 +19,17 @@ The rest of the documentation is [structured](https://diataxis.fr/) as follows:
 
 Depending on your learning style, you might prefer to start at different locations in the above documentation.
 
-Below we demo some of the results of the How-To guides.
+
+### Capabilities
+
+QuantumSavory offers advanced features such as:
+
+- **Hardware Parameter Database**: Detailed records of quantum hardware metrics, enabling realistic simulations and performance benchmarking.
+- **Noise Processes Zoo**: A collection of noise models for simulating quantum systems under realistic and complex conditions.
+- **Protocols and Circuits Compendium**: Pre-designed quantum circuits and protocols for rapid prototyping and optimization of applications.
+
+
+Below we show some of the results of the How-To guides.
 
 #### A simulation of a quantum repeater:
 
@@ -42,4 +52,7 @@ Below we demo some of the results of the How-To guides.
     This is software is still in a fairly unstable alpha state! The documentation is extremely barebones and current users are expected to read the source code.
 
 A good place to start is the How-To pages.
-For instance, the [implementation of a first generation repeater](@ref First-Generation-Quantum-Repeater).
+For instance, the [implementation of a first generation repeater](@ref First-Generation-Quantum-Repeater).
+
+### Get Involved
+We welcome contributions from experts and students alike, whether by improving the codebase or suggesting new useful features. Your input will help us refine QuantumSavory and support better quantum simulations.

docs/src/manual.md

@@ -6,3 +6,52 @@ DocTestSetup = quote
 end
 ```
 
+## Getting Started
+
+### Installation
+
+To use QuantumSavory, make sure you have Julia version 1.10 installed. You can download and install Julia from [the official Julia website](https://julialang.org/downloads/).
+
+Once Julia is setup, QuantumSavory can be installed with the following command in your in your Julia REPL:
+```bash
+$ julia
+julia> ]
+pkg> add QuantumSavory
+```
+
+#### Optional Dependencies
+
+There are optional packages that you need to install to use the full plotting feature.
+- **Makie**: For plotting of registers and processes.
+- **GeoMakie**: Enables plotting on a real-world map as a background.
+
+## Basic Demo
+
+Here’s a simple example to demonstrate how you can set up a simulation to generate a set of registers with qubit slots. For more advanced examples and detailed guide, see[How-To Guides](@ref) and [Tutorials](@ref) sections.
+
+```
+using QuantumSavory
+
+# This is a network of three registers, each with 2, 3, and 4 Qubit slots.
+net = RegisterNet([Register(2), Register(3), Register(4)])
+
+# initialize slots and entangle them
+initialize!(net[1,1])
+initialize!(net[2,3], X₁)
+initialize!((net[3,1],net[4,2]), X₁⊗Z₂)
+
+# apply CNOT gate
+apply!((net[2,3],net[3,1]), CNOT)
+```
+
+If you have `Makie` and `GeoMakie` installed, you can plot the above network:
+```
+using GLMakie
+GLMakie.activate!()
+
+# generate background map
+map_axis = generate_map()
+
+fig, ax, plt, obs = registernetplot_axis(map_axis, net, registercoords=[Point2f(-71, 42), Point2f(-111, 34), Point2f(-122, 37)])
+fig
+```