mixed cleanup

docs/make.jl

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

docs/src/backendsimulator.md

@@ -5,12 +5,12 @@ DocTestSetup = quote
     using QuantumSavory
 end
 ```
-QuantumSavory supports two backend simulators: `QuantumClifford` and `QuantumOptics`.
+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. Because these operations remain within the stabilizer subtheory, simulations can often run in polynomial time, enabling very fast computations. However, adding non-Clifford elements breaks this efficiency, making the simulation more complex and slower.
+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.
+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

@@ -8,9 +8,10 @@ end
 
 ## Overview
 
-imulating quantum processes requires robust tools for **Discrete Event Simulator**. In QuantumSavory, we use `ConcurrentSim.jl` and `ResumableFunctions.jl` to model complex, asynchronous processes.
+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 simulations are structured using [`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.
+
+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/manual.md

@@ -7,7 +7,9 @@ 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:
@@ -16,14 +18,16 @@ $ 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.
 
+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