diff --git a/.github/ISSUE_TEMPLATE/01_ITensors_bug_report.md b/.github/ISSUE_TEMPLATE/01_ITensors_bug_report.md
new file mode 100644
index 0000000000..56be1986ec
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/01_ITensors_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: ITensors.jl bug report
+about: Create a bug report to help us improve ITensors.jl
+title: "[ITensors] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["ITensors", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/ITensors_feature_request.md b/.github/ISSUE_TEMPLATE/01_ITensors_feature_request.md
similarity index 87%
rename from .github/ISSUE_TEMPLATE/ITensors_feature_request.md
rename to .github/ISSUE_TEMPLATE/01_ITensors_feature_request.md
index 0530081312..c4ecbbd7b1 100644
--- a/.github/ISSUE_TEMPLATE/ITensors_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/01_ITensors_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: ITensors.jl feature request
 about: Suggest an idea for ITensors.jl
-title: "[ITensors] [ENHANCEMENT]"
+title: "[ITensors] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["ITensors", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/02_NDTensors_bug_report.md b/.github/ISSUE_TEMPLATE/02_NDTensors_bug_report.md
new file mode 100644
index 0000000000..cb2aa59a82
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/02_NDTensors_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: NDTensors.jl bug report
+about: Create a bug report to help us improve NDTensors.jl
+title: "[NDTensors] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["NDTensors", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/NDTensors_feature_request.md b/.github/ISSUE_TEMPLATE/02_NDTensors_feature_request.md
similarity index 87%
rename from .github/ISSUE_TEMPLATE/NDTensors_feature_request.md
rename to .github/ISSUE_TEMPLATE/02_NDTensors_feature_request.md
index 649a8cb178..db445b1ef8 100644
--- a/.github/ISSUE_TEMPLATE/NDTensors_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/02_NDTensors_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: NDTensors.jl feature request
 about: Suggest an idea for NDTensors.jl
-title: "[NDTensors] [ENHANCEMENT]"
+title: "[NDTensors] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["NDTensors", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/03_ITensorGPU_bug_report.md b/.github/ISSUE_TEMPLATE/03_ITensorGPU_bug_report.md
new file mode 100644
index 0000000000..7fbd2619a8
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/03_ITensorGPU_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: ITensorGPU.jl bug report
+about: Create a bug report to help us improve ITensorGPU.jl
+title: "[ITensorGPU] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["ITensorGPU", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/ITensorGPU_feature_request.md b/.github/ISSUE_TEMPLATE/03_ITensorGPU_feature_request.md
similarity index 87%
rename from .github/ISSUE_TEMPLATE/ITensorGPU_feature_request.md
rename to .github/ISSUE_TEMPLATE/03_ITensorGPU_feature_request.md
index 63d8c09393..98530af229 100644
--- a/.github/ISSUE_TEMPLATE/ITensorGPU_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/03_ITensorGPU_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: ITensorGPU.jl feature request
 about: Suggest an idea for ITensorGPU.jl
-title: "[ITensorGPU] [ENHANCEMENT]"
+title: "[ITensorGPU] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["ITensorGPU", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/04_ITensorGaussianMPS_bug_report.md b/.github/ISSUE_TEMPLATE/04_ITensorGaussianMPS_bug_report.md
new file mode 100644
index 0000000000..a774199b5a
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/04_ITensorGaussianMPS_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: ITensorGaussianMPS.jl bug report
+about: Create a bug report to help us improve ITensorGaussianMPS.jl
+title: "[ITensorGaussianMPS] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["ITensorGaussianMPS", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/ITensorGaussianMPS_feature_request.md b/.github/ISSUE_TEMPLATE/04_ITensorGaussianMPS_feature_request.md
similarity index 86%
rename from .github/ISSUE_TEMPLATE/ITensorGaussianMPS_feature_request.md
rename to .github/ISSUE_TEMPLATE/04_ITensorGaussianMPS_feature_request.md
index 4468022e63..c4f75c0112 100644
--- a/.github/ISSUE_TEMPLATE/ITensorGaussianMPS_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/04_ITensorGaussianMPS_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: ITensorGaussianMPS.jl feature request
 about: Suggest an idea for ITensorGaussianMPS.jl
-title: "[ITensorGaussianMPS] [ENHANCEMENT]"
+title: "[ITensorGaussianMPS] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["ITensorGaussianMPS", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/05_ITensorVisualizationBase_bug_report.md b/.github/ISSUE_TEMPLATE/05_ITensorVisualizationBase_bug_report.md
new file mode 100644
index 0000000000..bc7fc64162
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/05_ITensorVisualizationBase_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: ITensorVisualizationBase.jl bug report
+about: Create a bug report to help us improve ITensorVisualizationBase.jl
+title: "[ITensorVisualizationBase] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["ITensorVisualizationBase", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/ITensorVisualizationBase_feature_request.md b/.github/ISSUE_TEMPLATE/05_ITensorVisualizationBase_feature_request.md
similarity index 86%
rename from .github/ISSUE_TEMPLATE/ITensorVisualizationBase_feature_request.md
rename to .github/ISSUE_TEMPLATE/05_ITensorVisualizationBase_feature_request.md
index bd42c2e23a..65142912b7 100644
--- a/.github/ISSUE_TEMPLATE/ITensorVisualizationBase_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/05_ITensorVisualizationBase_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: ITensorVisualizationBase.jl feature request
 about: Suggest an idea for ITensorVisualizationBase.jl
-title: "[ITensorVisualizationBase] [ENHANCEMENT]"
+title: "[ITensorVisualizationBase] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["ITensorVisualizationBase", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/06_ITensorUnicodePlots_bug_report.md b/.github/ISSUE_TEMPLATE/06_ITensorUnicodePlots_bug_report.md
new file mode 100644
index 0000000000..1da5724dd9
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/06_ITensorUnicodePlots_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: ITensorUnicodePlots.jl bug report
+about: Create a bug report to help us improve ITensorUnicodePlots.jl
+title: "[ITensorUnicodePlots] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["ITensorUnicodePlots", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/ITensorUnicodePlots_feature_request.md b/.github/ISSUE_TEMPLATE/06_ITensorUnicodePlots_feature_request.md
similarity index 86%
rename from .github/ISSUE_TEMPLATE/ITensorUnicodePlots_feature_request.md
rename to .github/ISSUE_TEMPLATE/06_ITensorUnicodePlots_feature_request.md
index abb4a6f071..61fd9aa80a 100644
--- a/.github/ISSUE_TEMPLATE/ITensorUnicodePlots_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/06_ITensorUnicodePlots_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: ITensorUnicodePlots.jl feature request
 about: Suggest an idea for ITensorUnicodePlots.jl
-title: "[ITensorUnicodePlots] [ENHANCEMENT]"
+title: "[ITensorUnicodePlots] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["ITensorUnicodePlots", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/07_ITensorMakie_bug_report.md b/.github/ISSUE_TEMPLATE/07_ITensorMakie_bug_report.md
new file mode 100644
index 0000000000..d2a4508988
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/07_ITensorMakie_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: ITensorMakie.jl bug report
+about: Create a bug report to help us improve ITensorMakie.jl
+title: "[ITensorMakie] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["ITensorMakie", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/ITensorMakie_feature_request.md b/.github/ISSUE_TEMPLATE/07_ITensorMakie_feature_request.md
similarity index 87%
rename from .github/ISSUE_TEMPLATE/ITensorMakie_feature_request.md
rename to .github/ISSUE_TEMPLATE/07_ITensorMakie_feature_request.md
index c4f7cb2186..8590b1f694 100644
--- a/.github/ISSUE_TEMPLATE/ITensorMakie_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/07_ITensorMakie_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: ITensorMakie.jl feature request
 about: Suggest an idea for ITensorMakie.jl
-title: "[ITensorMakie] [ENHANCEMENT]"
+title: "[ITensorMakie] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["ITensorMakie", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/08_ITensorGLMakie_bug_report.md b/.github/ISSUE_TEMPLATE/08_ITensorGLMakie_bug_report.md
new file mode 100644
index 0000000000..4405ece1ad
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/08_ITensorGLMakie_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: ITensorGLMakie.jl bug report
+about: Create a bug report to help us improve ITensorGLMakie.jl
+title: "[ITensorGLMakie] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["ITensorGLMakie", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/ITensorGLMakie_feature_request.md b/.github/ISSUE_TEMPLATE/08_ITensorGLMakie_feature_request.md
similarity index 87%
rename from .github/ISSUE_TEMPLATE/ITensorGLMakie_feature_request.md
rename to .github/ISSUE_TEMPLATE/08_ITensorGLMakie_feature_request.md
index 86c25f4b83..a97fa92829 100644
--- a/.github/ISSUE_TEMPLATE/ITensorGLMakie_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/08_ITensorGLMakie_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: ITensorGLMakie.jl feature request
 about: Suggest an idea for ITensorGLMakie.jl
-title: "[ITensorGLMakie] [ENHANCEMENT]"
+title: "[ITensorGLMakie] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["ITensorGLMakie", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/ITensorGLMakie_bug_report.md b/.github/ISSUE_TEMPLATE/ITensorGLMakie_bug_report.md
deleted file mode 100644
index 60356ed1ee..0000000000
--- a/.github/ISSUE_TEMPLATE/ITensorGLMakie_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: ITensorGLMakie.jl report
-about: Create a report to help us improve ITensorGLMakie.jl
-title: "[ITensorGLMakie] [BUG]"
-labels: ["ITensorGLMakie", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/ITensorGPU_bug_report.md b/.github/ISSUE_TEMPLATE/ITensorGPU_bug_report.md
deleted file mode 100644
index 3a657e5b85..0000000000
--- a/.github/ISSUE_TEMPLATE/ITensorGPU_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: ITensorGPU.jl report
-about: Create a report to help us improve ITensorGPU.jl
-title: "[ITensorGPU] [BUG]"
-labels: ["ITensorGPU", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/ITensorGaussianMPS_bug_report.md b/.github/ISSUE_TEMPLATE/ITensorGaussianMPS_bug_report.md
deleted file mode 100644
index c5b12dbe41..0000000000
--- a/.github/ISSUE_TEMPLATE/ITensorGaussianMPS_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: ITensorGaussianMPS.jl report
-about: Create a report to help us improve ITensorGaussianMPS.jl
-title: "[ITensorGaussianMPS] [BUG]"
-labels: ["ITensorGaussianMPS", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/ITensorMakie_bug_report.md b/.github/ISSUE_TEMPLATE/ITensorMakie_bug_report.md
deleted file mode 100644
index 5870f5131a..0000000000
--- a/.github/ISSUE_TEMPLATE/ITensorMakie_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: ITensorMakie.jl report
-about: Create a report to help us improve ITensorMakie.jl
-title: "[ITensorMakie] [BUG]"
-labels: ["ITensorMakie", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/ITensorUnicodePlots_bug_report.md b/.github/ISSUE_TEMPLATE/ITensorUnicodePlots_bug_report.md
deleted file mode 100644
index bf637692cb..0000000000
--- a/.github/ISSUE_TEMPLATE/ITensorUnicodePlots_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: ITensorUnicodePlots.jl report
-about: Create a report to help us improve ITensorUnicodePlots.jl
-title: "[ITensorUnicodePlots] [BUG]"
-labels: ["ITensorUnicodePlots", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/ITensorVisualizationBase_bug_report.md b/.github/ISSUE_TEMPLATE/ITensorVisualizationBase_bug_report.md
deleted file mode 100644
index 5a20ff9bb4..0000000000
--- a/.github/ISSUE_TEMPLATE/ITensorVisualizationBase_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: ITensorVisualizationBase.jl report
-about: Create a report to help us improve ITensorVisualizationBase.jl
-title: "[ITensorVisualizationBase] [BUG]"
-labels: ["ITensorVisualizationBase", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/ITensors_bug_report.md b/.github/ISSUE_TEMPLATE/ITensors_bug_report.md
deleted file mode 100644
index 3e43b3d7f1..0000000000
--- a/.github/ISSUE_TEMPLATE/ITensors_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: ITensors.jl report
-about: Create a report to help us improve ITensors.jl
-title: "[ITensors] [BUG]"
-labels: ["ITensors", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/NDTensors_bug_report.md b/.github/ISSUE_TEMPLATE/NDTensors_bug_report.md
deleted file mode 100644
index bd5349faa4..0000000000
--- a/.github/ISSUE_TEMPLATE/NDTensors_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: NDTensors.jl report
-about: Create a report to help us improve NDTensors.jl
-title: "[NDTensors] [BUG]"
-labels: ["NDTensors", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/generate_issue_templates/PACKAGE_bug_report.md b/.github/ISSUE_TEMPLATE/generate_issue_templates/PACKAGE_bug_report.md
new file mode 100644
index 0000000000..3946e68dbe
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/generate_issue_templates/PACKAGE_bug_report.md
@@ -0,0 +1,60 @@
+---
+name: PACKAGE.jl bug report
+about: Create a bug report to help us improve PACKAGE.jl
+title: "[PACKAGE] [BUG] YOUR SHORT DESCRIPTION OF THE BUG HERE"
+labels: ["PACKAGE", "bug"]
+assignees: ''
+
+---
+
+**Description of bug**
+
+Please give a brief description of the bug or unexpected behavior here.
+
+**Minimal code demonstrating the bug or unexpected behavior**
+
+If applicable, provide a minimal code that can be run to demonstrate the bug or unexpected behavior.
+
+If you are unable to construct a minimal code that demonstrates the bug or unexpected behavior, provide detailed steps for how to reproduce the behavior you are seeing.
+
+<details><summary>Minimal runnable code</summary><p>
+
+```julia
+[YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Expected output or behavior**
+
+Describe what you expected to happen.
+
+If you provided a minimal code that can be run to demonstrate the bug or unexpected behavior, describe what you expected the output would be.
+
+
+**Actual output or behavior**
+
+Describe what actually happened.
+
+If you provided a minimal code that demonstrates the bug or unexpected behavior, provide the output you get from that code. If the code leads to an error or warning, include the full error or warning below.
+
+<details><summary>Output of minimal runnable code</summary><p>
+
+```julia
+[OUTPUT OF YOUR MINIMAL RUNNABLE CODE HERE]
+```
+</p></details>
+
+
+**Version information**
+
+ - Output from `versioninfo()`:
+```julia
+julia> versioninfo()
+[YOUR OUTPUT HERE]
+```
+ - Output from `using Pkg; Pkg.status("ITensors")`:
+```julia
+julia> using Pkg; Pkg.status("ITensors")
+[YOUR OUTPUT HERE]
+```
diff --git a/.github/ISSUE_TEMPLATE/template_templates/PACKAGE_feature_request.md b/.github/ISSUE_TEMPLATE/generate_issue_templates/PACKAGE_feature_request.md
similarity index 87%
rename from .github/ISSUE_TEMPLATE/template_templates/PACKAGE_feature_request.md
rename to .github/ISSUE_TEMPLATE/generate_issue_templates/PACKAGE_feature_request.md
index 0402e847bc..fc6bea0a43 100644
--- a/.github/ISSUE_TEMPLATE/template_templates/PACKAGE_feature_request.md
+++ b/.github/ISSUE_TEMPLATE/generate_issue_templates/PACKAGE_feature_request.md
@@ -1,20 +1,24 @@
 ---
 name: PACKAGE.jl feature request
 about: Suggest an idea for PACKAGE.jl
-title: "[PACKAGE] [ENHANCEMENT]"
+title: "[PACKAGE] [ENHANCEMENT] YOUR SHORT DESCRIPTION OF THE FEATURE REQUEST HERE"
 labels: ["PACKAGE", "enhancement"]
 assignees: ''
 
 ---
 
 **Is your feature request related to a problem? Please describe.**
+
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 **Describe the solution you'd like**
+
 A clear and concise description of what you want to happen.
 
 **Describe alternatives you've considered**
+
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Additional context**
+
 Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/create_templates.jl b/.github/ISSUE_TEMPLATE/generate_issue_templates/generate_issue_templates.jl
similarity index 61%
rename from .github/ISSUE_TEMPLATE/create_templates.jl
rename to .github/ISSUE_TEMPLATE/generate_issue_templates/generate_issue_templates.jl
index e7a74a6a8c..af1bee1b64 100644
--- a/.github/ISSUE_TEMPLATE/create_templates.jl
+++ b/.github/ISSUE_TEMPLATE/generate_issue_templates/generate_issue_templates.jl
@@ -4,23 +4,40 @@ template_package_name = "PACKAGE"
 
 package_names = [
   "ITensors",
-  "ITensorGaussianMPS",
-  "ITensorGLMakie",
+  "NDTensors",
   "ITensorGPU",
-  "ITensorMakie",
-  "ITensorUnicodePlots",
+  "ITensorGaussianMPS",
   "ITensorVisualizationBase",
-  "NDTensors",
+  "ITensorUnicodePlots",
+  "ITensorMakie",
+  "ITensorGLMakie",
 ]
 
-bug_report_file(package_name::String) = "$(package_name)_bug_report.md"
-feature_request_file(package_name::String) = "$(package_name)_feature_request.md"
+package_ordering = Dict([
+  "ITensors" => 1,
+  "NDTensors" => 2,
+  "ITensorGPU" => 3,
+  "ITensorGaussianMPS" => 4,
+  "ITensorVisualizationBase" => 5,
+  "ITensorUnicodePlots" => 6,
+  "ITensorMakie" => 7,
+  "ITensorGLMakie" => 8,
+])
+
+function bug_report_file(package_name::String)
+  return "$(package_name)_bug_report.md"
+end
+function feature_request_file(package_name::String)
+  return "$(package_name)_feature_request.md"
+end
 
 for package_name in package_names
   @show package_name
 
+  order = lpad(package_ordering[package_name], 2, "0")
+
   template_bug_report = bug_report_file(template_package_name)
-  new_bug_report = bug_report_file(package_name)
+  new_bug_report = order * "_" * bug_report_file(package_name)
 
   if isfile(new_bug_report)
     println("File $new_bug_report already exists, skipping")
@@ -30,10 +47,12 @@ for package_name in package_names
 
     println("Replace $template_package_name with $package_name in $new_bug_report")
     replace_in_file(new_bug_report, template_package_name => package_name)
+
+    mv(new_bug_report, joinpath("..", new_bug_report); force=true)
   end
 
   template_feature_request = feature_request_file(template_package_name)
-  new_feature_request = feature_request_file(package_name)
+  new_feature_request = order * "_" * feature_request_file(package_name)
 
   if isfile(new_feature_request)
     println("File $new_feature_request already exists, skipping")
@@ -43,5 +62,7 @@ for package_name in package_names
 
     println("Replace $template_package_name with $package_name in $new_feature_request")
     replace_in_file(new_feature_request, template_package_name => package_name)
+
+    mv(new_feature_request, joinpath("..", new_feature_request); force=true)
   end
 end
diff --git a/.github/ISSUE_TEMPLATE/template_templates/PACKAGE_bug_report.md b/.github/ISSUE_TEMPLATE/template_templates/PACKAGE_bug_report.md
deleted file mode 100644
index 06e8dd8fa2..0000000000
--- a/.github/ISSUE_TEMPLATE/template_templates/PACKAGE_bug_report.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: PACKAGE.jl report
-about: Create a report to help us improve PACKAGE.jl
-title: "[PACKAGE] [BUG]"
-labels: ["PACKAGE", "bug"]
-assignees: ''
-
----
-
-**Description of bug**
-Describe the bug clearly and concisely.
-
-
-**How to reproduce**
-Detail steps to reproduce the behavior.
-
-
-**Expected behavior**
-Describe what you expected to happen.
-
-
-**Actual behavior**
-Describe what actually happened.
-
-
-**Code demonstrating bug**
-If applicable, provide a minimal working example of the bug.
-
-
-**Version information**
- - output from `versioninfo()` surrounded by backticks (``)
- - output from `] status ITensors` surrounded by backticks (``)
diff --git a/.github/ISSUE_TEMPLATE/template_templates/create_templates.jl b/.github/ISSUE_TEMPLATE/template_templates/create_templates.jl
deleted file mode 100644
index e7a74a6a8c..0000000000
--- a/.github/ISSUE_TEMPLATE/template_templates/create_templates.jl
+++ /dev/null
@@ -1,47 +0,0 @@
-using FileUtils
-
-template_package_name = "PACKAGE"
-
-package_names = [
-  "ITensors",
-  "ITensorGaussianMPS",
-  "ITensorGLMakie",
-  "ITensorGPU",
-  "ITensorMakie",
-  "ITensorUnicodePlots",
-  "ITensorVisualizationBase",
-  "NDTensors",
-]
-
-bug_report_file(package_name::String) = "$(package_name)_bug_report.md"
-feature_request_file(package_name::String) = "$(package_name)_feature_request.md"
-
-for package_name in package_names
-  @show package_name
-
-  template_bug_report = bug_report_file(template_package_name)
-  new_bug_report = bug_report_file(package_name)
-
-  if isfile(new_bug_report)
-    println("File $new_bug_report already exists, skipping")
-  else
-    println("Copying $template_bug_report to $new_bug_report")
-    cp(template_bug_report, new_bug_report)
-
-    println("Replace $template_package_name with $package_name in $new_bug_report")
-    replace_in_file(new_bug_report, template_package_name => package_name)
-  end
-
-  template_feature_request = feature_request_file(template_package_name)
-  new_feature_request = feature_request_file(package_name)
-
-  if isfile(new_feature_request)
-    println("File $new_feature_request already exists, skipping")
-  else
-    println("Copying $template_feature_request to $new_feature_request")
-    cp(template_feature_request, new_feature_request)
-
-    println("Replace $template_package_name with $package_name in $new_feature_request")
-    replace_in_file(new_feature_request, template_package_name => package_name)
-  end
-end
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000000..a6406fd1ec
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,40 @@
+# Description
+
+Please include a summary of the change and which issue is fixed (if applicable). Please also include relevant motivation and context. List any dependencies that are required for this change.
+
+Fixes #(issue)
+
+If practical and applicable, please include a minimal demonstration of the previous behavior and new behavior below.
+
+<details><summary>Minimal demonstration of previous behavior</summary><p>
+
+```julia
+[YOUR MINIMAL DEMONSTRATION OF PREVIOUS BEHAVIOR]
+```
+</p></details>
+
+<details><summary>Minimal demonstration of new behavior</summary><p>
+
+```julia
+[YOUR MINIMAL DEMONSTRATION OF NEW BEHAVIOR]
+```
+</p></details>
+
+# How Has This Been Tested?
+
+Please add tests that verify your changes to a file in the `test` directory.
+
+Please give a summary of the tests that you added to verify your changes.
+
+- [ ] Test A
+- [ ] Test B
+
+# Checklist:
+
+- [ ] My code follows the style guidelines of this project. Please run `using JuliaFormatter; format(".")` in the base directory of the repository (`~/.julia/dev/ITensors`) to format your code according to our style guidelines.
+- [ ] I have performed a self-review of my own code.
+- [ ] I have commented my code, particularly in hard-to-understand areas.
+- [ ] I have added tests that verify the behavior of the changes I made.
+- [ ] I have made corresponding changes to the documentation.
+- [ ] My changes generate no new warnings.
+- [ ] Any dependent changes have been merged and published in downstream modules.
diff --git a/Checklists.txt b/Checklists.txt
index c62a9d6aac..e29ef78712 100644
--- a/Checklists.txt
+++ b/Checklists.txt
@@ -24,3 +24,10 @@ Checklist for Updating the Version of Documenter.jl Used
   number for Documenter (under the [compat] section).
 - Create a new PR to confirm that the docs build correctly 
   with the new version.
+
+Checklist for Updating the Benchmark CI for New Dependencies
+----------------------------------------------------------
+- If you update the dependencies of the NDTensors or ITensors
+module, the changes need to get reflected in the benchmark
+CI setup.
+- See benchmark/README.md for detailed instructions.
diff --git a/ITensorGLMakie/.JuliaFormatter.toml b/ITensorGLMakie/.JuliaFormatter.toml
new file mode 100644
index 0000000000..08f664cdb9
--- /dev/null
+++ b/ITensorGLMakie/.JuliaFormatter.toml
@@ -0,0 +1,2 @@
+style = "blue"
+indent = 2
diff --git a/ITensorGPU/.JuliaFormatter.toml b/ITensorGPU/.JuliaFormatter.toml
new file mode 100644
index 0000000000..08f664cdb9
--- /dev/null
+++ b/ITensorGPU/.JuliaFormatter.toml
@@ -0,0 +1,2 @@
+style = "blue"
+indent = 2
diff --git a/ITensorGPU/NEWS.md b/ITensorGPU/NEWS.md
index 0dbf02fe54..4dae696f10 100644
--- a/ITensorGPU/NEWS.md
+++ b/ITensorGPU/NEWS.md
@@ -6,6 +6,36 @@ Note that as of Julia v1.5, in order to see deprecation warnings you will need t
 
 After we release v1 of the package, we will start following [semantic versioning](https://semver.org).
 
+ITensorGPU v0.0.5 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Clean up `outer` and add GEMM routing for CUDA (#887)
+
+ITensorGPU v0.0.4 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- `cu([[A, B], [C]])` -> `[[cu(A), cu(B)], [cu(C)]]` and same for cpu (#898).
+- Allow cutruncate to work for Float32s (#897).
+
+ITensorGPU v0.0.3 Release Notes
+===============================
+
+Bugs:
+
+- Fix bugs in complex SVD on GPU (with and without truncations) (#871)
+
+Enhancements:
+
+- Remove some unnecessary contract code (#860)
+
 ITensorGPU v0.0.2 Release Notes
 ===============================
 
diff --git a/ITensorGPU/Project.toml b/ITensorGPU/Project.toml
index 6fbec8beab..b67b3c4ad3 100644
--- a/ITensorGPU/Project.toml
+++ b/ITensorGPU/Project.toml
@@ -1,7 +1,7 @@
 name = "ITensorGPU"
 uuid = "d89171c1-af8f-46b3-badf-d2a472317c15"
 authors = ["Katharine Hyatt", "Matthew Fishman <mfishman@flatironinstitute.org>"]
-version = "0.0.2"
+version = "0.0.5"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
@@ -24,7 +24,7 @@ Combinatorics = "1.0.2"
 GPUArrays = "8.1.2"
 GPUCompiler = "0.13.8"
 HDF5 = "0.15.7"
-ITensors = "0.2.12"
+ITensors = "0.3.0"
 StaticArrays = "1.2.13"
 Strided = "1.1.2"
 TimerOutputs = "0.5.13"
diff --git a/ITensorGPU/src/cuitensor.jl b/ITensorGPU/src/cuitensor.jl
index 83a04dc85e..bb5e022e3c 100644
--- a/ITensorGPU/src/cuitensor.jl
+++ b/ITensorGPU/src/cuitensor.jl
@@ -1,3 +1,7 @@
+import ITensors.NDTensors: NeverAlias, AliasStyle, AllowAlias
+import ITensors: ITensor
+import CUDA: CuArray
+
 function cuITensor(::Type{T}, inds::IndexSet) where {T<:Number}
   return ITensor(Dense{float(T)}(CUDA.zeros(float(T), dim(inds))), inds)
 end
@@ -14,6 +18,38 @@ function cuITensor(x::S, inds::IndexSet{N}) where {S<:Number,N}
 end
 cuITensor(x::S, inds::Index...) where {S<:Number} = cuITensor(x, IndexSet(inds...))
 
+function ITensor(
+  as::AliasStyle,
+  eltype::Type{<:Number},
+  A::CuArray{<:Number},
+  inds::Indices{Index{Int}};
+  kwargs...,
+)
+  length(A) ≠ dim(inds) && throw(
+    DimensionMismatch(
+      "In ITensor(::CuArray, inds), length of AbstractArray ($(length(A))) must match total dimension of IndexSet ($(dim(inds)))",
+    ),
+  )
+  data = CuArray{eltype}(as, A)
+  return itensor(Dense(data), inds)
+end
+# Helper functions for different view behaviors
+CuArray{ElT,N}(::NeverAlias, A::AbstractArray) where {ElT,N} = CuArray{ElT,N}(A)
+function CuArray{ElT,N}(::AllowAlias, A::AbstractArray) where {ElT,N}
+  return convert(CuArray{ElT,N}, A)
+end
+function CuArray{ElT}(as::AliasStyle, A::AbstractArray{ElTA,N}) where {ElT,N,ElTA}
+  return CuArray{ElT,N}(as, A)
+end
+
+# TODO: Change to:
+# (Array{ElT, N} where {ElT})([...]) = [...]
+# once support for `VERSION < v"1.6"` is dropped.
+# Previous to Julia v1.6 `where` syntax couldn't be used in a function name
+function CuArray{<:Any,N}(as::AliasStyle, A::AbstractArray{ElTA,N}) where {N,ElTA}
+  return CuArray{ElTA,N}(as, A)
+end
+
 #TODO: check that the size of the Array matches the Index dimensions
 function cuITensor(A::Array{S}, inds) where {S<:Number}
   return ITensor(Dense(CuArray{S}(A)), inds)
@@ -23,6 +59,7 @@ function cuITensor(A::CuArray{S}, inds::IndexSet) where {S<:Number}
 end
 cuITensor(A::Array{S}, inds::Index...) where {S<:Number} = cuITensor(A, IndexSet(inds...))
 cuITensor(A::CuArray{S}, inds::Index...) where {S<:Number} = cuITensor(A, IndexSet(inds...))
+
 function cuITensor(A::ITensor)
   return if storage(tensor(A)) isa ITensors.EmptyStorage
     cuITensor(zero(eltype(storage(tensor(A)))), inds(A)...)
@@ -33,11 +70,19 @@ end
 
 cu(A::ITensor) = cuITensor(A)
 
+# Helpful for moving gate structures to GPU
+cu(A::Array{ITensor}) = map(cu, A)
+cu(A::Array{<:Array{ITensor}}) = map(cu, A)
+
 function cpu(A::ITensor)
   typeof(data(storage(A))) <: CuArray && return ITensor(cpu(storage(A)), inds(A))
   return A
 end
 
+# Helpful for moving gate structures to CPU
+cpu(A::Array{ITensor}) = map(cpu, A)
+cpu(A::Array{<:Array{ITensor}}) = map(cpu, A)
+
 function randomCuITensor(::Type{S}, inds::Indices) where {S<:Real}
   T = cuITensor(S, inds)
   randn!(T)
diff --git a/ITensorGPU/src/tensor/cudense.jl b/ITensorGPU/src/tensor/cudense.jl
index 9ad0eeec0c..c5843abd4b 100644
--- a/ITensorGPU/src/tensor/cudense.jl
+++ b/ITensorGPU/src/tensor/cudense.jl
@@ -1,3 +1,5 @@
+using LinearAlgebra: BlasFloat
+
 const CuDense{ElT,VecT} = Dense{ElT,VecT} where {VecT<:CuVector}
 const CuDenseTensor{ElT,N,StoreT,IndsT} = Tensor{ElT,N,StoreT,IndsT} where {StoreT<:CuDense}
 
@@ -14,6 +16,7 @@ function Dense{T,S}(x::T, size::Integer) where {T,S<:CuArray{<:T}}
   return Dense{T,S}(arr)
 end
 cpu(x::CuDense{T}) where {T<:Number} = Dense(collect(x.data))
+cpu(x::CuDenseTensor{T}) where {T<:Number} = Tensor(inds(x), cpu(store(x)))
 function Base.complex(::Type{Dense{ElT,VT}}) where {ElT,VT<:CuArray}
   return Dense{complex(ElT),CuVector{complex(ElT)}}
 end
@@ -35,6 +38,13 @@ Base.getindex(D::CuDense{<:Number}) = collect(data(D))[]
 Base.getindex(D::CuDenseTensor{<:Number,0}) = store(D)[]
 LinearAlgebra.norm(T::CuDenseTensor) = norm(data(store(T)))
 
+function Base.copyto!(R::CuDenseTensor{<:Number,N}, T::CuDenseTensor{<:Number,N}) where {N}
+  RA = array(R)
+  TA = array(T)
+  RA .= TA
+  return R
+end
+
 # This is for type promotion for Scalar*Dense
 function Base.promote_rule(
   ::Type{<:Dense{ElT1,CuVector{ElT1}}}, ::Type{ElT2}
@@ -44,19 +54,6 @@ function Base.promote_rule(
   return Dense{ElR,VecR}
 end
 
-function Base.permutedims(T::CuDenseTensor{<:Number,N}, perm::NTuple{N,Int}) where {N}
-  Tp = NDTensors.similar(T, ITensors.NDTensors.permute(inds(T), perm))
-  #Tp = permute(T,perm; always_copy=true)
-  permute!(Tp, T)
-  return Tp
-end
-
-function Base.permutedims!(
-  R::CuDenseTensor{<:Number,N}, T::CuDenseTensor{<:Number,N}, perm::NTuple{N,Int}
-) where {N}
-  return permutedims!!(R, T, perm)
-end
-
 function permutedims!!(
   B::Tensor{ElT,N,StoreT,IndsB},
   A::Tensor{ElT,N,StoreT,IndsA},
@@ -79,11 +76,59 @@ function Base.similar(::Type{<:CuDenseTensor{ElT}}, inds) where {ElT}
   return Tensor(Dense(storage_arr), inds)
 end
 
-function outer!(R::CuDenseTensor, T1::CuDenseTensor, T2::CuDenseTensor)
-  R_dat = vec(array(T1)) * transpose(vec(array(T2)))
-  copyto!(data(store(R)), vec(R_dat))
-  inds_outer = unioninds(inds(T1), inds(T2))
-  return R
+import ITensors.NDTensors: GemmBackend, auto_select_backend, _gemm!
+function backend_cutensor()
+  return gemm_backend[] = :CUTENSOR
+end
+function backend_cublas()
+  return gemm_backend[] = :CUBLAS
+end
+
+@inline function auto_select_backend(
+  ::Type{<:CuArray{<:BlasFloat}},
+  ::Type{<:CuArray{<:BlasFloat}},
+  ::Type{<:CuArray{<:BlasFloat}},
+)
+  return GemmBackend(:CUBLAS)
+end
+
+@inline function auto_select_backend(
+  ::Type{<:CuArray{<:BlasFloat}}, ::Type{<:CuArray{<:BlasFloat}}, ::Type{<:AbstractVecOrMat}
+)
+  return GemmBackend(:GenericCUDA)
+end
+
+# CUBLAS matmul
+function _gemm!(
+  ::GemmBackend{:CUBLAS},
+  tA,
+  tB,
+  alpha,
+  A::AbstractVecOrMat,
+  B::AbstractVecOrMat,
+  beta,
+  C::AbstractVecOrMat,
+)
+  return CUBLAS.gemm!(tA, tB, alpha, A, B, beta, C)
+end
+
+# CUDA generic matmul
+function _gemm!(
+  ::GemmBackend{:GenericCUDA},
+  tA,
+  tB,
+  alpha,
+  A::AbstractVecOrMat,
+  B::AbstractVecOrMat,
+  beta,
+  C::CuDenseTensor,
+)
+  C_dat = reshape(data(store(C)), size(C))
+  A_ = tA == 'T' ? transpose(A) : A
+  B_ = tB == 'T' ? transpose(B) : B
+  C_dat = mul!(C_dat, A_, B_, alpha, beta)
+  copyto!(data(store(C)), C_dat)
+  return C
 end
 
 function _contract_scalar!(
@@ -485,7 +530,7 @@ function Base.permute!(B::CuDenseTensor, A::CuDenseTensor)
   Bdata = data(store(B))
   reshapeBdata = reshape(Bdata, dims(Bis)...)
   reshapeAdata = reshape(Adata, dims(Ais)...)
-  if ndims(A) < 12 # use CUTENSOR
+  if ndims(A) < 40 # use CUTENSOR
     ctainds = zeros(Int, length(Ais))
     ctbinds = zeros(Int, length(Bis))
     for (ii, ia) in enumerate(Ais)
@@ -510,7 +555,7 @@ function Base.permute!(B::CuDenseTensor, A::CuDenseTensor)
     @assert isperm(perm)
     permutedims!(reshapeBdata, reshapeAdata, invperm(perm))
   end
-  return vec(reshapeBdata)
+  return Tensor(inds(B), Dense(vec(reshapeBdata)))
 end
 
 function Base.permute!(B::CuDense, Bis::IndexSet, A::CuDense, Ais::IndexSet)
@@ -538,7 +583,7 @@ function Base.permute!(B::CuDense, Bis::IndexSet, A::CuDense, Ais::IndexSet)
     reshapeBdata,
     Vector{Char}(ctbinds),
   )
-  return vec(reshapeBdata)
+  return Tensor(Bis, Dense(vec(reshapeBdata)))
 end
 
 Base.:/(A::CuDenseTensor, x::Number) = A * inv(x)
diff --git a/ITensorGPU/src/tensor/culinearalgebra.jl b/ITensorGPU/src/tensor/culinearalgebra.jl
index 7a39bc5bd8..b981db5f55 100644
--- a/ITensorGPU/src/tensor/culinearalgebra.jl
+++ b/ITensorGPU/src/tensor/culinearalgebra.jl
@@ -40,7 +40,10 @@ function LinearAlgebra.svd(T::CuDenseTensor{ElT,2,IndsT}; kwargs...) where {ElT,
   @timeit "CUSOLVER svd" begin
     MU, MS, MV = CUSOLVER.svd!(aT)
   end
-  #conj!(MV)
+  # for consistency with cpu version, 
+  # ITensors.jl/NDTensors/src/linearalgebra.jl/svd
+  # need conj!(MV)
+  conj!(MV)
   P = MS .^ 2
   truncerr, docut, P = truncate!(
     P;
diff --git a/ITensorGPU/src/tensor/cutruncate.jl b/ITensorGPU/src/tensor/cutruncate.jl
index 14861d7e88..aff32e2ca2 100644
--- a/ITensorGPU/src/tensor/cutruncate.jl
+++ b/ITensorGPU/src/tensor/cutruncate.jl
@@ -1,78 +1,69 @@
-function truncate!(
-  P::CuVector{Float64}; kwargs...
-)::Tuple{Float64,Float64,CuVector{Float64}}
+import LinearAlgebra: BlasReal
+
+function truncate!(P::CuVector{T}; kwargs...)::Tuple{T,T,CuVector{T}} where {T<:BlasReal}
   maxdim::Int = min(get(kwargs, :maxdim, length(P)), length(P))
   mindim::Int = min(get(kwargs, :mindim, 1), maxdim)
   cutoff::Float64 = get(kwargs, :cutoff, 0.0)
   absoluteCutoff::Bool = get(kwargs, :absoluteCutoff, false)
   doRelCutoff::Bool = get(kwargs, :doRelCutoff, true)
   origm = length(P)
-  docut = 0.0
+  docut = zero(T)
+  # handle the case where nothing is to be cut off
+  minP = minimum(P)
+  if minP > cutoff
+    return zero(T), zero(T), P
+  end
   maxP = maximum(P)
-  if maxP == 0.0
-    P = CUDA.zeros(Float64, 1)
-    return 0.0, 0.0, P
+  if maxP == zero(T)
+    P = CUDA.zeros(T, 1)
+    return zero(T), zero(T), P
   end
   if origm == 1
     docut = maxP / 2
-    return 0.0, docut, P[1:1]
+    return zero(T), docut, P[1:1]
   end
-
   @timeit "setup rP" begin
     #Zero out any negative weight
     #neg_z_f = (!signbit(x) ? x : 0.0)
-    rP = map(x -> !signbit(x) ? x : 0.0, P)
+    rP = map(x -> !signbit(x) ? Float64(x) : 0.0, P)
     n = origm
-    truncerr = 0.0
-    if n > maxdim
-      truncerr = sum(rP[1:(n - maxdim)])
-      n = maxdim
-    end
   end
   @timeit "handle cutoff" begin
     if absoluteCutoff
       #Test if individual prob. weights fall below cutoff
       #rather than using *sum* of discarded weights
-      sub_arr = rP .- cutoff
+      sub_arr = rP .- Float64(cutoff)
       err_rP = sub_arr ./ abs.(sub_arr)
       flags = reinterpret(Float64, (signbit.(err_rP) .<< 1 .& 2) .<< 61)
       cut_ind = CUDA.CUBLAS.iamax(length(err_rP), err_rP .* flags) - 1
-      n = min(maxdim, length(P) - cut_ind)
+      n = min(maxdim, cut_ind)
       n = max(n, mindim)
-      truncerr += sum(rP[(cut_ind + 1):end])
+      truncerr = T(sum(rP[(n + 1):end]))
     else
-      scale = 1.0
+      truncerr = zero(T)
+      scale = one(T)
       @timeit "find scale" begin
         if doRelCutoff
           scale = sum(P)
-          scale = scale > 0.0 ? scale : 1.0
+          scale = scale > zero(T) ? scale : one(T)
         end
       end
-
-      #Continue truncating until *sum* of discarded probability 
+      #Truncating until *sum* of discarded probability 
       #weight reaches cutoff reached (or m==mindim)
-      sub_arr = rP .+ truncerr .- cutoff * scale
+      csum_rp = Float64.(CUDA.reverse(CUDA.cumsum(CUDA.reverse(rP))))
+      sub_arr = csum_rp .- Float64(cutoff * scale)
       err_rP = sub_arr ./ abs.(sub_arr)
       flags = reinterpret(Float64, (signbit.(err_rP) .<< 1 .& 2) .<< 61)
-      cut_ind = CUDA.CUBLAS.iamax(length(err_rP), err_rP .* flags) - 1
+      cut_ind = (CUDA.CUBLAS.iamax(length(err_rP), err_rP .* flags) - 1)
       if cut_ind > 0
-        truncerr += sum(rP[(cut_ind + 1):end])
-        n = min(maxdim, length(P) - cut_ind)
-        n = max(n, mindim)
-        if scale == 0.0
-          truncerr = 0.0
-        else
-          truncerr /= scale
-        end
-      else # all are above cutoff
-        truncerr += sum(rP[1:maxdim])
-        n = min(maxdim, length(P) - cut_ind)
+        n = min(maxdim, cut_ind)
         n = max(n, mindim)
-        if scale == 0.0
-          truncerr = 0.0
-        else
-          truncerr /= scale
-        end
+        truncerr = sum(rP[(n + 1):end])
+      end
+      if scale == zero(T)
+        truncerr = zero(T)
+      else
+        truncerr /= scale
       end
     end
   end
@@ -83,7 +74,7 @@ function truncate!(
     hP = collect(P)
     docut = (hP[n] + hP[n + 1]) / 2
     if abs(hP[n] - hP[n + 1]) < 1E-3 * hP[n]
-      docut += 1E-3 * hP[n]
+      docut += T(1E-3) * hP[n]
     end
   end
   @timeit "setup return" begin
diff --git a/ITensorGPU/test/test_cudense.jl b/ITensorGPU/test/test_cudense.jl
index 65108cfb9c..4cc7567f03 100644
--- a/ITensorGPU/test/test_cudense.jl
+++ b/ITensorGPU/test/test_cudense.jl
@@ -37,8 +37,8 @@ using ITensors,
     B = [SType(0.0) for ii in 1:dim(j), jj in 1:dim(j)]
     dB = ITensorGPU.CuDense{SType,CuVector{SType}}(SType(0.0), dim(i) * dim(j))
     dC = permute!(dB, IndexSet(j, i), dA, IndexSet(i, j))
-    hC = collect(dC)
-    @test vec(transpose(A)) == hC
+    hC = cpu(dC)
+    @test transpose(A) == hC
   end
   @testset "Test move CuDense on/off GPU" begin
     A = [SType(1.0) for ii in 1:dim(i), jj in 1:dim(j)]
diff --git a/ITensorGPU/test/test_cuitensor.jl b/ITensorGPU/test/test_cuitensor.jl
index 0193ab9262..d37da607f2 100644
--- a/ITensorGPU/test/test_cuitensor.jl
+++ b/ITensorGPU/test/test_cuitensor.jl
@@ -102,16 +102,22 @@ using ITensors,
 
   @testset "Test factorizations of a cuITensor" begin
     A = randomCuITensor(SType, i, j, k, l)
-
     @testset "Test SVD of a cuITensor" begin
       U, S, V = svd(A, (j, l))
       u = commonind(U, S)
       v = commonind(S, V)
-      @test cpu(A) ≈ cpu(U * S * dag(V))
+      @test cpu(A) ≈ cpu(U * S * V)
       @test cpu(U * dag(prime(U, u))) ≈ δ(SType, u, u') rtol = 1e-14
       @test cpu(V * dag(prime(V, v))) ≈ δ(SType, v, v') rtol = 1e-14
     end
 
+    A = randomCuITensor(SType, i, j, k, l)
+    @testset "Test SVD consistency between CPU and GPU" begin
+      U_gpu, S_gpu, V_gpu = svd(A, (j, l))
+      U_cpu, S_cpu, V_cpu = svd(cpu(A), (j, l))
+      @test cpu(U_gpu) * cpu(S_gpu) * cpu(V_gpu) ≈ U_cpu * S_cpu * V_cpu
+    end
+
     #=@testset "Test SVD truncation" begin 
         M = randn(4,4)
         (U,s,V) = svd(M)
diff --git a/ITensorGPU/test/test_cumpo.jl b/ITensorGPU/test/test_cumpo.jl
index 3a10710b82..059aeb7bdb 100644
--- a/ITensorGPU/test/test_cumpo.jl
+++ b/ITensorGPU/test/test_cumpo.jl
@@ -31,10 +31,10 @@ using ITensors, ITensorGPU, Test
     K = randomCuMPO(sites)
     orthogonalize!(phi, 1)
     orthogonalize!(K, 1)
-    orig_inner = inner(phi, K, phi)
+    orig_inner = inner(phi', K, phi)
     orthogonalize!(phi, div(N, 2))
     orthogonalize!(K, div(N, 2))
-    @test inner(phi, K, phi) ≈ orig_inner
+    @test inner(phi', K, phi) ≈ orig_inner
   end
 
   @testset "inner <y|A|x>" begin
@@ -48,11 +48,11 @@ using ITensors, ITensorGPU, Test
     for j in 2:N
       phiKpsi *= phidag[j] * K[j] * psi[j]
     end
-    @test phiKpsi[] ≈ inner(phi, K, psi)
+    @test phiKpsi[] ≈ inner(phi', K, psi)
 
     badsites = [Index(2, "Site") for n in 1:(N + 1)]
     badpsi = randomCuMPS(badsites)
-    @test_throws DimensionMismatch inner(phi, K, badpsi)
+    @test_throws DimensionMismatch inner(phi', K, badpsi)
 
     # make bigger random MPO...
     for link_dim in 2:5
@@ -90,7 +90,7 @@ using ITensors, ITensorGPU, Test
       for j in 2:N
         phiKpsi *= phidag[j] * K[j] * psi[j]
       end
-      @test scalar(phiKpsi) ≈ inner(phi, K, psi)
+      @test scalar(phiKpsi) ≈ inner(phi', K, psi)
     end
   end
 
@@ -100,8 +100,8 @@ using ITensors, ITensorGPU, Test
     @test maxlinkdim(K) == 1
     psi = randomCuMPS(sites)
     psi_out = contract(K, psi; maxdim=1)
-    @test inner(phi, psi_out) ≈ inner(phi, K, psi)
-    @test_throws ArgumentError contract(K, psi, method="fakemethod")
+    @test inner(phi', psi_out) ≈ inner(phi', K, psi)
+    @test_throws MethodError contract(K', psi, method="fakemethod")
 
     badsites = [Index(2, "Site") for n in 1:(N + 1)]
     badpsi = randomCuMPS(badsites)
@@ -138,7 +138,7 @@ using ITensors, ITensorGPU, Test
       orthogonalize!(K, 1; maxdim=link_dim)
       orthogonalize!(phi, 1; normalize=true, maxdim=link_dim)
       psi_out = contract(deepcopy(K), deepcopy(psi); maxdim=10 * link_dim, cutoff=0.0)
-      @test inner(phi, psi_out) ≈ inner(phi, K, psi)
+      @test inner(phi', psi_out) ≈ inner(phi', K, psi)
     end
   end
   @testset "add" begin
@@ -150,7 +150,7 @@ using ITensors, ITensorGPU, Test
     psi = randomCuMPS(shsites)
     k_psi = contract(K, psi; maxdim=1)
     l_psi = contract(L, psi; maxdim=1)
-    @test inner(psi, add(k_psi, l_psi)) ≈ inner(psi, M, psi) atol = 5e-3
+    @test inner(psi', add(k_psi, l_psi)) ≈ inner(psi', M, psi) atol = 5e-3
   end
   @testset "contract(::CuMPO, ::CuMPO)" begin
     psi = randomCuMPS(sites)
@@ -160,7 +160,7 @@ using ITensors, ITensorGPU, Test
     @test maxlinkdim(L) == 1
     KL = contract(prime(K), L; maxdim=1)
     psi_kl_out = contract(prime(K), contract(L, psi; maxdim=1); maxdim=1)
-    @test inner(psi, KL, psi) ≈ inner(psi, psi_kl_out) atol = 5e-3
+    @test inner(psi'', KL, psi) ≈ inner(psi'', psi_kl_out) atol = 5e-3
 
     # where both K and L have differently labelled sites
     othersitesk = [Index(2, "Site,aaa") for n in 1:N]
diff --git a/ITensorGPU/test/test_cutruncate.jl b/ITensorGPU/test/test_cutruncate.jl
index 2de15381ef..5e6a0b0781 100644
--- a/ITensorGPU/test/test_cutruncate.jl
+++ b/ITensorGPU/test/test_cutruncate.jl
@@ -6,15 +6,27 @@ using ITensors,
 
 # gpu tests!
 @testset "cutrunctate" begin
-  @test ITensorGPU.truncate!(CUDA.zeros(Float64, 10)) == (0.0, 0.0, CUDA.zeros(Float64, 1))
-  trunc = ITensorGPU.truncate!(
-    CuArray([1.0, 0.5, 0.1, 0.05]); absoluteCutoff=true, cutoff=0.2
-  )
-  @test trunc[1] ≈ 0.15
-  @test trunc[2] ≈ 0.3
-  @test trunc[3] == CuArray([1.0, 0.5])
-  trunc = ITensorGPU.truncate!(CuArray([0.5, 0.4, 0.1]); relativeCutoff=true, cutoff=0.2)
-  @test trunc[1] ≈ 0.1
-  @test trunc[2] ≈ 0.45
-  @test trunc[3] == CuArray([0.5])
+  @testset for T in (Float32, Float64)
+    @test ITensorGPU.truncate!(CUDA.zeros(T, 10)) == (zero(T), zero(T), CUDA.zeros(T, 1))
+    trunc = ITensorGPU.truncate!(
+      CuArray(T[1.0, 0.5, 0.4, 0.1, 0.05]); absoluteCutoff=true, cutoff=T(0.2)
+    )
+    @test trunc[1] ≈ T(0.15)
+    @test trunc[2] ≈ T(0.25)
+    @test Array(trunc[3]) == T[1.0, 0.5, 0.4]
+    trunc = ITensorGPU.truncate!(
+      CuArray(T[0.4, 0.26, 0.19, 0.1, 0.05]); relativeCutoff=true, cutoff=T(0.2)
+    )
+    @test trunc[1] ≈ T(0.15)
+    @test trunc[2] ≈ T(0.145)
+    @test Array(trunc[3]) == T[0.4, 0.26, 0.19]
+    trunc = ITensorGPU.truncate!(
+      CuArray(convert(Vector{T}, [0.4, 0.26, 0.19, 0.1, 0.05] / 2));
+      relativeCutoff=true,
+      cutoff=T(0.2),
+    )
+    @test trunc[1] ≈ T(0.15)
+    @test trunc[2] ≈ T(0.145 / 2)
+    @test Array(trunc[3]) == convert(Vector{T}, [0.4, 0.26, 0.19] / 2)
+  end
 end # End truncate test
diff --git a/ITensorGaussianMPS/NEWS.md b/ITensorGaussianMPS/NEWS.md
index f41d4c8971..9a08924a85 100644
--- a/ITensorGaussianMPS/NEWS.md
+++ b/ITensorGaussianMPS/NEWS.md
@@ -6,7 +6,39 @@ Note that as of Julia v1.5, in order to see deprecation warnings you will need t
 
 After we release v1 of the package, we will start following [semantic versioning](https://semver.org).
 
+ITensors v0.0.4 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Update for new OpSum representation and interface (#920)
+- Add check for proper fermionic operators when making hopping Hamiltonian (#920)
+
+ITensors v0.0.3 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Add support for GMERA (#879)
+
+ITensors v0.0.2 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Bump to ITensors 0.3 (#880)
+
 ITensors v0.0.1 Release Notes
-==============================
+=============================
+
+Bugs:
+
+Enhancements:
 
 - Move ITensorGaussianMPS package into ITensors repository (#792)
diff --git a/ITensorGaussianMPS/Project.toml b/ITensorGaussianMPS/Project.toml
index a556e045be..0d67ebe084 100644
--- a/ITensorGaussianMPS/Project.toml
+++ b/ITensorGaussianMPS/Project.toml
@@ -1,7 +1,7 @@
 name = "ITensorGaussianMPS"
 uuid = "2be41995-7c9f-4653-b682-bfa4e7cebb93"
 authors = ["Matthew Fishman <mfishman@flatironinstitute.org> and contributors"]
-version = "0.0.1"
+version = "0.0.4"
 
 [deps]
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
@@ -10,5 +10,5 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
 Compat = "3.40.0"
-ITensors = "0.2.12"
+ITensors = "0.3.14"
 julia = "1.6"
diff --git a/ITensorGaussianMPS/src/ITensorGaussianMPS.jl b/ITensorGaussianMPS/src/ITensorGaussianMPS.jl
index 7669a5645e..5885d83f60 100644
--- a/ITensorGaussianMPS/src/ITensorGaussianMPS.jl
+++ b/ITensorGaussianMPS/src/ITensorGaussianMPS.jl
@@ -8,8 +8,12 @@ using LinearAlgebra
 import LinearAlgebra: Givens
 
 export slater_determinant_to_mps,
-  slater_determinant_to_gmps, hopping_hamiltonian, slater_determinant_matrix
+  slater_determinant_to_gmps,
+  hopping_hamiltonian,
+  slater_determinant_matrix,
+  slater_determinant_to_gmera
 
 include("gmps.jl")
+include("gmera.jl")
 
 end
diff --git a/ITensorGaussianMPS/src/gmera.jl b/ITensorGaussianMPS/src/gmera.jl
new file mode 100644
index 0000000000..d630b8d4ee
--- /dev/null
+++ b/ITensorGaussianMPS/src/gmera.jl
@@ -0,0 +1,182 @@
+# brick wall scanning for a single MERA layer with treatment to the tail
+function correlation_matrix_to_gmps_brickwall_tailed(
+  Λ0::AbstractMatrix{ElT},
+  inds::Vector{Int};
+  eigval_cutoff::Float64=1e-8,
+  maxblocksize::Int=size(Λ0, 1),
+) where {ElT<:Number}
+  Λ = Hermitian(Λ0)
+  N = size(Λ, 1)
+  V = Circuit{ElT}([])
+  #ns = Vector{real(ElT)}(undef, 2*N)
+  err_tot = 0.0
+  indsnext = Int[]
+  relinds = Int[]
+  for i in 1:N
+    if i % 2 == 0
+      append!(indsnext, inds[i])
+      append!(relinds, i)
+      continue
+    end
+    blocksize = 0
+    n = 0.0
+    err = 0.0
+    p = Int[]
+    uB = 0.0
+    # find the block whose lowest eigenvalue is within torelence
+    for blocksize in 1:maxblocksize
+      j = min(i + blocksize, N)
+      ΛB = deepcopy(Λ[i:j, i:j]) #@view Λ[i:j, i:j] # \LambdaB is still part of Lambda
+      nB, uB = eigen(Hermitian(ΛB))
+      # sort by -(n * log(n) + (1 - n) * log(1 - n)) in ascending order
+      p = sortperm(nB; by=entropy)
+      n = nB[p[1]]
+      err = min(n, 1 - n)
+      err ≤ eigval_cutoff && break
+    end
+    # keep the node if the err cannot be reduced
+    if i + maxblocksize >= N && err > eigval_cutoff
+      append!(indsnext, inds[i])
+      append!(relinds, i)
+      continue
+    end
+    err_tot += err
+    #ns[i] = n # eigenvalue
+    v = deepcopy(uB[:, p[1]]) #@view uB[:, p[1]] # eigenvector of the correlation matrix
+    g, _ = givens_rotations(v) # convert eigenvector into givens rotation
+    shift!(g, i - 1) # shift rotation location
+    # In-place version of:
+    # V = g * V
+    lmul!(g, V)
+    #@show g
+    Λ = Hermitian(g * Λ * g') #isolate current site i
+  end
+  return Λ, V, indsnext, relinds
+end
+
+# shift givens rotation indexes according to the inds 
+function shiftByInds!(G::Circuit, inds::Vector{Int})
+  for (n, g) in enumerate(G.rotations)
+    G.rotations[n] = Givens(inds[g.i1], inds[g.i2], g.c, g.s)
+  end
+  return G
+end
+
+"""
+    correlation_matrix_to_gmera(Λ::AbstractMatrix{ElT}; eigval_cutoff::Float64 = 1e-8, maxblocksize::Int = size(Λ0, 1))
+Diagonalize a correlation matrix through MERA layers,
+output gates and eigenvalues of the correlation matrix
+"""
+# Combine gates for each MERA layer
+function correlation_matrix_to_gmera(
+  Λ0::AbstractMatrix{ElT}; eigval_cutoff::Float64=1e-8, maxblocksize::Int=size(Λ0, 1)
+) where {ElT<:Number}
+  Λ = Hermitian(Λ0)
+  N = size(Λ, 1)
+  Nnew = N - 1
+  inds = collect(1:N)
+  V = Circuit{ElT}([])
+  Λtemp = deepcopy(Λ)
+  layer = 0                                 # layer label of MERA
+  while N > Nnew # conditioned on the reduction of nodes
+    N = Nnew
+    # indsnext: next layer indexes with original matrix labels
+    # relinds: next layer indexes with labels from the last layer
+    Λr, C, indsnext, relinds = correlation_matrix_to_gmps_brickwall_tailed(
+      Λtemp, inds; eigval_cutoff=eigval_cutoff, maxblocksize=maxblocksize
+    )
+    shiftByInds!(C, inds)    # shift the index back to the original matrix
+    inds = indsnext
+    Λtemp = deepcopy(Λr[relinds, relinds]) # project to even site for next layer based on keeping indexes relinds
+    Nnew = size(Λtemp, 1)
+    lmul!(C, V)                           # add vector of givens rotation C into the larger vector V
+    #V = C * V
+    layer += 1
+    #Λ = ITensors.Hermitian(C * Λ * C')
+  end
+  # gmps for the final layer
+  Λr, C = correlation_matrix_to_gmps(
+    Λtemp; eigval_cutoff=eigval_cutoff, maxblocksize=maxblocksize
+  )
+  shiftByInds!(C, inds)
+  lmul!(C, V)
+  Λ = V * Λ0 * V'
+  ns = real.(diag(Λ))
+  return ns, V
+end
+
+# output the MERA gates and eigenvalues of correlation matrix from WF
+function slater_determinant_to_gmera(Φ::AbstractMatrix; kwargs...)
+  return correlation_matrix_to_gmera(conj(Φ) * transpose(Φ); kwargs...)
+end
+
+# ouput the MPS based on the MERA gates
+function correlation_matrix_to_mera(
+  s::Vector{<:Index},
+  Λ::AbstractMatrix;
+  eigval_cutoff::Float64=1e-8,
+  maxblocksize::Int=size(Λ, 1),
+  kwargs...,
+)
+  @assert size(Λ, 1) == size(Λ, 2)
+  ns, C = correlation_matrix_to_gmera(
+    Λ; eigval_cutoff=eigval_cutoff, maxblocksize=maxblocksize
+  )
+  if all(hastags("Fermion"), s)
+    U = [ITensor(s, g) for g in reverse(C.rotations)]
+    ψ = MPS(s, n -> round(Int, ns[n]) + 1, U; kwargs...)
+  elseif all(hastags("Electron"), s)
+    isodd(length(s)) && error(
+      "For Electron type, must have even number of sites of alternating up and down spins.",
+    )
+    N = length(s)
+    if isspinful(s)
+      error(
+        "correlation_matrix_to_mps(Λ::AbstractMatrix) currently only supports spinless Fermions or Electrons that do not conserve Sz. Use correlation_matrix_to_mps(Λ_up::AbstractMatrix, Λ_dn::AbstractMatrix) to use spinful Fermions/Electrons.",
+      )
+    else
+      sf = siteinds("Fermion", 2 * N; conserve_qns=true)
+    end
+    U = [ITensor(sf, g) for g in reverse(C.rotations)]
+    ψf = MPS(sf, n -> round(Int, ns[n]) + 1, U; kwargs...)
+    ψ = MPS(N)
+    for n in 1:N
+      i, j = 2 * n - 1, 2 * n
+      C = combiner(sf[i], sf[j])
+      c = combinedind(C)
+      ψ[n] = ψf[i] * ψf[j] * C
+      ψ[n] *= δ(dag(c), s[n])
+    end
+  else
+    error("All sites must be Fermion or Electron type.")
+  end
+  return ψ
+end
+
+function slater_determinant_to_mera(s::Vector{<:Index}, Φ::AbstractMatrix; kwargs...)
+  return correlation_matrix_to_mera(s, conj(Φ) * transpose(Φ); kwargs...)
+end
+
+# G the circuit from the gates, N is the total number of sites
+function UmatFromGates(G::Circuit, N::Int)
+  U = Matrix{Float64}(I, N, N)
+  n = size(G.rotations, 1)
+  for k in 1:n
+    rot = G.rotations[k]
+    U = rot * U
+  end
+  return U
+end
+
+# compute the energy of the state based on the gates
+function EfromGates(H::Matrix{<:Number}, U::Matrix{<:Number})
+  Htemp = U * H * U'
+  Etot = 0
+  N = size(U, 1)
+  for i in 1:N
+    if Htemp[i, i] < 0.0
+      Etot += Htemp[i, i]
+    end
+  end
+  return Etot
+end
diff --git a/ITensorGaussianMPS/src/gmps.jl b/ITensorGaussianMPS/src/gmps.jl
index 34ff0b6377..602f4135d8 100644
--- a/ITensorGaussianMPS/src/gmps.jl
+++ b/ITensorGaussianMPS/src/gmps.jl
@@ -91,19 +91,40 @@ ngates(G::Circuit) = length(G.rotations)
 # Free fermion tools
 #
 
+is_creation_operator(o::Op) = is_creation_operator(ITensors.name(o))
+is_creation_operator(o::String) = is_creation_operator(OpName(o))
+is_creation_operator(::OpName) = false
+is_creation_operator(::OpName"Cdag") = true
+is_creation_operator(::OpName"Cdagup") = true
+is_creation_operator(::OpName"Cdagdn") = true
+is_creation_operator(::OpName"c†") = true
+is_creation_operator(::OpName"c†↑") = true
+is_creation_operator(::OpName"c†↓") = true
+
+is_annihilation_operator(o::Op) = is_annihilation_operator(ITensors.name(o))
+is_annihilation_operator(o::String) = is_annihilation_operator(OpName(o))
+is_annihilation_operator(::OpName) = false
+is_annihilation_operator(::OpName"C") = true
+is_annihilation_operator(::OpName"Cup") = true
+is_annihilation_operator(::OpName"Cdn") = true
+is_annihilation_operator(::OpName"c") = true
+is_annihilation_operator(::OpName"c↑") = true
+is_annihilation_operator(::OpName"c↓") = true
+
 # Make a hopping Hamiltonian from quadratic Hamiltonian
-function hopping_hamiltonian(ampo::AutoMPO)
-  nterms = length(ampo.data)
+function hopping_hamiltonian(os::OpSum)
+  nterms = length(os)
   coefs = Vector{Number}(undef, nterms)
   sites = Vector{Tuple{Int,Int}}(undef, nterms)
   nsites = 0
   for n in 1:nterms
-    term = ampo.data[n]
-    coef = isreal(term.coef) ? real(term.coef) : term.coef
+    term = os[n]
+    coef = isreal(coefficient(term)) ? real(coefficient(term)) : term.coef
     coefs[n] = coef
-    ops = term.ops
-    length(ops) != 2 && error("Must create hopping Hamiltonian from quadratic Hamiltonian")
-    sites[n] = ntuple(n -> only(ops[n].site), Val(2))
+    length(term) ≠ 2 && error("Must create hopping Hamiltonian from quadratic Hamiltonian")
+    @assert is_creation_operator(term[1])
+    @assert is_annihilation_operator(term[2])
+    sites[n] = ntuple(n -> ITensors.site(term[n]), Val(2))
     nsites = max(nsites, maximum(sites[n]))
   end
   ElT = all(isreal(coefs)) ? Float64 : ComplexF64
@@ -115,9 +136,9 @@ function hopping_hamiltonian(ampo::AutoMPO)
 end
 
 # Make a combined hopping Hamiltonian for spin up and down
-function hopping_hamiltonian(ampo_up::AutoMPO, ampo_dn::AutoMPO)
-  h_up = hopping_hamiltonian(ampo_up)
-  h_dn = hopping_hamiltonian(ampo_dn)
+function hopping_hamiltonian(os_up::OpSum, os_dn::OpSum)
+  h_up = hopping_hamiltonian(os_up)
+  h_dn = hopping_hamiltonian(os_dn)
   @assert size(h_up) == size(h_dn)
   N = size(h_up, 1)
   ElT = promote_type(eltype(h_up), eltype(h_dn))
@@ -141,10 +162,6 @@ function slater_determinant_matrix(h::AbstractMatrix, Nf::Int)
   return u[:, 1:Nf]
 end
 
-function Base.:+(a1::AutoMPO, a2::AutoMPO)
-  return AutoMPO(vcat(a1.data, a2.data))
-end
-
 #
 # Correlation matrix diagonalization
 #
diff --git a/ITensorGaussianMPS/test/electron.jl b/ITensorGaussianMPS/test/electron.jl
index 1328dc3b35..d0d7c5d243 100644
--- a/ITensorGaussianMPS/test/electron.jl
+++ b/ITensorGaussianMPS/test/electron.jl
@@ -86,7 +86,7 @@ end
   end
 
   H_noninteracting = MPO(os_noninteracting, s)
-  @test tr(Φ_up' * h_up * Φ_up) + tr(Φ_dn' * h_dn * Φ_dn) ≈ inner(ψ0, H_noninteracting, ψ0) rtol =
+  @test tr(Φ_up' * h_up * Φ_up) + tr(Φ_dn' * h_dn * Φ_dn) ≈ inner(ψ0', H_noninteracting, ψ0) rtol =
     1e-3
 
   # The total interacting Hamiltonian
@@ -108,7 +108,7 @@ end
   @test flux(ψr) == QN(("Nf", Nf, -1), ("Sz", 0))
   @test flux(ψ0) == QN(("Nf", Nf, -1), ("Sz", 0))
 
-  @test inner(ψ0, H, ψ0) < inner(ψr, H, ψr)
+  @test inner(ψ0', H, ψ0) < inner(ψr', H, ψr)
 
   sweeps = Sweeps(3)
   setmaxdim!(sweeps, 10, 20, _maxlinkdim)
@@ -122,7 +122,7 @@ end
   setnoise!(sweeps, 1e-5, 1e-6, 1e-7, 0.0)
   e0, _ = dmrg(H, ψ0, sweeps; outputlevel=0)
 
-  @test e0 > inner(ψ0, H_noninteracting, ψ0)
+  @test e0 > inner(ψ0', H_noninteracting, ψ0)
   @test e0 < er
 end
 
@@ -147,7 +147,7 @@ end
   Φ_up = slater_determinant_matrix(h_up, Nf_up)
   Φ_dn = slater_determinant_matrix(h_dn, Nf_dn)
   ψ = slater_determinant_to_mps(s, Φ_up, Φ_dn; eigval_cutoff=0.0, cutoff=0.0)
-  @test inner(ψ, H, ψ) ≈ tr(Φ_up'h_up * Φ_up) + tr(Φ_dn'h_dn * Φ_dn)
+  @test inner(ψ', H, ψ) ≈ tr(Φ_up'h_up * Φ_up) + tr(Φ_dn'h_dn * Φ_dn)
   @test maxlinkdim(ψ) == 2
   @test flux(ψ) == QN(("Nf", 1, -1), ("Sz", 1))
   ns_up = expect_compat(ψ, "Nup")
diff --git a/ITensorGaussianMPS/test/gmera.jl b/ITensorGaussianMPS/test/gmera.jl
new file mode 100644
index 0000000000..1259ea4310
--- /dev/null
+++ b/ITensorGaussianMPS/test/gmera.jl
@@ -0,0 +1,176 @@
+using ITensorGaussianMPS
+using ITensors
+using LinearAlgebra
+using Test
+
+@testset "Basic" begin
+  # Test Givens rotations
+  v = randn(6)
+  g, r = ITensorGaussianMPS.givens_rotations(v)
+  @test g * v ≈ r * [n == 1 ? 1 : 0 for n in 1:length(v)]
+end
+
+@testset "Fermion" begin
+  N = 10
+  Nf = N ÷ 2
+
+  # Hopping
+  t = 1.0
+
+  # Hopping Hamiltonian
+  h = Hermitian(diagm(1 => fill(-t, N - 1), -1 => fill(-t, N - 1)))
+  e, u = eigen(h)
+
+  @test h * u ≈ u * Diagonal(e)
+
+  E = sum(e[1:Nf])
+
+  # Get the Slater determinant
+  Φ = u[:, 1:Nf]
+  @test h * Φ ≈ Φ * Diagonal(e[1:Nf])
+
+  # Diagonalize the correlation matrix as a
+  # Gaussian MPS (GMPS) gates
+  n, gmps = slater_determinant_to_gmera(Φ; maxblocksize=10)
+
+  ns = round.(Int, n)
+  @test sum(ns) == Nf
+
+  Λ = conj(Φ) * transpose(Φ)
+  @test gmps * Λ * gmps' ≈ Diagonal(ns) rtol = 1e-2
+  @test gmps' * Diagonal(ns) * gmps ≈ Λ rtol = 1e-2
+
+  # Form the MPS
+  s = siteinds("Fermion", N; conserve_qns=true)
+  ψ = ITensorGaussianMPS.slater_determinant_to_mera(s, Φ; blocksize=4)
+
+  os = OpSum()
+  for i in 1:N, j in 1:N
+    if h[i, j] ≠ 0
+      os .+= h[i, j], "Cdag", i, "C", j
+    end
+  end
+  H = MPO(os, s)
+
+  @test inner(ψ', H, ψ) ≈ E rtol = 1e-5
+
+  # Compare to DMRG
+  sweeps = Sweeps(10)
+  setmaxdim!(sweeps, 10, 20, 40, 60)
+  setcutoff!(sweeps, 1E-12)
+  energy, ψ̃ = dmrg(H, productMPS(s, n -> n ≤ Nf ? "1" : "0"), sweeps; outputlevel=0)
+
+  # Create an mps
+  @test abs(inner(ψ, ψ̃)) ≈ 1 rtol = 1e-5
+  @test inner(ψ̃', H, ψ̃) ≈ inner(ψ', H, ψ) rtol = 1e-5
+  @test E ≈ energy
+end
+
+@testset "Fermion (complex)" begin
+  N = 10
+  Nf = N ÷ 2
+
+  # Hopping
+  θ = π / 8
+  t = exp(im * θ)
+
+  # Hopping Hamiltonian
+  h = Hermitian(diagm(1 => fill(-t, N - 1), -1 => fill(-conj(t), N - 1)))
+  e, u = eigen(h)
+
+  @test h * u ≈ u * Diagonal(e)
+
+  E = sum(e[1:Nf])
+
+  # Get the Slater determinant
+  Φ = u[:, 1:Nf]
+  @test h * Φ ≈ Φ * Diagonal(e[1:Nf])
+
+  # Diagonalize the correlation matrix as a
+  # Gaussian MPS (GMPS)
+  n, gmps = slater_determinant_to_gmera(Φ; maxblocksize=4)
+
+  ns = round.(Int, n)
+  @test sum(ns) == Nf
+
+  Λ = conj(Φ) * transpose(Φ)
+  @test gmps * Λ * gmps' ≈ Diagonal(ns) rtol = 1e-2
+  @test gmps' * Diagonal(ns) * gmps ≈ Λ rtol = 1e-2
+
+  # Form the MPS
+  s = siteinds("Fermion", N; conserve_qns=true)
+  ψ = ITensorGaussianMPS.slater_determinant_to_mera(s, Φ; blocksize=4)
+
+  os = OpSum()
+  for i in 1:N, j in 1:N
+    if h[i, j] ≠ 0
+      os .+= h[i, j], "Cdag", i, "C", j
+    end
+  end
+  H = MPO(os, s)
+
+  @test inner(ψ', H, ψ) ≈ E rtol = 1e-5
+  @test inner(ψ', H, ψ) / norm(ψ) ≈ E rtol = 1e-5
+
+  # Compare to DMRG
+  sweeps = Sweeps(10)
+  setmaxdim!(sweeps, 10, 20, 40, 60)
+  setcutoff!(sweeps, 1E-12)
+  energy, ψ̃ = dmrg(H, productMPS(s, n -> n ≤ Nf ? "1" : "0"), sweeps; outputlevel=0)
+
+  # Create an mps
+  @test abs(inner(ψ, ψ̃)) ≈ 1 rtol = 1e-5
+  @test inner(ψ̃', H, ψ̃) ≈ inner(ψ', H, ψ) rtol = 1e-5
+  @test E ≈ energy
+end
+
+# Build 1-d SSH model
+function SSH1dModel(N::Int, t::Float64, vardelta::Float64)
+  # N should be even
+  s = siteinds("Fermion", N; conserve_qns=true)
+  limit = div(N - 1, 2)
+  t1 = -t * (1 + vardelta / 2)
+  t2 = -t * (1 - vardelta / 2)
+  os = OpSum()
+  for n in 1:limit
+    os .+= t1, "Cdag", 2 * n - 1, "C", 2 * n
+    os .+= t1, "Cdag", 2 * n, "C", 2 * n - 1
+    os .+= t2, "Cdag", 2 * n, "C", 2 * n + 1
+    os .+= t2, "Cdag", 2 * n + 1, "C", 2 * n
+  end
+  if N % 2 == 0
+    os .+= t1, "Cdag", N - 1, "C", N
+    os .+= t1, "Cdag", N, "C", N - 1
+  end
+  h = hopping_hamiltonian(os)
+  H = MPO(os, s)
+  #display(t1)
+  return (h, H, s)
+end
+
+@testset "Energy" begin
+  N = 2^4
+  Nf = div(N, 2)
+  t = 1.0
+  gapsize = 0
+  vardelta = gapsize / 2
+  h, H, s = SSH1dModel(N, t, vardelta)
+
+  Φ = slater_determinant_matrix(h, Nf)
+  E, V = eigen(h)
+  sort(E)
+  Eana = sum(E[1:Nf])
+
+  Λ0 = Φ * Φ'
+  @test Eana ≈ tr(h * Λ0) rtol = 1e-5
+  # Diagonalize the correlation matrix as a
+  # Gaussian MPS (GMPS) and GMERA
+  ngmps, V1 = ITensorGaussianMPS.correlation_matrix_to_gmps(Λ0; eigval_cutoff=1e-8)
+  nmera, V1 = ITensorGaussianMPS.correlation_matrix_to_gmera(Λ0; eigval_cutoff=1e-8)#,maxblocksize=6)
+  @test sum(round.(Int, nmera)) == sum(round.(Int, ngmps))
+
+  U = ITensorGaussianMPS.UmatFromGates(V1, N)
+  Etest = ITensorGaussianMPS.EfromGates(h, U)
+
+  @test Eana ≈ Etest rtol = 1e-5
+end
diff --git a/ITensorGaussianMPS/test/gmps.jl b/ITensorGaussianMPS/test/gmps.jl
index f55252c66e..1675d973ef 100644
--- a/ITensorGaussianMPS/test/gmps.jl
+++ b/ITensorGaussianMPS/test/gmps.jl
@@ -52,7 +52,7 @@ end
   end
   H = MPO(os, s)
 
-  @test inner(ψ, H, ψ) ≈ E rtol = 1e-5
+  @test inner(ψ', H, ψ) ≈ E rtol = 1e-5
 
   # Compare to DMRG
   sweeps = Sweeps(10)
@@ -62,7 +62,7 @@ end
 
   # Create an mps
   @test abs(inner(ψ, ψ̃)) ≈ 1 rtol = 1e-5
-  @test inner(ψ̃, H, ψ̃) ≈ inner(ψ, H, ψ) rtol = 1e-5
+  @test inner(ψ̃', H, ψ̃) ≈ inner(ψ', H, ψ) rtol = 1e-5
   @test E ≈ energy
 end
 
@@ -109,8 +109,8 @@ end
   end
   H = MPO(os, s)
 
-  @test inner(ψ, H, ψ) ≈ E rtol = 1e-5
-  @test inner(ψ, H, ψ) / norm(ψ) ≈ E rtol = 1e-5
+  @test inner(ψ', H, ψ) ≈ E rtol = 1e-5
+  @test inner(ψ', H, ψ) / norm(ψ) ≈ E rtol = 1e-5
 
   # Compare to DMRG
   sweeps = Sweeps(10)
@@ -120,6 +120,6 @@ end
 
   # Create an mps
   @test abs(inner(ψ, ψ̃)) ≈ 1 rtol = 1e-5
-  @test inner(ψ̃, H, ψ̃) ≈ inner(ψ, H, ψ) rtol = 1e-5
+  @test inner(ψ̃', H, ψ̃) ≈ inner(ψ', H, ψ) rtol = 1e-5
   @test E ≈ energy
 end
diff --git a/ITensorMakie/.JuliaFormatter.toml b/ITensorMakie/.JuliaFormatter.toml
new file mode 100644
index 0000000000..08f664cdb9
--- /dev/null
+++ b/ITensorMakie/.JuliaFormatter.toml
@@ -0,0 +1,2 @@
+style = "blue"
+indent = 2
diff --git a/ITensorUnicodePlots/.JuliaFormatter.toml b/ITensorUnicodePlots/.JuliaFormatter.toml
new file mode 100644
index 0000000000..08f664cdb9
--- /dev/null
+++ b/ITensorUnicodePlots/.JuliaFormatter.toml
@@ -0,0 +1,2 @@
+style = "blue"
+indent = 2
diff --git a/ITensorUnicodePlots/NEWS.md b/ITensorUnicodePlots/NEWS.md
index db78964eb4..9798311287 100644
--- a/ITensorUnicodePlots/NEWS.md
+++ b/ITensorUnicodePlots/NEWS.md
@@ -6,12 +6,21 @@ Note that as of Julia v1.5, in order to see deprecation warnings you will need t
 
 After we release v1 of the package, we will start following [semantic versioning](https://semver.org).
 
+ITensorUnicodePlots v0.1.2 Release Notes
+========================================
+
+Bugs
+
+Enhancements
+
+- Drop explicit dependency on ITensors
+
 ITensorUnicodePlots v0.1.1 Release Notes
-==============================
+========================================
 
 - Remove newlines from unicode visualization (#819)
 
 ITensorUnicodePlots v0.1.0 Release Notes
-==============================
+========================================
 
 - Register ITensorUnicodePlots package, code in ITensors.jl repository
diff --git a/ITensorUnicodePlots/Project.toml b/ITensorUnicodePlots/Project.toml
index 69f675a115..c104e25af2 100644
--- a/ITensorUnicodePlots/Project.toml
+++ b/ITensorUnicodePlots/Project.toml
@@ -1,12 +1,11 @@
 name = "ITensorUnicodePlots"
 uuid = "73163f41-4a9e-479f-8353-73bf94dbd758"
 authors = ["Matthew Fishman <mfishman@flatironinstitute.org>"]
-version = "0.1.1"
+version = "0.1.2"
 
 [deps]
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 ITensorVisualizationBase = "cd2553d2-8bef-4d93-8a38-c62f17d5ad23"
-ITensors = "9136182c-28ba-11e9-034c-db9fb085ebd5"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 NetworkLayout = "46757867-2c16-5918-afeb-47bfcb05e46a"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
@@ -16,7 +15,6 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 [compat]
 Graphs = "1.4.1"
 ITensorVisualizationBase = "0.1.0"
-ITensors = "0.2.12"
 NetworkLayout = "0.4.3"
 Reexport = "1.2.2"
 UnicodePlots = "2.5.0"
diff --git a/ITensorUnicodePlots/test/references/R.txt b/ITensorUnicodePlots/test/references/R.txt
index 6f203b2052..8f0d350d8a 100644
--- a/ITensorUnicodePlots/test/references/R.txt
+++ b/ITensorUnicodePlots/test/references/R.txt
@@ -1,22 +1,22 @@
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ERn2⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⡇⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠕⠀⡇⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊(20)'⠀⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀20⠊⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀10⠢⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠢⢄⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣉hn2⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠜⠀⣀⣀⣀⣀⣀⡠⠤⠤⠤⠤2⠒⠒⠒⠒⠒⠉⠉⠉⠉⠉⠀⢀⠔⢹⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠜⠀⣀⣀⣀⣀⣀⡠⠤⠤⠠⠤2⠒⠒⠒⠒⠒⠉⠉⠉⠉⠉⠀⢀⠔⢹⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ψn1n2⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔(2)'⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠁⠀⠀⠀⠀⠉⠢⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀10⠔⠁⠀⠀⠀⢸⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀2⊗2⊗2⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀20⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠒⢄⡀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀20⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠖⢀⡀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣑hn1⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⢀⣀⣀⣀⣀⡠⠤⠤10⠤⠒⠒⠒⠒⠒⠉⠉⠉⠉⠉⠁⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⢀⣀⣀⣀⣀⡠⠤⠤10⠤⠒⠒⠒⠒⠒⠉⠉⠉⠉⠈⠁⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀ELn0⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(2)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀(20)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
\ No newline at end of file
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
\ No newline at end of file
diff --git a/ITensorUnicodePlots/test/references/R1.txt b/ITensorUnicodePlots/test/references/R1.txt
index a2f52ebbea..dd88b4a1db 100644
--- a/ITensorUnicodePlots/test/references/R1.txt
+++ b/ITensorUnicodePlots/test/references/R1.txt
@@ -1,11 +1,11 @@
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀ELn0⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⣷⠀⠀⠉⠉⠑⠒⠒⠤⠤⢄⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⢇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠑⠒⠒⠤⠤10⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀(20)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠉⠒⠒⠢⠤⠤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀(20)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠈⠒⠒⠢⠤⠤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⠀⢱⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠒⠒⠢⠤hn1⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⠀⠀⢇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠒⠉⢸⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠁⠀⠀⠘⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠒⠉⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀
@@ -19,4 +19,4 @@
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀2⊗20⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
\ No newline at end of file
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
\ No newline at end of file
diff --git a/ITensorUnicodePlots/test/references/R2.txt b/ITensorUnicodePlots/test/references/R2.txt
index 8922773de3..698bc913ec 100644
--- a/ITensorUnicodePlots/test/references/R2.txt
+++ b/ITensorUnicodePlots/test/references/R2.txt
@@ -1,11 +1,11 @@
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀T1⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⣷⠀⠀⠉⠉⠑⠒⠒⠤⠤⢄⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⢇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠑⠒⠒⠤⠤20⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀20)'⊗(2)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠉⠒⠒⠢⠤⠤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀20)'⊗(2)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠈⠒⠒⠢⠤⠤⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⠀⢱⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠒⠒⠢⠤T3⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⠀⠀⢇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠤⠒⠉⢸⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠁⠀⠀⠘⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠒⠉⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀
@@ -19,4 +19,4 @@
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(2)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
\ No newline at end of file
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
\ No newline at end of file
diff --git a/ITensorUnicodePlots/test/references/R_tags.txt b/ITensorUnicodePlots/test/references/R_tags.txt
index a97e4ceed0..cd8b09f8ff 100644
--- a/ITensorUnicodePlots/test/references/R_tags.txt
+++ b/ITensorUnicodePlots/test/references/R_tags.txt
@@ -1,9 +1,9 @@
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ERn2⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⡇⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠕⠀⡇⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(20|"Link,l=3")'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(20|"Link,l(10|"Link,ham,l=3")⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠢⢄⠀⠀⠀⠀⠀⠀⠀⠀
@@ -12,11 +12,11 @@
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ψn1n2⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(2|"S=1/2,Site,⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠁⠀⠀⠀⠀⠉⠢⢄⠀⠀⠀⠀⠀⠀(10|"Link,ham,l=2")⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀(2|"S=1/2,Site,n=2")⊗(2|"X")⊗(2|"Y")⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀(20|"Link,l=1")⠀⠀⠀⠀⠀⠀⠀⠀⠈⠒⢄⡀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀(20|"Link,l=1")⠀⠀⠀⠀⠀⠀⠀⠀⠈⠖⢀⡀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣑hn1⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀(10|"Link,ham,l=1")⠉⠉⠁⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀(10|"Link,ham,l=1")⠉⠈⠁⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀ELn0⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(2|"S=1/2,Site,n=2")'⠀⠀⠀⠀⠀⠀⠀
     ⠀"Link,l=1")'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
\ No newline at end of file
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
\ No newline at end of file
diff --git a/ITensorUnicodePlots/test/references/T.txt b/ITensorUnicodePlots/test/references/T.txt
index 9d0776d5af..ac2397bb71 100644
--- a/ITensorUnicodePlots/test/references/T.txt
+++ b/ITensorUnicodePlots/test/references/T.txt
@@ -1,4 +1,4 @@
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
@@ -19,4 +19,4 @@
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
\ No newline at end of file
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
\ No newline at end of file
diff --git a/ITensorUnicodePlots/test/references/tn.txt b/ITensorUnicodePlots/test/references/tn.txt
index 54999489fa..6ce2dcca5c 100644
--- a/ITensorUnicodePlots/test/references/tn.txt
+++ b/ITensorUnicodePlots/test/references/tn.txt
@@ -1,22 +1,22 @@
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀tn₅⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠁⡇⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠕⠀⡇⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊(20)'⠀⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀20⠊⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀10⠢⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠢⢄⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣉tn₄⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠜⠀⣀⣀⣀⣀⣀⡠⠤⠤⠤⠤2⠒⠒⠒⠒⠒⠉⠉⠉⠉⠉⠀⢀⠔⢹⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠜⠀⣀⣀⣀⣀⣀⡠⠤⠤⠠⠤2⠒⠒⠒⠒⠒⠉⠉⠉⠉⠉⠀⢀⠔⢹⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀tn₂⣉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔(2)'⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⠁⠀⠀⠀⠀⠉⠢⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀10⠔⠁⠀⠀⠀⢸⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀2⊗2⊗2⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠒⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀20⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠒⢄⡀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀20⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠖⢀⡀⠀⠀⠀⠀⡠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⣑tn₃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⢀⣀⣀⣀⣀⡠⠤⠤10⠤⠒⠒⠒⠒⠒⠉⠉⠉⠉⠉⠁⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⠀⡠⠊⠀⠀⢀⣀⣀⣀⣀⡠⠤⠤10⠤⠒⠒⠒⠒⠒⠉⠉⠉⠉⠈⠁⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀tn₁⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(2)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀(20)'⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
     ⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 
\ No newline at end of file
+    ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
\ No newline at end of file
diff --git a/ITensorVisualizationBase/.JuliaFormatter.toml b/ITensorVisualizationBase/.JuliaFormatter.toml
new file mode 100644
index 0000000000..08f664cdb9
--- /dev/null
+++ b/ITensorVisualizationBase/.JuliaFormatter.toml
@@ -0,0 +1,2 @@
+style = "blue"
+indent = 2
diff --git a/ITensorVisualizationBase/NEWS.md b/ITensorVisualizationBase/NEWS.md
index 23859a1732..01bf847666 100644
--- a/ITensorVisualizationBase/NEWS.md
+++ b/ITensorVisualizationBase/NEWS.md
@@ -6,8 +6,26 @@ Note that as of Julia v1.5, in order to see deprecation warnings you will need t
 
 After we release v1 of the package, we will start following [semantic versioning](https://semver.org).
 
+ITensors v0.1.4 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Generalize edge labels for more general vertices (#907)
+
+ITensors v0.1.3 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Bump to ITensors 0.3 (#880)
+
 ITensors v0.1.2 Release Notes
-==============================
+=============================
 
 Bugs:
 
@@ -16,7 +34,7 @@ Enhancements:
 - Remove subscript from single tensor visualization. Show plevs by default. (#841)
 
 ITensors v0.1.1 Release Notes
-==============================
+=============================
 
 Bugs:
 
@@ -25,7 +43,7 @@ Enhancements:
 - Generalize `ITensorVisualizationBase.visualize` to make it easier to overload for new types (#802)
 
 ITensors v0.1.0 Release Notes
-==============================
+=============================
 
 Bugs:
 
diff --git a/ITensorVisualizationBase/Project.toml b/ITensorVisualizationBase/Project.toml
index 3caeaa1ad4..9aaa2b05bc 100644
--- a/ITensorVisualizationBase/Project.toml
+++ b/ITensorVisualizationBase/Project.toml
@@ -1,7 +1,7 @@
 name = "ITensorVisualizationBase"
 uuid = "cd2553d2-8bef-4d93-8a38-c62f17d5ad23"
 authors = ["Matthew Fishman <mfishman@flatironinstitute.org> and contributors"]
-version = "0.1.2"
+version = "0.1.4"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
@@ -20,7 +20,7 @@ AbstractTrees = "0.3.4"
 Compat = "3.40.0"
 GeometryBasics = "0.4.1"
 Graphs = "1.4.1"
-ITensors = "0.2.12"
+ITensors = "0.2.12, 0.3"
 MetaGraphs = "0.7.1"
 NetworkLayout = "0.4.3"
 julia = "1.6"
diff --git a/ITensorVisualizationBase/src/defaults.jl b/ITensorVisualizationBase/src/defaults.jl
index 6cdeb2d745..a43d72b59a 100644
--- a/ITensorVisualizationBase/src/defaults.jl
+++ b/ITensorVisualizationBase/src/defaults.jl
@@ -21,6 +21,8 @@ function subscript(n::Integer)
   return ss
 end
 
+subscript(n) = string(n)
+
 default_vertex_labels_prefix(b::Backend, g) = "T"
 function default_vertex_labels(
   b::Backend, g::AbstractGraph, vertex_labels_prefix=default_vertex_labels_prefix(b)
@@ -42,6 +44,10 @@ default_vertex_textsize(b::Backend, g) = 20
 default_edge_textsize(b::Backend) = 30
 
 function default_edge_labels(b::Backend, g::AbstractGraph)
+  return fill("", ne(g))
+end
+
+function default_edge_labels(b::Backend, g::AbstractMetaGraph)
   return IndexLabels(b)
 end
 
@@ -80,6 +86,8 @@ function IndexLabels(
   return IndexLabels(dims, tags, ids, plevs, qns, newlines)
 end
 
+edge_labels(b::Backend, l::Vector{String}, g::AbstractGraph) = l
+
 function edge_labels(b::Backend, l::IndexLabels, g::AbstractGraph)
   return edge_labels(l, g)
 end
@@ -92,7 +100,7 @@ function edge_labels(b::Backend, params::NamedTuple, g::AbstractGraph)
   return IndexLabels(b; params...)(g)
 end
 
-function edge_label(l::IndexLabels, g::AbstractGraph, e)
+function edge_label(l::IndexLabels, g::AbstractMetaGraph, e)
   indsₑ = get_prop(g, e, :inds)
   return label_string(
     indsₑ;
@@ -106,12 +114,12 @@ function edge_label(l::IndexLabels, g::AbstractGraph, e)
   )
 end
 
-function _edge_label(l, g::Graph, e)
+function _edge_label(l, g::AbstractGraph, e)
   return string(e)
 end
 
-edge_label(l::IndexLabels, g::Graph, e) = _edge_label(l, g, e)
-edge_label(l, g::Graph, e) = _edge_label(l, g, e)
+edge_label(l::IndexLabels, g::AbstractGraph, e) = _edge_label(l, g, e)
+edge_label(l, g::AbstractGraph, e) = _edge_label(l, g, e)
 
 #function default_edge_labels(b::Backend, g; kwargs...)
 #  return [edge_label(g, e; kwargs...) for e in edges(g)]
@@ -194,12 +202,12 @@ function width(inds)
   return log2(dim(inds)) + 1
 end
 
-function default_edge_widths(b::Backend, g::AbstractGraph)
+function default_edge_widths(b::Backend, g::AbstractMetaGraph)
   return Float64[width(get_prop(g, e, :inds)) for e in edges(g)]
 end
 
-function default_edge_widths(b::Backend, g::Graph)
-  return [1.0 for e in edges(g)]
+function default_edge_widths(b::Backend, g::AbstractGraph)
+  return fill(one(Float64), ne(g))
 end
 
 #############################################################################
@@ -210,7 +218,7 @@ default_arrow_size(b::Backend, g) = 30
 
 _hasqns(tn::Vector{ITensor}) = any(hasqns, tn)
 
-function _hasqns(g::AbstractGraph)
+function _hasqns(g::AbstractMetaGraph)
   if iszero(ne(g))
     if has_prop(g, first(vertices(g)), :inds)
       return hasqns(get_prop(g, first(vertices(g)), :inds))
@@ -221,7 +229,7 @@ function _hasqns(g::AbstractGraph)
   return hasqns(get_prop(g, first(edges(g)), :inds))
 end
 
-_hasqns(g::Graph) = false
+_hasqns(g::AbstractGraph) = false
 
 default_arrow_show(b::Backend, g) = _hasqns(g)
 
diff --git a/NDTensors/.JuliaFormatter.toml b/NDTensors/.JuliaFormatter.toml
new file mode 100644
index 0000000000..08f664cdb9
--- /dev/null
+++ b/NDTensors/.JuliaFormatter.toml
@@ -0,0 +1,2 @@
+style = "blue"
+indent = 2
diff --git a/NDTensors/NEWS.md b/NDTensors/NEWS.md
index e818f3cf36..fe27388823 100644
--- a/NDTensors/NEWS.md
+++ b/NDTensors/NEWS.md
@@ -6,6 +6,82 @@ Note that as of Julia v1.5, in order to see deprecation warnings you will need t
 
 After we release v1 of the package, we will start following [semantic versioning](https://semver.org).
 
+NDTensors v0.1.42 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Define `map` for Tensor and TensorStorage (b66d1b7)
+- Define `real` and `imag` for Tensor (b66d1b7)
+- Throw error when trying to do an eigendecomposition of Tensor with Infs or NaNs (b66d1b7)
+
+NDTensors v0.1.41 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Fix `truncate!` for `Float32`/`ComplexF32` (#926)
+
+NDTensors v0.1.40 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Add support for `cutoff < 0` and `cutoff = nothing` for disabling truncating according to `cutoff` (#925)
+- Define contraction of Diag with Combiner (#920)
+
+NDTensors v0.1.39 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Fix `svd` and `qr` for empty input left or right indices (#917)
+
+NDTensors v0.1.38 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Clean up QN `svd` code in `ITensors` by handling QN blocks better in `NDTensors` (#906)
+- Clean up `outer` and add GEMM routing for CUDA (#887)
+
+NDTensors v0.1.37 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Add fallbacks for when LAPACK SVD fails (#885)
+
+NDTensors v0.1.36 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Change minimal required Julia version from 1.3 to 1.6 (#849)
+
+NDTensors v0.1.35 Release Notes
+===============================
+
+Bugs:
+
+Enhancements:
+
+- Allow general AbstractArray as data of `Dense` storage `Tensor`/`ITensor` (#848)
+
 NDTensors v0.1.34 Release Notes
 ===============================
 
diff --git a/NDTensors/Project.toml b/NDTensors/Project.toml
index 66d981ea5c..4629b07ecb 100644
--- a/NDTensors/Project.toml
+++ b/NDTensors/Project.toml
@@ -1,7 +1,7 @@
 name = "NDTensors"
 uuid = "23ae76d9-e61a-49c4-8f12-3f1a16adf9cf"
 authors = ["Matthew Fishman <mfishman@flatironinstitute.org>"]
-version = "0.1.35"
+version = "0.1.42"
 
 [deps]
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
@@ -18,7 +18,7 @@ TupleTools = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6"
 [compat]
 Compat = "2.1, 3"
 Dictionaries = "0.3.5"
-HDF5 = "0.14, 0.15"
+HDF5 = "0.14, 0.15, 0.16"
 Requires = "1.1"
 StaticArrays = "0.12, 1.0"
 Strided = "0.3, 1"
diff --git a/NDTensors/src/blocksparse/blockdims.jl b/NDTensors/src/blocksparse/blockdims.jl
index b2ccd55af1..7a04d714b9 100644
--- a/NDTensors/src/blocksparse/blockdims.jl
+++ b/NDTensors/src/blocksparse/blockdims.jl
@@ -202,8 +202,14 @@ blockindex(T) = (), Block{0}()
 # This is to help with ITensor compatibility
 #
 
+block(i::BlockDim, n::Integer) = i[n]
+
+resize(n::Int, newdim::Int) = newdim
+
 setblockdim!(dim1::BlockDim, newdim::Int, n::Int) = setindex!(dim1, newdim, n)
 
+setblock!(i::BlockDim, b::Int, n::Integer) = (i[n] = b)
+
 sim(dim::BlockDim) = copy(dim)
 
 dir(::BlockDim) = 0
diff --git a/NDTensors/src/blocksparse/linearalgebra.jl b/NDTensors/src/blocksparse/linearalgebra.jl
index cb899963d5..7814239716 100644
--- a/NDTensors/src/blocksparse/linearalgebra.jl
+++ b/NDTensors/src/blocksparse/linearalgebra.jl
@@ -4,18 +4,21 @@ const DiagBlockSparseMatrix{ElT,StoreT,IndsT} = DiagBlockSparseTensor{ElT,2,Stor
 const DiagMatrix{ElT,StoreT,IndsT} = DiagTensor{ElT,2,StoreT,IndsT}
 
 function _truncated_blockdim(
-  S::DiagMatrix, docut::Float64; singular_values=false, truncate=true
+  S::DiagMatrix, docut::Real; singular_values=false, truncate=true, min_blockdim=0
 )
-  !truncate && return diaglength(S)
+  full_dim = diaglength(S)
+  !truncate && return full_dim
+  min_blockdim = min(min_blockdim, full_dim)
   newdim = 0
   val = singular_values ? getdiagindex(S, newdim + 1)^2 : abs(getdiagindex(S, newdim + 1))
-  while newdim + 1 ≤ diaglength(S) && val > docut
+  while newdim + 1 ≤ full_dim && val > docut
     newdim += 1
-    if newdim + 1 ≤ diaglength(S)
+    if newdim + 1 ≤ full_dim
       val =
         singular_values ? getdiagindex(S, newdim + 1)^2 : abs(getdiagindex(S, newdim + 1))
     end
   end
+  (newdim >= min_blockdim) || (newdim = min_blockdim)
   return newdim
 end
 
@@ -31,7 +34,7 @@ computed from the dense svds of seperate blocks.
 """
 function LinearAlgebra.svd(T::BlockSparseMatrix{ElT}; kwargs...) where {ElT}
   alg::String = get(kwargs, :alg, "divide_and_conquer")
-
+  min_blockdim::Int = get(kwargs, :min_blockdim, 0)
   truncate = haskey(kwargs, :maxdim) || haskey(kwargs, :cutoff)
 
   #@timeit_debug timer "block sparse svd" begin
@@ -74,7 +77,9 @@ function LinearAlgebra.svd(T::BlockSparseMatrix{ElT}; kwargs...) where {ElT}
   if truncate
     truncerr, docut = truncate!(d; kwargs...)
     for n in 1:nnzblocks(T)
-      blockdim = _truncated_blockdim(Ss[n], docut; singular_values=true, truncate=truncate)
+      blockdim = _truncated_blockdim(
+        Ss[n], docut; min_blockdim, singular_values=true, truncate
+      )
       if blockdim == 0
         push!(dropblocks, n)
       else
@@ -92,57 +97,37 @@ function LinearAlgebra.svd(T::BlockSparseMatrix{ElT}; kwargs...) where {ElT}
     truncerr, docut = 0.0, 0.0
   end
 
-  # The number of blocks of T remaining
-  nnzblocksT = nnzblocks(T) - length(dropblocks)
+  # The number of non-zero blocks of T remaining
+  nnzblocksT = length(nzblocksT)
 
   #
-  # Put the blocks into U,S,V
-  # 
-
-  nb1_lt_nb2 = (
-    nblocks(T)[1] < nblocks(T)[2] ||
-    (nblocks(T)[1] == nblocks(T)[2] && dim(T, 1) < dim(T, 2))
-  )
-
-  if nb1_lt_nb2
-    uind = sim(ind(T, 1))
-  else
-    uind = sim(ind(T, 2))
-  end
-
-  deleteat!(uind, dropblocks)
-
-  # uind may have too many blocks
-  if nblocks(uind) > nnzblocksT
-    resize!(uind, nnzblocksT)
-  end
-
-  for n in 1:nnzblocksT
-    setblockdim!(uind, minimum(dims(Ss[n])), n)
-  end
-
-  if dir(uind) != dir(inds(T)[1])
-    uind = dag(uind)
-  end
-  indsU = setindex(inds(T), dag(uind), 2)
-
-  vind = sim(uind)
-  if dir(vind) != dir(inds(T)[2])
-    vind = dag(vind)
+  # Make indices of U and V 
+  # that connect to S
+  #
+  i1 = ind(T, 1)
+  i2 = ind(T, 2)
+  uind = dag(sim(i1))
+  vind = dag(sim(i2))
+  resize!(uind, nnzblocksT)
+  resize!(vind, nnzblocksT)
+  for (n, blockT) in enumerate(nzblocksT)
+    Udim = size(Us[n], 2)
+    b1 = block(i1, blockT[1])
+    setblock!(uind, resize(b1, Udim), n)
+    Vdim = size(Vs[n], 2)
+    b2 = block(i2, blockT[2])
+    setblock!(vind, resize(b2, Vdim), n)
   end
-  indsV = setindex(inds(T), dag(vind), 1)
-  indsV = permute(indsV, (2, 1))
 
-  indsS = setindex(inds(T), uind, 1)
-  indsS = setindex(indsS, vind, 2)
+  #
+  # Put the blocks into U,S,V
+  # 
 
   nzblocksU = Vector{Block{2}}(undef, nnzblocksT)
   nzblocksS = Vector{Block{2}}(undef, nnzblocksT)
   nzblocksV = Vector{Block{2}}(undef, nnzblocksT)
 
-  for n in 1:nnzblocksT
-    blockT = nzblocksT[n]
-
+  for (n, blockT) in enumerate(nzblocksT)
     blockU = (blockT[1], UInt(n))
     nzblocksU[n] = blockU
 
@@ -153,6 +138,14 @@ function LinearAlgebra.svd(T::BlockSparseMatrix{ElT}; kwargs...) where {ElT}
     nzblocksV[n] = blockV
   end
 
+  indsU = setindex(inds(T), uind, 2)
+
+  indsV = setindex(inds(T), vind, 1)
+  indsV = permute(indsV, (2, 1))
+
+  indsS = setindex(inds(T), dag(uind), 1)
+  indsS = setindex(indsS, dag(vind), 2)
+
   U = BlockSparseTensor(ElT, undef, nzblocksU, indsU)
   S = DiagBlockSparseTensor(real(ElT), undef, nzblocksS, indsS)
   V = BlockSparseTensor(ElT, undef, nzblocksV, indsV)
diff --git a/NDTensors/src/combiner.jl b/NDTensors/src/combiner.jl
index 18f6e1d4ca..4aa7d99ed9 100644
--- a/NDTensors/src/combiner.jl
+++ b/NDTensors/src/combiner.jl
@@ -123,6 +123,10 @@ function contract!!(
   return contract!!(R, labelsR, T2, labelsT2, T1, labelsT1)
 end
 
+function contract(T1::DiagTensor, labelsT1, T2::CombinerTensor, labelsT2)
+  return contract(dense(T1), labelsT1, T2, labelsT2)
+end
+
 function show(io::IO, mime::MIME"text/plain", S::Combiner)
   println(io, "Permutation of blocks: ", S.perm)
   return println(io, "Combination of blocks: ", S.comb)
diff --git a/NDTensors/src/dense.jl b/NDTensors/src/dense.jl
index db5c4c511c..5edf3f53b9 100644
--- a/NDTensors/src/dense.jl
+++ b/NDTensors/src/dense.jl
@@ -344,36 +344,69 @@ function copyto!(
 end
 
 # If they are something more complicated like views, use Strided copyto!
-function copyto!(R::DenseTensor{<:Number,N}, T::DenseTensor{<:Number,N}) where {N}
+function copyto!(
+  R::DenseTensor{<:Number,N,StoreT}, T::DenseTensor{<:Number,N,StoreT}
+) where {N,StoreT<:StridedArray}
   RA = array(R)
   TA = array(T)
   @strided RA .= TA
   return R
 end
 
+# TODO: call permutedims!(R,T,perm,(r,t)->t)?
+function permutedims!(
+  R::DenseTensor{<:Number,N,StoreT}, T::DenseTensor{<:Number,N,StoreT}, perm::NTuple{N,Int}
+) where {N,StoreT<:StridedArray}
+  RA = array(R)
+  TA = array(T)
+  @strided RA .= permutedims(TA, perm)
+  return R
+end
+
+function copyto!(R::DenseTensor{<:Number,N}, T::DenseTensor{<:Number,N}) where {N}
+  RA = array(R)
+  TA = array(T)
+  RA .= TA
+  return R
+end
+
 # TODO: call permutedims!(R,T,perm,(r,t)->t)?
 function permutedims!(
   R::DenseTensor{<:Number,N}, T::DenseTensor{<:Number,N}, perm::NTuple{N,Int}
 ) where {N}
   RA = array(R)
   TA = array(T)
-  @strided RA .= permutedims(TA, perm)
+  RA .= permutedims(TA, perm)
   return R
 end
 
-function apply!(R::DenseTensor, T::DenseTensor, f::Function=(r, t) -> t)
+function apply!(
+  R::DenseTensor{<:Number,N,StoreT},
+  T::DenseTensor{<:Number,N,StoreT},
+  f::Function=(r, t) -> t,
+) where {N,StoreT<:StridedArray}
   RA = array(R)
   TA = array(T)
   @strided RA .= f.(RA, TA)
   return R
 end
 
+function apply!(R::DenseTensor, T::DenseTensor, f::Function=(r, t) -> t)
+  RA = array(R)
+  TA = array(T)
+  RA .= f.(RA, TA)
+  return R
+end
+
 # Version that may overwrite the result or promote
 # and return the result
-function permutedims!!(R::DenseTensor, T::DenseTensor, perm::Tuple, f::Function=(r, t) -> t)
+function permutedims!!(
+  R::DenseTensor{<:Number,N,StoreT},
+  T::DenseTensor{<:Number,N,StoreT},
+  perm::Tuple,
+  f::Function=(r, t) -> t,
+) where {N,StoreT<:StridedArray}
   RR = convert(promote_type(typeof(R), typeof(T)), R)
-  #RA = array(R)
-  #TA = array(T)
   RA = ReshapedArray(data(RR), dims(RR), ())
   TA = ReshapedArray(data(T), dims(T), ())
   if !is_trivial_permutation(perm)
@@ -385,6 +418,20 @@ function permutedims!!(R::DenseTensor, T::DenseTensor, perm::Tuple, f::Function=
   return RR
 end
 
+function permutedims!!(R::DenseTensor, T::DenseTensor, perm::Tuple, f::Function=(r, t) -> t)
+  RR = convert(promote_type(typeof(R), typeof(T)), R)
+  RA = ReshapedArray(data(RR), dims(RR), ())
+  TA = ReshapedArray(data(T), dims(T), ())
+  if !is_trivial_permutation(perm)
+    TB = permutedims(TA, perm)
+    RA .= f.(RA, TB)
+  else
+    # TODO: specialize for specific functions
+    RA .= f.(RA, TA)
+  end
+  return RR
+end
+
 # TODO: move to tensor.jl?
 function permutedims(T::Tensor{<:Number,N}, perm::NTuple{N,Int}) where {N}
   Tp = similar(T, permute(inds(T), perm))
diff --git a/NDTensors/src/imports.jl b/NDTensors/src/imports.jl
index a63dc99940..de8f45d42f 100644
--- a/NDTensors/src/imports.jl
+++ b/NDTensors/src/imports.jl
@@ -24,15 +24,18 @@ import Base:
   fill!,
   getindex,
   hash,
+  imag,
   isempty,
   isless,
   iterate,
   length,
+  map,
   ndims,
   permutedims,
   permutedims!,
   promote_rule,
   randn,
+  real,
   reshape,
   setindex,
   setindex!,
diff --git a/NDTensors/src/linearalgebra.jl b/NDTensors/src/linearalgebra.jl
index 889b618ef4..22e90cee84 100644
--- a/NDTensors/src/linearalgebra.jl
+++ b/NDTensors/src/linearalgebra.jl
@@ -34,9 +34,9 @@ end
 contains the (truncated) density matrix eigenvalue spectrum which is computed during a
 decomposition done by `svd` or `eigen`. In addition stores the truncation error.
 """
-struct Spectrum{VecT<:Union{AbstractVector,Nothing}}
+struct Spectrum{VecT<:Union{AbstractVector,Nothing},ElT<:Real}
   eigs::VecT
-  truncerr::Float64
+  truncerr::ElT
 end
 
 eigs(s::Spectrum) = s.eigs
@@ -119,7 +119,7 @@ function LinearAlgebra.svd(T::DenseTensor{ElT,2,IndsT}; kwargs...) where {ElT,In
 
   maxdim::Int = get(kwargs, :maxdim, minimum(dims(T)))
   mindim::Int = get(kwargs, :mindim, 1)
-  cutoff::Float64 = get(kwargs, :cutoff, 0.0)
+  cutoff = get(kwargs, :cutoff, 0.0)
   use_absolute_cutoff::Bool = get(kwargs, :use_absolute_cutoff, use_absolute_cutoff)
   use_relative_cutoff::Bool = get(kwargs, :use_relative_cutoff, use_relative_cutoff)
   alg::String = get(kwargs, :alg, "divide_and_conquer")
@@ -127,8 +127,23 @@ function LinearAlgebra.svd(T::DenseTensor{ElT,2,IndsT}; kwargs...) where {ElT,In
   #@timeit_debug timer "dense svd" begin
   if alg == "divide_and_conquer"
     MUSV = svd_catch_error(matrix(T); alg=LinearAlgebra.DivideAndConquer())
+    if isnothing(MUSV)
+      # If "divide_and_conquer" fails, try "qr_iteration"
+      alg = "qr_iteration"
+      MUSV = svd_catch_error(matrix(T); alg=LinearAlgebra.QRIteration())
+      if isnothing(MUSV)
+        # If "qr_iteration" fails, try "recursive"
+        alg = "recursive"
+        MUSV = svd_recursive(matrix(T))
+      end
+    end
   elseif alg == "qr_iteration"
     MUSV = svd_catch_error(matrix(T); alg=LinearAlgebra.QRIteration())
+    if isnothing(MUSV)
+      # If "qr_iteration" fails, try "recursive"
+      alg = "recursive"
+      MUSV = svd_recursive(matrix(T))
+    end
   elseif alg == "recursive"
     MUSV = svd_recursive(matrix(T))
   else
@@ -199,11 +214,20 @@ function LinearAlgebra.eigen(
   truncate = haskey(kwargs, :maxdim) || haskey(kwargs, :cutoff)
   maxdim::Int = get(kwargs, :maxdim, minimum(dims(T)))
   mindim::Int = get(kwargs, :mindim, 1)
-  cutoff::Float64 = get(kwargs, :cutoff, 0.0)
+  cutoff::Union{Nothing,Float64} = get(kwargs, :cutoff, 0.0)
   use_absolute_cutoff::Bool = get(kwargs, :use_absolute_cutoff, use_absolute_cutoff)
   use_relative_cutoff::Bool = get(kwargs, :use_relative_cutoff, use_relative_cutoff)
 
-  DM, VM = eigen(matrix(T))
+  matrixT = matrix(T)
+  if any(!isfinite, matrixT)
+    throw(
+      ArgumentError(
+        "Trying to perform the eigendecomposition of a matrix containing NaNs or Infs"
+      ),
+    )
+  end
+
+  DM, VM = eigen(matrixT)
 
   # Sort by largest to smallest eigenvalues
   p = sortperm(DM; rev=true, by=abs)
@@ -213,6 +237,7 @@ function LinearAlgebra.eigen(
   if truncate
     truncerr, _ = truncate!(
       DM;
+      mindim=mindim,
       maxdim=maxdim,
       cutoff=cutoff,
       use_absolute_cutoff=use_absolute_cutoff,
@@ -327,7 +352,16 @@ function LinearAlgebra.eigen(
   use_absolute_cutoff::Bool = get(kwargs, :use_absolute_cutoff, use_absolute_cutoff)
   use_relative_cutoff::Bool = get(kwargs, :use_relative_cutoff, use_relative_cutoff)
 
-  DM, VM = eigen(matrix(T))
+  matrixT = matrix(T)
+  if any(!isfinite, matrixT)
+    throw(
+      ArgumentError(
+        "Trying to perform the eigendecomposition of a matrix containing NaNs or Infs"
+      ),
+    )
+  end
+
+  DM, VM = eigen(matrixT)
 
   # Sort by largest to smallest eigenvalues
   #p = sortperm(DM; rev = true)
diff --git a/NDTensors/src/tensor.jl b/NDTensors/src/tensor.jl
index ab251abc05..68e4a23908 100644
--- a/NDTensors/src/tensor.jl
+++ b/NDTensors/src/tensor.jl
@@ -124,13 +124,22 @@ copyto!(R::Tensor, T::Tensor) = (copyto!(storage(R), storage(T)); R)
 
 complex(T::Tensor) = setstorage(T, complex(storage(T)))
 
-Base.real(T::Tensor) = setstorage(T, real(storage(T)))
+real(T::Tensor) = setstorage(T, real(storage(T)))
 
-Base.imag(T::Tensor) = setstorage(T, imag(storage(T)))
+imag(T::Tensor) = setstorage(T, imag(storage(T)))
 
 # Define Base.similar in terms of NDTensors.similar
 Base.similar(T::Tensor, args...) = similar(T, args...)
 
+function map(f, x::Tensor{T}) where {T}
+  if !iszero(f(zero(T)))
+    error(
+      "map(f, ::Tensor) currently doesn't support functions that don't preserve zeros, while you passed a function such that f(0) = $(f(zero(T))). This isn't supported right now because it doesn't necessarily preserve the sparsity structure of the input tensor.",
+    )
+  end
+  return setstorage(x, map(f, storage(x)))
+end
+
 #
 # Necessary to overload since the generic fallbacks are
 # slow
diff --git a/NDTensors/src/tensorstorage.jl b/NDTensors/src/tensorstorage.jl
index 619c6f22de..08bf03a5fb 100644
--- a/NDTensors/src/tensorstorage.jl
+++ b/NDTensors/src/tensorstorage.jl
@@ -72,6 +72,15 @@ Base.copyto!(S1::TensorStorage, S2::TensorStorage) = (copyto!(data(S1), data(S2)
 
 Random.randn!(S::TensorStorage) = (randn!(data(S)); S)
 
+function map(f, x::TensorStorage{T}) where {T}
+  if !iszero(f(zero(T)))
+    error(
+      "map(f, ::TensorStorage) currently doesn't support functions that don't preserve zeros, while you passed a function such that f(0) = $(f(zero(T))). This isn't supported right now because it doesn't necessarily preserve the sparsity structure of the input tensor.",
+    )
+  end
+  return setdata(x, map(f, data(x)))
+end
+
 Base.fill!(S::TensorStorage, v) = (fill!(data(S), v); S)
 
 LinearAlgebra.rmul!(S::TensorStorage, v::Number) = (rmul!(data(S), v); S)
diff --git a/NDTensors/src/truncate.jl b/NDTensors/src/truncate.jl
index 452e1ab3ac..1e69166a49 100644
--- a/NDTensors/src/truncate.jl
+++ b/NDTensors/src/truncate.jl
@@ -1,6 +1,11 @@
 export truncate!
 
-function truncate!(P::Vector{Float64}; kwargs...)::Tuple{Float64,Float64}
+function truncate!(P::Vector{ElT}; kwargs...)::Tuple{ElT,ElT} where {ElT}
+  cutoff::Union{Nothing,ElT} = get(kwargs, :cutoff, zero(ElT))
+  if isnothing(cutoff)
+    cutoff = typemin(ElT)
+  end
+
   # Keyword argument deprecations
   use_absolute_cutoff = false
   if haskey(kwargs, :absoluteCutoff)
@@ -15,12 +20,12 @@ function truncate!(P::Vector{Float64}; kwargs...)::Tuple{Float64,Float64}
 
   maxdim::Int = min(get(kwargs, :maxdim, length(P)), length(P))
   mindim::Int = max(get(kwargs, :mindim, 1), 1)
-  cutoff::Float64 = max(get(kwargs, :cutoff, 0.0), 0.0)
+
   use_absolute_cutoff::Bool = get(kwargs, :use_absolute_cutoff, use_absolute_cutoff)
   use_relative_cutoff::Bool = get(kwargs, :use_relative_cutoff, use_relative_cutoff)
 
   origm = length(P)
-  docut = 0.0
+  docut = zero(ElT)
 
   #if P[1] <= 0.0
   #  P[1] = 0.0
@@ -30,7 +35,7 @@ function truncate!(P::Vector{Float64}; kwargs...)::Tuple{Float64,Float64}
 
   if origm == 1
     docut = abs(P[1]) / 2
-    return 0.0, docut
+    return zero(ElT), docut
   end
 
   s = sign(P[1])
@@ -38,12 +43,12 @@ function truncate!(P::Vector{Float64}; kwargs...)::Tuple{Float64,Float64}
 
   #Zero out any negative weight
   for n in origm:-1:1
-    (P[n] >= 0.0) && break
-    P[n] = 0.0
+    (P[n] >= zero(ElT)) && break
+    P[n] = zero(ElT)
   end
 
   n = origm
-  truncerr = 0.0
+  truncerr = zero(ElT)
   while n > maxdim
     truncerr += P[n]
     n -= 1
@@ -57,10 +62,10 @@ function truncate!(P::Vector{Float64}; kwargs...)::Tuple{Float64,Float64}
       n -= 1
     end
   else
-    scale = 1.0
+    scale = one(ElT)
     if use_relative_cutoff
       scale = sum(P)
-      (scale == 0.0) && (scale = 1.0)
+      (scale == zero(ElT)) && (scale = one(ElT))
     end
 
     #Continue truncating until *sum* of discarded probability 
@@ -79,8 +84,8 @@ function truncate!(P::Vector{Float64}; kwargs...)::Tuple{Float64,Float64}
 
   if n < origm
     docut = (P[n] + P[n + 1]) / 2
-    if abs(P[n] - P[n + 1]) < 1E-3 * P[n]
-      docut += 1E-3 * P[n]
+    if abs(P[n] - P[n + 1]) < ElT(1e-3) * P[n]
+      docut += ElT(1e-3) * P[n]
     end
   end
 
diff --git a/NEWS.md b/NEWS.md
index e8046e2a7f..c0ac9334de 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -6,6 +6,250 @@ Note that as of Julia v1.5, in order to see deprecation warnings you will need t
 
 After we release v1 of the package, we will start following [semantic versioning](https://semver.org).
 
+ITensors v0.3.19 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Simplify the `rrule`s for priming and tagging MPS/MPO
+
+ITensors v0.3.18 Release Notes
+==============================
+
+Bugs:
+
+- Extend `apply(::MPO, ::MPO)` to `apply(::MPO, ::MPO, ::MPO...)` (#949)
+- Fix AD for `apply(::MPO, ::MPO)` and `contract(::MPO, ::MPO)` (#949)
+- Properly use element type in `randomMPS` in the 1-site case (b66d1b7)
+- Fix bug in `tr(::MPO)` rrule where the derivative was being multiplied twice into the identity MPO (b66d1b7)
+- Fix directsum when specifying a single `Index` (#930)
+- Fix bug in loginner when inner is negative or complex (#945)
+- Fix subtraction bug in `OpSum` (#945)
+
+Enhancements:
+
+- Define "I" for Qudit/Boson type (b66d1b7)
+- Only warn in `inner` if the result is `Inf` or `NaN` (b66d1b7)
+- Make sure `randomITensor(())` and `randomITensor(Float64, ())` returns a Dense storage type (b66d1b7)
+- Define `isreal` and `iszero` for ITensors (b66d1b7)
+- Project element type of ITensor in reverse pass of tensor-tensor or scalar-tensor contraction (b66d1b7)
+- Define reverse rules for ITensor subtraction and negation (b66d1b7)
+- Define `map` for ITensors (b66d1b7)
+- Throw error when performing eigendecomposition of tensor with NaN or Inf elements (b66d1b7)
+- Fix `rrule` for `MPO` constructor by generalizing the `rrule` for the `MPS` constructor (#946)
+- Forward truncation arguments to more operations in `rrule` for `apply` (#945)
+- Add rrules for addition and subtraction of MPOs (#935)
+
+ITensors v0.3.17 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Add Zp as alias for operator Z+, etc. (#942)
+- Export diag (#942)
+
+ITensors v0.3.16 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Define `nullspace` for ITensors (#929)
+
+ITensors v0.3.15 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Fix `randomMPS` and `svd` for `Float32`/`ComplexF32` (#926)
+
+ITensors v0.3.14 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Add backend `alg="directsum"` for MPS/MPO addition (#925)
+- Add `alg="naive"` for MPO contraction (#925)
+- Add `svd`/`eigen` option `cutoff<0` or `cutoff=nothing`, indicating that no truncation should be performed based on a cutoff (previously you could only specify `cutoff=0.0` which still truncated eigenvalues of 0) (#925)
+- Fixes an issue that `mindim` wasn't be used in `eigen` (#925)
+- Remove `OpSum` in favor of `Ops.OpSum` (#920)
+
+ITensors v0.3.13 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Implement `min_blockdim` keyword for blocksparse SVD (#923)
+- Add support for non-zero flux MPOs to OpSum (#918)
+
+ITensors v0.3.12 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Fix `svd` and `qr` for empty input left or right indices (#917)
+- Add support for defining MPOs from operators represented as matrices (#904)
+
+ITensors v0.3.11 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Introduce `removeqn` function for removing a specified quantum number (#915)
+- Non-Hermitian `dmrg` (#913)
+- Clean up QN `svd` code in `ITensors` by handling QN blocks better in `NDTensors` (#906)
+
+ITensors v0.3.10 Release Notes
+==============================
+
+Bugs:
+
+Enhancements:
+
+- Update installation instructions for Julia 1.7.
+
+ITensors v0.3.9 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Haar random unitary gate and generalize identity operator to arbitrary number of sites (#903).
+- Improve error messages for op.
+- Return the original MPS/MPO when normalizing a zero MPS/MPO (#901).
+- Allow Matrix representations for operators in `expect` and `correlation_matrix` (#902).
+
+ITensors v0.3.8 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Increase maximum TagSet size to 16 characters (#882)
+
+ITensors v0.3.7 Release Notes
+=============================
+
+Bugs:
+
+- Fix for performance issue when applying gates that skip sites (#900).
+
+Enhancements:
+
+ITensors v0.3.6 Release Notes
+=============================
+
+Bugs:
+
+- Fix bug in `op(opname, s::Vector{<:Index})` and `op(s::Vector{<:Index}, opname)`.
+
+Enhancements:
+
+ITensors v0.3.5 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Generalize `op` to handle `Matrix`/`String` inputs more generically (#899)
+
+ITensors v0.3.4 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Simplify rrules for Index manipulation of ITensors (#888)
+- Add some helper functions like converting element types of ITensors (#898)
+  - `cu([A, B])` -> `[cu(A), cu(B)]` (same for `cpu`).
+  - `cu([[A, B], [C]])` -> `[[cu(A), cu(B)], [cu(C)]]` (same for `cpu`).
+  - `convert_eltype(T::Type, A::ITensor)` - convert the element type of an ITensor to `T`.
+  - `convert_leaf_eltype(T, A::MPS)` - convert the element types of the ITensors of an MPS/MPO.
+  - `convert_leaf_eltype(T, [[A, B], C])` - convert the element types of ITensors `A`, `B`, `C` in a nested data structure (useful for layered gate structures used in PastaQ).
+  - `contract(A::MPS)` - contract the ITensors of an MPS/MPO into an ITensor (previously we used `prod` for that but I think using ` contract` is clearer).
+  - `array(A::ITensor, i::Index, j::Index, ...)` - convert the ITensor to an Array, first permuting into the Index ordering `i, j, ...`. Previously I used `array(permute(A, i, j, ...))` for this but this is more convenient.
+  - `A(x)` as a simpler syntax for `apply(A::ITensor, x::ITensor)`, treating `A` as an operator from unprimed to primed indices. I've already defined this syntax for `MPO` and `MPS` and I think it is pretty nice. I was holding off on doing this for a while to see if there might be a better meaning for `A(B)` but 
+  - Define `complex`, `real`, `imag`, and `conj` for MPS/MPO by applying them to the ITensors of the MPS/MPO. Maybe there is a better meaning for these, as in the MPS that is the real part of the MPS defined as a state?
+
+ITensors v0.3.3 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Add `copy` for `AbstractProjMPO` (#895)
+
+ITensors v0.3.2 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Introduce `set_nsite!` generic `AbstractProjMPO` function (#894)
+- Factorize out `contract(::ProjMPO, ::ITensor)` (#893)
+
+ITensors v0.3.1 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Introduce `Algorithm` type for selecting algorithm backends (#886)
+
+ITensors v0.3.0 Release Notes
+=============================
+
+Bugs:
+
+Enhancements:
+
+- Introduce `apply(::MPO, ::MPO)` (#880)
+- Make automatic differentiation work for `contract(::ITensor...)` (#878)
+- Deprecate automatically making indices match in `inner` and `outer` (#877)
+  - Add test for `apply(::MPO, ::MPS) = noprime(contract(::MPO, ::MPS))` and lazy version `Apply(::MPO, ::MPS)`.
+  - Define `isapprox(::AbstractMPS, ::AbstractMPS)`.
+- correlation_matrix sites keyword (#868)
+  - Implement non-contiguous sites for correlation_matrix
+- rrule for MPS(Vector{::ITensor}) (#865)
+  - `rrule` for constructing an `MPS` from a `Vector{ITensor}`.
+  - Improve `op(::OpName ,::SiteType"Qudit")` for handling two-body ops.
+  - Add support for storing a `Function` in an `op` in the format `(f, opame, support, (params...))`.
+- Fix expect for complex MPS (#867)
+- Get some AD working for LazyApply and Ops (#859)
+- + and - in the op system (#857)
+- Rename expect site_range keyword to sites (#858)
+  - Allow more general sites collections to be passed including single site number that maps to scalar outputs.
+  - Add ishermitian for ITensors
+  - Improve handling of types and non-Hermitian operators in expect
+  - Define ITensor transpose
+- Improve Sweeps constructors with keyword arguments and default init (#856)
+- rrules for apply(U, ::MPO), `(::MPO * ::MPO)`, `tr(::MPO)` (#852)
+- Unification of PastaQ.gate and `ITensors.op`, new `OpSum` algebra functions (#843)
+- Change minimal required Julia version from 1.3 to 1.6 (#849)
+  - Add default `maxdim=typemax(Int)` in `dmrg`.
+
 ITensors v0.2.16 Release Notes
 ==============================
 
diff --git a/PULL_REQUEST_TEMPLATE.md b/PULL_REQUEST_TEMPLATE.md
deleted file mode 100644
index 752adea7a9..0000000000
--- a/PULL_REQUEST_TEMPLATE.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Description
-
-Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
-
-Fixes # (issue)
-
-# How Has This Been Tested?
-
-Please describe the tests that you ran to verify your changes.
-
-- [ ] Test A
-- [ ] Test B
-
-# Checklist:
-
-- [ ] My code follows the style guidelines of this project. Please run `using JuliaFormatter; format(".")` in the base directory of the repository (`~/.julia/dev/ITensors`) to format your code according to our style guidelines.
-- [ ] I have performed a self-review of my own code.
-- [ ] I have commented my code, particularly in hard-to-understand areas.
-- [ ] I have made corresponding changes to the documentation.
-- [ ] My changes generate no new warnings.
-- [ ] Any dependent changes have been merged and published in downstream modules.
diff --git a/Project.toml b/Project.toml
index 0ec5ef9d14..edb849908c 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,9 +1,10 @@
 name = "ITensors"
 uuid = "9136182c-28ba-11e9-034c-db9fb085ebd5"
 authors = ["Matthew Fishman <mfishman@flatironinstitute.org>", "Miles Stoudenmire <mstoudenmire@flatironinstitute.org>"]
-version = "0.2.16"
+version = "0.3.18"
 
 [deps]
+BitIntegers = "c3b6d118-76ef-56ca-8cc7-ebb389d030a1"
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
@@ -27,14 +28,15 @@ Zeros = "bd1ec220-6eb4-527a-9b49-e79c3db6233b"
 ZygoteRules = "700de1a5-db45-46bc-99cf-38207098b444"
 
 [compat]
+BitIntegers = "0.2"
 ChainRulesCore = "1.10"
-Compat = "2.1, 3"
+Compat = "2.1, 3, 4"
 Dictionaries = "0.3.5"
 HDF5 = "0.14, 0.15, 0.16"
-IsApprox = "0.1.4"
+IsApprox = "0.1"
 KrylovKit = "0.4.2, 0.5"
 LinearMaps = "3"
-NDTensors = "0.1.35"
+NDTensors = "0.1.42"
 PackageCompiler = "1.0.0, 2"
 Requires = "1.1"
 SerializedElementArrays = "0.1"
diff --git a/benchmark/Manifest.toml b/benchmark/Manifest.toml
index a4a38c6b4e..dce799027e 100644
--- a/benchmark/Manifest.toml
+++ b/benchmark/Manifest.toml
@@ -1,362 +1,371 @@
 # This file is machine-generated - editing it directly is not advised
 
-[[ArgTools]]
+julia_version = "1.7.2"
+manifest_format = "2.0"
+
+[[deps.ArgTools]]
 uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
 
-[[Artifacts]]
+[[deps.Artifacts]]
 uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 
-[[Base64]]
+[[deps.Base64]]
 uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 
-[[BenchmarkTools]]
+[[deps.BenchmarkTools]]
 deps = ["JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"]
-git-tree-sha1 = "61adeb0823084487000600ef8b1c00cc2474cd47"
+git-tree-sha1 = "4c10eee4af024676200bc7752e536f858c6b8f93"
 uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
-version = "1.2.0"
+version = "1.3.1"
 
-[[Blosc]]
+[[deps.BitIntegers]]
+deps = ["Random"]
+git-tree-sha1 = "5a814467bda636f3dde5c4ef83c30dd0a19928e0"
+uuid = "c3b6d118-76ef-56ca-8cc7-ebb389d030a1"
+version = "0.2.6"
+
+[[deps.Blosc]]
 deps = ["Blosc_jll"]
-git-tree-sha1 = "217da19d6f3a94753e580a8bc241c7cbefd9281f"
+git-tree-sha1 = "310b77648d38c223d947ff3f50f511d08690b8d5"
 uuid = "a74b3585-a348-5f62-a45c-50e91977d574"
-version = "0.7.1"
+version = "0.7.3"
 
-[[Blosc_jll]]
+[[deps.Blosc_jll]]
 deps = ["Artifacts", "JLLWrappers", "Libdl", "Lz4_jll", "Pkg", "Zlib_jll", "Zstd_jll"]
-git-tree-sha1 = "e747dac84f39c62aff6956651ec359686490134e"
+git-tree-sha1 = "91d6baa911283650df649d0aea7c28639273ae7b"
 uuid = "0b7ba130-8d10-5ba8-a3d6-c5182647fed9"
-version = "1.21.0+0"
+version = "1.21.1+0"
 
-[[ChainRulesCore]]
+[[deps.ChainRulesCore]]
 deps = ["Compat", "LinearAlgebra", "SparseArrays"]
-git-tree-sha1 = "f885e7e7c124f8c92650d61b9477b9ac2ee607dd"
+git-tree-sha1 = "9950387274246d08af38f6eef8cb5480862a435f"
 uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
-version = "1.11.1"
+version = "1.14.0"
 
-[[Compat]]
+[[deps.Compat]]
 deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"]
-git-tree-sha1 = "dce3e3fea680869eaa0b774b2e8343e9ff442313"
+git-tree-sha1 = "b153278a25dd42c65abbf4e62344f9d22e59191b"
 uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
-version = "3.40.0"
+version = "3.43.0"
 
-[[CompilerSupportLibraries_jll]]
+[[deps.CompilerSupportLibraries_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"
 
-[[Dates]]
+[[deps.Dates]]
 deps = ["Printf"]
 uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
 
-[[DelimitedFiles]]
+[[deps.DelimitedFiles]]
 deps = ["Mmap"]
 uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"
 
-[[Dictionaries]]
+[[deps.Dictionaries]]
 deps = ["Indexing", "Random"]
-git-tree-sha1 = "43ae37eac34e76ac97d1a7db28561243e7242461"
+git-tree-sha1 = "0340cee29e3456a7de968736ceeb705d591875a2"
 uuid = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
-version = "0.3.15"
+version = "0.3.20"
 
-[[Distributed]]
+[[deps.Distributed]]
 deps = ["Random", "Serialization", "Sockets"]
 uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 
-[[Downloads]]
+[[deps.Downloads]]
 deps = ["ArgTools", "LibCURL", "NetworkOptions"]
 uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
 
-[[ExprTools]]
-git-tree-sha1 = "b7e3d17636b348f005f11040025ae8c6f645fe92"
+[[deps.ExprTools]]
+git-tree-sha1 = "56559bbef6ca5ea0c0818fa5c90320398a6fbf8d"
 uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04"
-version = "0.1.6"
+version = "0.1.8"
 
-[[HDF5]]
+[[deps.HDF5]]
 deps = ["Blosc", "Compat", "HDF5_jll", "Libdl", "Mmap", "Random", "Requires"]
 git-tree-sha1 = "698c099c6613d7b7f151832868728f426abe698b"
 uuid = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 version = "0.15.7"
 
-[[HDF5_jll]]
+[[deps.HDF5_jll]]
 deps = ["Artifacts", "JLLWrappers", "LibCURL_jll", "Libdl", "OpenSSL_jll", "Pkg", "Zlib_jll"]
-git-tree-sha1 = "fd83fa0bde42e01952757f01149dd968c06c4dba"
+git-tree-sha1 = "bab67c0d1c4662d2c4be8c6007751b0b6111de5c"
 uuid = "0234f1f7-429e-5d53-9886-15a909be8d59"
-version = "1.12.0+1"
+version = "1.12.1+0"
 
-[[ITensors]]
-deps = ["ChainRulesCore", "Compat", "Dictionaries", "HDF5", "IsApprox", "KrylovKit", "LinearAlgebra", "LinearMaps", "NDTensors", "PackageCompiler", "Pkg", "Printf", "Random", "Requires", "SerializedElementArrays", "StaticArrays", "Strided", "TimerOutputs", "TupleTools", "Zeros", "ZygoteRules"]
+[[deps.ITensors]]
+deps = ["BitIntegers", "ChainRulesCore", "Compat", "Dictionaries", "HDF5", "IsApprox", "KrylovKit", "LinearAlgebra", "LinearMaps", "NDTensors", "PackageCompiler", "Pkg", "Printf", "Random", "Requires", "SerializedElementArrays", "StaticArrays", "Strided", "TimerOutputs", "TupleTools", "Zeros", "ZygoteRules"]
 path = ".."
 uuid = "9136182c-28ba-11e9-034c-db9fb085ebd5"
-version = "0.2.16"
+version = "0.3.7"
 
-[[Indexing]]
+[[deps.Indexing]]
 git-tree-sha1 = "ce1566720fd6b19ff3411404d4b977acd4814f9f"
 uuid = "313cdc1a-70c2-5d6a-ae34-0150d3930a38"
 version = "1.1.1"
 
-[[InteractiveUtils]]
+[[deps.InteractiveUtils]]
 deps = ["Markdown"]
 uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 
-[[IsApprox]]
+[[deps.IsApprox]]
 deps = ["LinearAlgebra"]
 git-tree-sha1 = "fcf3bcf04bea6483b9d0aa95cef3963ffb4281be"
 uuid = "28f27b66-4bd8-47e7-9110-e2746eb8bed7"
 version = "0.1.4"
 
-[[JLLWrappers]]
+[[deps.JLLWrappers]]
 deps = ["Preferences"]
-git-tree-sha1 = "642a199af8b68253517b80bd3bfd17eb4e84df6e"
+git-tree-sha1 = "abc9885a7ca2052a736a600f7fa66209f96506e1"
 uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
-version = "1.3.0"
+version = "1.4.1"
 
-[[JSON]]
+[[deps.JSON]]
 deps = ["Dates", "Mmap", "Parsers", "Unicode"]
-git-tree-sha1 = "8076680b162ada2a031f707ac7b4953e30667a37"
+git-tree-sha1 = "3c837543ddb02250ef42f4738347454f95079d4e"
 uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
-version = "0.21.2"
+version = "0.21.3"
 
-[[KrylovKit]]
+[[deps.KrylovKit]]
 deps = ["LinearAlgebra", "Printf"]
-git-tree-sha1 = "0328ad9966ae29ccefb4e1b9bfd8c8867e4360df"
+git-tree-sha1 = "49b0c1dd5c292870577b8f58c51072bd558febb9"
 uuid = "0b1a1467-8014-51b9-945f-bf0ae24f4b77"
-version = "0.5.3"
+version = "0.5.4"
 
-[[LazyArtifacts]]
+[[deps.LazyArtifacts]]
 deps = ["Artifacts", "Pkg"]
 uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3"
 
-[[LibCURL]]
+[[deps.LibCURL]]
 deps = ["LibCURL_jll", "MozillaCACerts_jll"]
 uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"
 
-[[LibCURL_jll]]
+[[deps.LibCURL_jll]]
 deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
 uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
 
-[[LibGit2]]
+[[deps.LibGit2]]
 deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
 uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
 
-[[LibSSH2_jll]]
+[[deps.LibSSH2_jll]]
 deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
 uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"
 
-[[Libdl]]
+[[deps.Libdl]]
 uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 
-[[LinearAlgebra]]
+[[deps.LinearAlgebra]]
 deps = ["Libdl", "libblastrampoline_jll"]
 uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
-[[LinearMaps]]
-deps = ["LinearAlgebra", "SparseArrays"]
-git-tree-sha1 = "dbb14c604fc47aa4f2e19d0ebb7b6416f3cfa5f5"
+[[deps.LinearMaps]]
+deps = ["LinearAlgebra", "SparseArrays", "Statistics"]
+git-tree-sha1 = "1693d6d0dfefd24ee97ffc5ea91f1cd2cf77ef6e"
 uuid = "7a12625a-238d-50fd-b39a-03d52299707e"
-version = "3.5.1"
+version = "3.6.1"
 
-[[Logging]]
+[[deps.Logging]]
 uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
 
-[[Lz4_jll]]
+[[deps.Lz4_jll]]
 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
 git-tree-sha1 = "5d494bc6e85c4c9b626ee0cab05daa4085486ab1"
 uuid = "5ced341a-0733-55b8-9ab6-a4889d929147"
 version = "1.9.3+0"
 
-[[MacroTools]]
+[[deps.MacroTools]]
 deps = ["Markdown", "Random"]
 git-tree-sha1 = "3d3e902b31198a27340d0bf00d6ac452866021cf"
 uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 version = "0.5.9"
 
-[[Markdown]]
+[[deps.Markdown]]
 deps = ["Base64"]
 uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
 
-[[MbedTLS_jll]]
+[[deps.MbedTLS_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
 
-[[Mmap]]
+[[deps.Mmap]]
 uuid = "a63ad114-7e13-5084-954f-fe012c677804"
 
-[[MozillaCACerts_jll]]
+[[deps.MozillaCACerts_jll]]
 uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
 
-[[NDTensors]]
+[[deps.NDTensors]]
 deps = ["Compat", "Dictionaries", "HDF5", "LinearAlgebra", "Random", "Requires", "StaticArrays", "Strided", "TimerOutputs", "TupleTools"]
 path = "../NDTensors"
 uuid = "23ae76d9-e61a-49c4-8f12-3f1a16adf9cf"
-version = "0.1.35"
+version = "0.1.37"
 
-[[NetworkOptions]]
+[[deps.NetworkOptions]]
 uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
 
-[[OpenBLAS_jll]]
+[[deps.OpenBLAS_jll]]
 deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]
 uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
 
-[[OpenSSL_jll]]
+[[deps.OpenSSL_jll]]
 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
-git-tree-sha1 = "15003dcb7d8db3c6c857fda14891a539a8f2705a"
+git-tree-sha1 = "ab05aa4cc89736e95915b01e7279e61b1bfe33b8"
 uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
-version = "1.1.10+0"
+version = "1.1.14+0"
 
-[[PackageCompiler]]
-deps = ["Artifacts", "LazyArtifacts", "Libdl", "Pkg", "RelocatableFolders", "UUIDs"]
-git-tree-sha1 = "a16924b37299cc7d6106fac255b44a8c79c7c21f"
+[[deps.PackageCompiler]]
+deps = ["Artifacts", "LazyArtifacts", "Libdl", "Pkg", "Printf", "RelocatableFolders", "UUIDs"]
+git-tree-sha1 = "4ad92047603f8e955503f92767577b32508c39af"
 uuid = "9b87118b-4619-50d2-8e1e-99f35a4d4d9d"
-version = "1.7.7"
+version = "2.0.5"
 
-[[Parsers]]
+[[deps.Parsers]]
 deps = ["Dates"]
-git-tree-sha1 = "ae4bbcadb2906ccc085cf52ac286dc1377dceccc"
+git-tree-sha1 = "621f4f3b4977325b9128d5fae7a8b4829a0c2222"
 uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
-version = "2.1.2"
+version = "2.2.4"
 
-[[Pkg]]
+[[deps.Pkg]]
 deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
 uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 
-[[Preferences]]
+[[deps.Preferences]]
 deps = ["TOML"]
-git-tree-sha1 = "00cfd92944ca9c760982747e9a1d0d5d86ab1e5a"
+git-tree-sha1 = "d3538e7f8a790dc8903519090857ef8e1283eecd"
 uuid = "21216c6a-2e73-6563-6e65-726566657250"
-version = "1.2.2"
+version = "1.2.5"
 
-[[Printf]]
+[[deps.Printf]]
 deps = ["Unicode"]
 uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 
-[[Profile]]
+[[deps.Profile]]
 deps = ["Printf"]
 uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
 
-[[REPL]]
+[[deps.REPL]]
 deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
 uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
 
-[[Random]]
+[[deps.Random]]
 deps = ["SHA", "Serialization"]
 uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
-[[RelocatableFolders]]
+[[deps.RelocatableFolders]]
 deps = ["SHA", "Scratch"]
 git-tree-sha1 = "cdbd3b1338c72ce29d9584fdbe9e9b70eeb5adca"
 uuid = "05181044-ff0b-4ac5-8273-598c1e38db00"
 version = "0.1.3"
 
-[[Requires]]
+[[deps.Requires]]
 deps = ["UUIDs"]
-git-tree-sha1 = "4036a3bd08ac7e968e27c203d45f5fff15020621"
+git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7"
 uuid = "ae029012-a4dd-5104-9daa-d747884805df"
-version = "1.1.3"
+version = "1.3.0"
 
-[[SHA]]
+[[deps.SHA]]
 uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
 
-[[Scratch]]
+[[deps.Scratch]]
 deps = ["Dates"]
 git-tree-sha1 = "0b4b7f1393cff97c33891da2a0bf69c6ed241fda"
 uuid = "6c6a2e73-6563-6170-7368-637461726353"
 version = "1.1.0"
 
-[[Serialization]]
+[[deps.Serialization]]
 uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 
-[[SerializedElementArrays]]
+[[deps.SerializedElementArrays]]
 deps = ["Serialization"]
 git-tree-sha1 = "8e73e49eaebf73486446a3c1eede403bff259826"
 uuid = "d3ce8812-9567-47e9-a7b5-65a6d70a3065"
 version = "0.1.0"
 
-[[SharedArrays]]
+[[deps.SharedArrays]]
 deps = ["Distributed", "Mmap", "Random", "Serialization"]
 uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
 
-[[Sockets]]
+[[deps.Sockets]]
 uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
 
-[[SparseArrays]]
+[[deps.SparseArrays]]
 deps = ["LinearAlgebra", "Random"]
 uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
-[[StaticArrays]]
+[[deps.StaticArrays]]
 deps = ["LinearAlgebra", "Random", "Statistics"]
-git-tree-sha1 = "3c76dde64d03699e074ac02eb2e8ba8254d428da"
+git-tree-sha1 = "4f6ec5d99a28e1a749559ef7dd518663c5eca3d5"
 uuid = "90137ffa-7385-5640-81b9-e52037218182"
-version = "1.2.13"
+version = "1.4.3"
 
-[[Statistics]]
+[[deps.Statistics]]
 deps = ["LinearAlgebra", "SparseArrays"]
 uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
-[[Strided]]
+[[deps.Strided]]
 deps = ["LinearAlgebra", "TupleTools"]
-git-tree-sha1 = "4d581938087ca90eab9bd4bb6d270edaefd70dcd"
+git-tree-sha1 = "972de61ae8cb965c516b871b69bb8594463d39a9"
 uuid = "5e0ebb24-38b0-5f93-81fe-25c709ecae67"
-version = "1.1.2"
+version = "1.2.0"
 
-[[TOML]]
+[[deps.TOML]]
 deps = ["Dates"]
 uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
 
-[[Tar]]
+[[deps.Tar]]
 deps = ["ArgTools", "SHA"]
 uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"
 
-[[Test]]
+[[deps.Test]]
 deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
 uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
-[[TimerOutputs]]
+[[deps.TimerOutputs]]
 deps = ["ExprTools", "Printf"]
-git-tree-sha1 = "7cb456f358e8f9d102a8b25e8dfedf58fa5689bc"
+git-tree-sha1 = "d60b0c96a16aaa42138d5d38ad386df672cb8bd8"
 uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
-version = "0.5.13"
+version = "0.5.16"
 
-[[TupleTools]]
+[[deps.TupleTools]]
 git-tree-sha1 = "3c712976c47707ff893cf6ba4354aa14db1d8938"
 uuid = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6"
 version = "1.3.0"
 
-[[UUIDs]]
+[[deps.UUIDs]]
 deps = ["Random", "SHA"]
 uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
-[[Unicode]]
+[[deps.Unicode]]
 uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
 
-[[Zeros]]
+[[deps.Zeros]]
 deps = ["Test"]
 git-tree-sha1 = "7eb4fd47c304c078425bf57da99a56606150d7d4"
 uuid = "bd1ec220-6eb4-527a-9b49-e79c3db6233b"
 version = "0.3.0"
 
-[[Zlib_jll]]
+[[deps.Zlib_jll]]
 deps = ["Libdl"]
 uuid = "83775a58-1f1d-513f-b197-d71354ab007a"
 
-[[Zstd_jll]]
+[[deps.Zstd_jll]]
 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
-git-tree-sha1 = "cc4bf3fdde8b7e3e9fa0351bdeedba1cf3b7f6e6"
+git-tree-sha1 = "e45044cd873ded54b6a5bac0eb5c971392cf1927"
 uuid = "3161d3a3-bdf6-5164-811a-617609db77b4"
-version = "1.5.0+0"
+version = "1.5.2+0"
 
-[[ZygoteRules]]
+[[deps.ZygoteRules]]
 deps = ["MacroTools"]
 git-tree-sha1 = "8c1a8e4dfacb1fd631745552c8db35d0deb09ea0"
 uuid = "700de1a5-db45-46bc-99cf-38207098b444"
 version = "0.2.2"
 
-[[libblastrampoline_jll]]
+[[deps.libblastrampoline_jll]]
 deps = ["Artifacts", "Libdl", "OpenBLAS_jll"]
 uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"
 
-[[nghttp2_jll]]
+[[deps.nghttp2_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
 
-[[p7zip_jll]]
+[[deps.p7zip_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
diff --git a/benchmark/README.md b/benchmark/README.md
new file mode 100644
index 0000000000..33e1d275ac
--- /dev/null
+++ b/benchmark/README.md
@@ -0,0 +1,45 @@
+# ITensor automated benchmarks
+
+These benchmarks run for every PR. They compare a set of benchmarks (such as basic ITensor operations like contraction) between the PR and the main branch of ITensor.
+
+To run the benchmarks, you should go to the benchmark folder and activate the benchmarks project, and run the benchmarks:
+```julia
+julia> using ITensors
+
+julia> cd(joinpath(pkgdir(ITensors), "benchmarks"))
+
+julia> using Pkg
+
+julia> Pkg.activate(".")
+
+julia> include("benchmarks.jl")
+
+julia> SUITE
+[...]
+```
+The benchmark results will be stored in the "SUITE" object.
+
+Then you can run the benchmark suite using the [interface from BenchmarkTools](https://juliaci.github.io/BenchmarkTools.jl/stable/manual/#Tuning-and-running-a-BenchmarkGroup).
+
+Alternatively, you can run the benchmarks with the [BencharmkCI interface](https://github.com/tkf/BenchmarkCI.jl#running-benchmarkci-interactively=).
+
+## Development
+
+If you are developing the ITensors.jl or NDTensors.jl packages, and any of the dependencies of either of those get updated, you will need to update the Manifest.toml file.
+
+You can do that by removing the Manifest.toml file, checking out the ITensors and NDTensors modules for development, and then create a new Manifest.toml file with `Pkg.resolve`:
+```julia
+julia> using ITensors
+
+julia> cd(joinpath(pkgdir(ITensors), "benchmark"))
+
+julia> rm("Manifest.toml")
+
+julia> Pkg.activate(".")
+
+julia> Pkg.develop(path="..") # Develop ITensors
+
+julia> Pkg.develop(path=joinpath("..", "NDTensors")) # Develop NDTensors
+
+julia> Pkg.resolve()
+```
diff --git a/benchmark/bench_tagset.jl b/benchmark/bench_tagset.jl
index 7b82d76ec4..0e4093c175 100644
--- a/benchmark/bench_tagset.jl
+++ b/benchmark/bench_tagset.jl
@@ -7,6 +7,9 @@ suite = BenchmarkGroup()
 
 suite["tagset"] = @benchmarkable TagSet("abcdefgh,ijklmnop,qrstuvwx,ABCDEFGH")
 suite["tagset_unicode"] = @benchmarkable TagSet("αβγδϵζηθ,ijklmnop,qrstuvwx,ΑΒΓΔΕΖΗΘ")
+suite["tagset_long"] = @benchmarkable TagSet(
+  "abcdefghijklm,nopqrstuvwxyz,ABCDEFGHIJKLM,NOPQRSTUVWXYZ"
+)
 end
 
 BenchTagSet.suite
diff --git a/docs/settings.jl b/docs/settings.jl
index 931cb3cb9a..920468e171 100644
--- a/docs/settings.jl
+++ b/docs/settings.jl
@@ -32,6 +32,7 @@ settings = Dict(
       "MPS and MPO" => "MPSandMPO.md",
       "QN" => "QN.md",
       "SiteType and op, state, val functions" => "SiteType.md",
+      "SiteTypes Included with ITensor" => "IncludedSiteTypes.md",
       "DMRG" => [
         "DMRG.md",
         "Sweeps.md",
@@ -47,6 +48,7 @@ settings = Dict(
       "DMRG FAQs" => "faq/DMRG.md",
       "ITensor Development FAQs" => "faq/Development.md",
       "Relationship of ITensor to other tensor libraries FAQs" => "faq/RelationshipToOtherLibraries.md",
+      "Julia Package Manager FAQs" => "faq/JuliaPkg.md",
     ],
     "Upgrade guides" => ["Upgrading from 0.1 to 0.2" => "UpgradeGuide_0.1_to_0.2.md"],
     "ITensor indices and Einstein notation" => "Einsum.md",
diff --git a/docs/src/AdvancedUsageGuide.md b/docs/src/AdvancedUsageGuide.md
index 5a488bb973..1bc41170be 100644
--- a/docs/src/AdvancedUsageGuide.md
+++ b/docs/src/AdvancedUsageGuide.md
@@ -631,7 +631,7 @@ generated directory inside `~/.julia/packages`. You can find out what version yo
 ```julia
 julia> Pkg.status("ITensors")
       Status `~/.julia/environments/v1.7/Project.toml`
-  [9136182c] ITensors v0.2.12
+  [9136182c] ITensors v0.2.16
 ```
 and you can use [`pkgdir`](https://docs.julialang.org/en/v1/base/base/#Base.pkgdir-Tuple{Module})
 to find out the directory of the source code of a package that you have loaded:
@@ -643,30 +643,42 @@ julia> pkgdir(ITensors)
 ```
 The source code of a package loaded in this way is read-only, so you won't be able to modify it.
 
-If you want to modify the source code of ITensors.jl, you can check it out in development
-mode with `Pkg.develop`:
+If you want to modify the source code of `ITensors.jl`, you should check out the packages
+`NDTensors.jl` and `ITensors.jl` in development mode with `Pkg.develop`:
 ```julia
-julia> Pkg.develop("ITensors")
+julia> Pkg.develop(["NDTensors", "ITensors"])
+Path `/home/mfishman/.julia/dev/ITensors` exists and looks like the correct repo. Using existing path.
    Resolving package versions...
     Updating `~/.julia/environments/v1.7/Project.toml`
-  [9136182c] ~ ITensors v0.2.12 ⇒ v0.2.12 `~/.julia/dev/ITensors`
+  [9136182c] ~ ITensors v0.2.16 ⇒ v0.2.16 `~/.julia/dev/ITensors`
+  [23ae76d9] ~ NDTensors v0.1.35 ⇒ v0.1.35 `~/.julia/dev/ITensors/NDTensors`
     Updating `~/.julia/environments/v1.7/Manifest.toml`
-  [9136182c] ~ ITensors v0.2.12 ⇒ v0.2.12 `~/.julia/dev/ITensors`
+  [9136182c] ~ ITensors v0.2.16 ⇒ v0.2.16 `~/.julia/dev/ITensors`
+  [23ae76d9] ~ NDTensors v0.1.35 ⇒ v0.1.35 `~/.julia/dev/ITensors/NDTensors`
 
-julia> Pkg.status("ITensors")
+julia> Pkg.status(["NDTensors", "ITensors"])
       Status `~/.julia/environments/v1.7/Project.toml`
-  [9136182c] ITensors v0.2.12 `~/.julia/dev/ITensors`
+  [9136182c] ITensors v0.2.16 `~/.julia/dev/ITensors`
+  [23ae76d9] NDTensors v0.1.35 `~/.julia/dev/ITensors/NDTensors`
 ```
-Then, Julia will use the version of ITensors.jl living in the directory `~/.julia/dev/ITensors`.
-By default, you will have to restart Julia for modifications of the code in `~/.julia/dev/ITensors`
-to be reflected in practice.
+Then, Julia will use the version of `ITensors.jl` living in the directory `~/.julia/dev/ITensors`
+and the version of `NDTensors.jl` living in the directory `~/.julia/dev/ITensors/NDTensors`,
+though you may need to restart Julia for this to take affect.
+
+We recommend checking out the development versions of both `NDTensors.jl` and `ITensors.jl`
+since we often develop both packages tandem, so the development branch
+of `ITensors.jl` may rely on changes we make in `NDTensors.jl`.
 
+By default, when you modify code in `~/.julia/dev/ITensors` or `~/.julia/dev/ITensors/NDTensors`
+you will need to restart Julia for the changes to take affect.
 A way around this issue is the [Revise](https://timholy.github.io/Revise.jl/stable/) package.
 We highly recommend using the [Revise](https://timholy.github.io/Revise.jl/stable/) package
 when you are developing packages, which automatically detects changes you are making to
 a package you have checked out for development and edit code and not have to restart your Julia session.
-In short, if you have `Revise.jl` loaded, you can edit the code in `~/.julia/dev/ITensors` and
-the changes you make will be reflected on the fly as you use the package.
+In short, if you have `Revise.jl` loaded, you can edit the code in `~/.julia/dev/ITensors` 
+or `~/.julia/dev/ITensors/NDTensors` and the changes you make will be reflected on the fly as
+you use the package (there are some limitations, for example you will need to restart Julia
+if you change the definitions of types).
 
 Note that the code in `~/.julia/dev/ITensors` is just a git repository cloned from
 the repository https://github.com/ITensor/ITensors.jl, so you can do anything that
@@ -685,18 +697,21 @@ where you would replace `mtfishman` with your own Github username.
 Make the changes to the code in `~/.julia/dev/ITensors`, push the changes to your fork, and then
 [make a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) to the [ITensors.jl Github repository](https://github.com/ITensor/ITensors.jl/compare).
 
-To go back to the official version of the ITensors.jl package, you can use the command `Pkg.free("ITensors")`:
+To go back to the official version of the `NDTensors.jl` and `ITensors.jl` packages, you can use the command `Pkg.free(["NDTensors", "ITensors"])`:
 ```julia
-julia> Pkg.free("ITensors")
+julia> Pkg.free(["NDTensors", "ITensors"])
    Resolving package versions...
     Updating `~/.julia/environments/v1.7/Project.toml`
-  [9136182c] ~ ITensors v0.2.12 `~/.julia/dev/ITensors` ⇒ v0.2.12
+  [9136182c] ~ ITensors v0.2.16 `~/.julia/dev/ITensors` ⇒ v0.2.16
+  [23ae76d9] ~ NDTensors v0.1.35 `~/.julia/dev/ITensors/NDTensors` ⇒ v0.1.35
     Updating `~/.julia/environments/v1.7/Manifest.toml`
-  [9136182c] ~ ITensors v0.2.12 `~/.julia/dev/ITensors` ⇒ v0.2.12
+  [9136182c] ~ ITensors v0.2.16 `~/.julia/dev/ITensors` ⇒ v0.2.16
+  [23ae76d9] ~ NDTensors v0.1.35 `~/.julia/dev/ITensors/NDTensors` ⇒ v0.1.35
 
-julia> Pkg.status("ITensors")
+julia> Pkg.status(["NDTensors", "ITensors"])
       Status `~/.julia/environments/v1.7/Project.toml`
-  [9136182c] ITensors v0.2.12
+  [9136182c] ITensors v0.2.16
+  [23ae76d9] NDTensors v0.1.35
 ```
 so it returns to the version of the package you would have just after installing with `Pkg.add`.
 
@@ -716,7 +731,7 @@ julia> using Pkg
 
 julia> Pkg.status("ITensors")
       Status `~/.julia/environments/v1.7/Project.toml`
-  [9136182c] ITensors v0.2.12 `~/.julia/dev/ITensors`
+  [9136182c] ITensors v0.2.16 `~/.julia/dev/ITensors`
 
 julia> using ITensors
 
diff --git a/docs/src/ITensorType.md b/docs/src/ITensorType.md
index 30b56200f2..603eff7a23 100644
--- a/docs/src/ITensorType.md
+++ b/docs/src/ITensorType.md
@@ -50,7 +50,10 @@ delta(::Type{<:Number}, ::QN, ::ITensors.Indices)
 ## Convert to Array
 
 ```@docs
-Array{ElT, N}(::ITensor, ::Vararg{Index, N}) where {ElT, N}
+Array{ElT, N}(::ITensor, ::ITensors.Indices) where {ElT, N}
+array(::ITensor, ::Any...)
+matrix(::ITensor, ::Any...)
+vector(::ITensor, ::Any...)
 array(::ITensor)
 matrix(::ITensor)
 vector(::ITensor)
diff --git a/docs/src/IncludedSiteTypes.md b/docs/src/IncludedSiteTypes.md
new file mode 100644
index 0000000000..57d50939d0
--- /dev/null
+++ b/docs/src/IncludedSiteTypes.md
@@ -0,0 +1,336 @@
+# SiteTypes Included with ITensor
+
+## "S=1/2" SiteType
+
+Site indices with the "S=1/2" site type represent ``S=1/2`` spins with the states
+``|\!\uparrow\rangle``, ``|\!\downarrow\rangle``.
+
+Making a single "S=1/2" site or collection of N "S=1/2" sites
+```
+s = siteind("S=1/2")
+sites = siteinds("S=1/2",N)
+```
+
+Available keyword arguments for enabling and customizing quantum numbers (QN) subspaces:
+- `conserve_qns` (default: false): conserve total ``S^z``
+- `conserve_sz` (default: conserve_qns): conserve total ``S^z``
+- `conserve_szparity` (default: false): conserve total ``S^z`` modulo two
+- `qnname_sz` (default: "Sz"): name of total ``S^z`` QN
+- `qnname_szparity` (default: "SzParity"): name of total ``S^z`` modulo two QN
+For example:
+```
+sites = siteinds("S=1/2",N; conserve_szparity=true, qnname_szparity="SzP")
+```
+
+Operators associated with "S=1/2" sites can be made using the `op` function,
+for example
+```
+Sz = op("Sz",s)
+Sz4 = op("Sz",sites[4])
+```
+
+Available operators are exactly the same as those for the "Qubit" site type. Please
+see the list of "Qubit" operators below.
+
+## "Qubit" SiteType
+
+Site indices with the "Qubit" site type represent qubits with the states
+``|0\rangle``, ``|1\rangle``.
+
+Making a single "Qubit" site or collection of N "Qubit" sites
+```
+s = siteind("Qubit")
+sites = siteinds("Qubit",N)
+```
+
+Available keyword arguments for enabling and customizing quantum numbers (QN) subspaces:
+- `conserve_qns` (default: false): conserve total qubit parity
+- `conserve_parity` (default: conserve_qns): conserve total qubit parity
+- `conserve_number` (default: false): conserve total qubit number
+- `qnname_parity` (default: "Parity"): name of total qubit parity QN
+- `qnname_number` (default: "Number"): name of total qubit number QN
+For example:
+```
+sites = siteinds("Qubit",N; conserve_parity=true)
+```
+
+Operators or gates associated with "Qubit" sites can be made using the `op` function,
+for example
+```
+H = op("H",s)
+H3 = op("H",sites[3])
+```
+
+Single-qubit operators:
+- `"X"` (aliases: `"σx"`, `"σ1"`) Pauli X operator
+- `"Y"` (aliases: `"σy"`, `"σ2"`) Pauli Y operator
+- `"iY"` (aliases: `"iσy"`, `"iσ2"`) Pauli Y operator times i
+- `"Z"` (aliases: `"σz"`, `"σ3"`) Pauli Z operator
+- `"√NOT"` (aliases: `"X"`)
+- `"H"` Hadamard gate
+- `"Phase"` (takes optional argument: ϕ=π/2) (aliases: `"P"`, `"S"`)
+- `"π/8"` (aliases: `"T"`)
+- `"Rx"` (takes argument: θ) Rotation around x axis
+- `"Ry"` (takes argument: θ) Rotation around y axis
+- `"Rz"` (takes argument: ϕ) Rotation around z axis
+- `"Rn"` (takes arguments: θ, ϕ, λ) (aliases: `"Rn̂"`) Rotation about axis n=(θ, ϕ, λ)
+
+Spin operators:
+- `"Sz"` (aliases: `"Sᶻ"`)
+- `"S+"` (alises: `"S⁺"`, `"Splus"`)
+- `"S-"` (aliases: `"S⁻"`, `"Sminus"`)
+- `"Sx"` (alises: `"Sˣ"`)
+- `"iSy"` (aliases: `"iSʸ"`)
+- `"Sy"` (aliases: `"Sʸ"`)
+- `"S2"` (aliases: "S²"`)
+- `"ProjUp"` (aliases: `"projUp"`)
+- `"ProjDn"` (aliases: `"projDn"`)
+
+Two-qubit gates:
+- `"CNOT"` (aliases: `"CX"`) Controlled NOT gate
+- `"CY"` Controlled Y gate
+- `"CZ"` Controlled Z gate
+- `"CPHASE"` (aliases: `"Cphase"`) Controlled Phase gate
+- `"CRx"` (aliases: `"CRX"`) (takes arguments: θ)
+- `"CRy"` (aliases: `"CRY"`) (takes arguments: θ)
+- `"CRz"` (aliases: `"CRZ"`) (takes arguments: ϕ)
+- `"CRn"` (aliases: `"CRn̂"`) (takes arguments: θ, ϕ, λ)
+- `"SWAP"` (aliases: `"Swap"`) 
+- `"√SWAP"` (aliases: `"√Swap"`) 
+- `"iSWAP"` (aliases: `"iSwap"`) 
+- `"√iSWAP"` (aliases: `"√iSwap"`) 
+- `"Rxx"` (aliases: `"RXX"`) (takes arguments: ϕ) Ising (XX) coupling gate
+- `"Ryy"` (aliases: `"RYY"`) (takes arguments: ϕ) Ising (YY) coupling gate
+- `"Rzz"` (aliases: `"RZZ"`) (takes arguments: ϕ) Ising (ZZ) coupling gate
+
+Three-qubit gates:
+- `"Toffoli"` (aliases `"CCNOT"`, `"CCX"`, `"TOFF"`)
+- `"Fredkin"` (aliases `"CSWAP"`, `"CSwap"`, `"CS"`)
+
+Four-qubit gates:
+- `"CCCNOT"`
+
+## "S=1" SiteType
+
+Site indices with the "S=1" site type represent ``S=1`` spins with the states
+``|\!\uparrow\rangle``, ``|0\rangle``, ``|\!\downarrow\rangle``.
+
+Making a single "S=1" site or collection of N "S=1" sites
+```
+s = siteind("S=1")
+sites = siteinds("S=1",N)
+```
+
+Available keyword arguments for enabling and customizing quantum numbers (QN) subspaces:
+- `conserve_qns` (default: false): conserve total ``S^z``
+- `conserve_sz` (default: conserve_qns): conserve total ``S^z``
+- `qnname_sz` (default: "Sz"): name of total ``S^z`` QN
+For example:
+```
+sites = siteinds("S=1",N; conserve_sz=true, qnname_sz="TotalSz")
+```
+
+Operators associated with "S=1" sites can be made using the `op` function,
+for example
+```
+Sz = op("Sz",s)
+Sz4 = op("Sz",sites[4])
+```
+
+Spin operators:
+- `"Sz"` (aliases: `"Sᶻ"`)
+- `"Sz2"` Square of `S^z` operator
+- `"S+"` (alises: `"S⁺"`, `"Splus"`)
+- `"S-"` (aliases: `"S⁻"`, `"Sminus"`)
+- `"Sx"` (alises: `"Sˣ"`)
+- `"Sx2"` Square of `S^x` operator
+- `"iSy"` (aliases: `"iSʸ"`)
+- `"Sy"` (aliases: `"Sʸ"`)
+- `"Sy2"` Square of `S^y` operator
+- `"S2"` (aliases: "S²"`)
+
+## "Boson" SiteType
+
+The "Boson" site type is an alias for the "Qudit" site type. Please
+see more information about "Qudit" below:
+
+## "Qudit" SiteType
+
+Making a single "Qudit" site or collection of N "Qudit" sites
+```
+s = siteind("Qudit")
+sites = siteinds("Qudit",N)
+```
+
+Available keyword arguments for enabling and customizing quantum numbers (QN) subspaces:
+- `dim` (default: 2): dimension of the index (number of qudit or boson values)
+- `conserve_qns` (default: false): conserve total qudit or boson number
+- `conserve_number` (default: conserve_qns): conserve total qudit or boson number
+- `qnname_number` (default: "Number"): name of total qudit or boson number QN
+For example:
+```
+sites = siteinds("Qudit",N; conserve_number=true)
+```
+
+Operators associated with "Qudit" sites can be made using the `op` function,
+for example
+```
+A = op("A",s)
+A4 = op("A",sites[4])
+```
+
+Single-qudit operators:
+- `"A"` (aliases: `"a"`)
+- `"Adag"` (aliases: `"adag"`, `"a†"`)
+- `"N"` (aliases: `"n"`)
+
+Two-qudit operators:
+- `"ab"`
+- `"a†b"`
+- `"ab†"`
+- `"a†b†"`
+
+## "Fermion" SiteType
+
+Site indices with the "Fermion" SiteType represent 
+spinless fermion sites with the states
+``|0\rangle``, ``|1\rangle``, corresponding to zero fermions or one fermion.
+
+Making a single "Fermion" site or collection of N "Fermion" sites
+```
+s = siteind("Fermion")
+sites = siteinds("Fermion",N)
+```
+
+Available keyword arguments for enabling and customizing quantum numbers (QN) subspaces:
+- `conserve_qns` (default: false): conserve total number of fermions
+- `conserve_nf` (default: conserve_qns): conserve total number of fermions
+- `conserve_nfparity` (default: conserve_qns): conserve total fermion number parity
+- `qnname_nf` (default: "Nf"): name of total fermion number QN
+- `qnname_nfparity` (default: "NfParity"): name of total fermion number parity QN
+For example:
+```
+sites = siteinds("Fermion",N; conserve_nfparity=true)
+```
+
+Operators associated with "Fermion" sites can be made using the `op` function,
+for example
+```
+C = op("C",s)
+C4 = op("C",sites[4])
+```
+
+Single-fermion operators:
+- `"N"` (aliases: `"n"`) Density operator
+- `"C"` (aliases: `"c"`) Fermion annihilation operator
+- `"Cdag"` (aliases: `"cdag"`, `"c†"`) Fermion creation operator
+- `"F"` Jordan-Wigner string operator
+
+## "Electron" SiteType
+
+The states of site indices with the "Electron" SiteType correspond to
+``|0\rangle``, ``|\!\uparrow\rangle``, ``|\!\downarrow\rangle``, ``|\!\uparrow\downarrow\rangle``.
+
+Making a single "Electron" site or collection of N "Electron" sites
+```
+s = siteind("Electron")
+sites = siteinds("Electron",N)
+```
+
+Available keyword arguments for enabling and customizing quantum numbers (QN) subspaces:
+- `conserve_qns` (default: false): conserve total number of electrons
+- `conserve_sz` (default: conserve_qns): conserve total ``S^z``
+- `conserve_nf` (default: conserve_qns): conserve total number of electrons
+- `conserve_nfparity` (default: conserve_qns): conserve total electron number parity
+- `qnname_sz` (default: "Sz"): name of total ``S^z`` QN
+- `qnname_nf` (default: "Nf"): name of total electron number QN
+- `qnname_nfparity` (default: "NfParity"): name of total electron number parity QN
+For example:
+```
+sites = siteinds("Electron",N; conserve_nfparity=true)
+```
+
+Operators associated with "Electron" sites can be made using the `op` function,
+for example
+```
+Cup = op("Cup",s)
+Cup4 = op("Cup",sites[4])
+```
+
+Single-fermion operators:
+- `"Ntot"` (aliases: `"ntot"`) Total density operator
+- `"Nup"` (aliases: `"n↑"`) Up density operator
+- `"Ndn"` (aliases: `"n↓"`) Down density operator
+- `"Cup"` (aliases: `"c↑"`) Up-spin annihilation operator
+- `"Cdn"` (aliases: `"c↓"`) Down-spin annihilation operator
+- `"Cdagup"` (aliases: `"c†↑"`) Up-spin creation operator
+- `"Cdagdn"` (aliases: `"c†↓"`) Down-spin creation operator
+- `"Sz"` (aliases: `"Sᶻ"`) 
+- `"Sx"` (aliases: `"Sˣ"`) 
+- `"S+"` (aliases: `"Sp"`, `"S⁺"`,`"Splus"`) 
+- `"S-"` (aliases: `"Sm"`, `"S⁻"`, `"Sminus"`) 
+- `"F"` Jordan-Wigner string operator
+- `"Fup"` (aliases: `"F↑"`) Up-spin Jordan-Wigner string operator
+- `"Fdn"` (aliases: `"F↓"`) Down-spin Jordan-Wigner string operator
+
+Non-fermionic single particle operators (these do not have Jordan-Wigner string attached,
+so will commute within systems such as OpSum or the `apply` function):
+- `"Aup"` (aliases: `"a↑"`) Up-spin annihilation operator
+- `"Adn"` (aliases: `"a↓"`) Down-spin annihilation operator
+- `"Adagup"` (aliases: `"a†↑"`) Up-spin creation operator
+- `"Adagdn"` (aliases: `"a†↓"`) Down-spin creation operator
+
+
+## "tJ" SiteType
+
+"tJ" sites are similar to electron sites, but cannot be doubly occupied
+The states of site indices with the "tJ" SiteType correspond to
+``|0\rangle``, ``|\!\uparrow\rangle``, ``|\!\downarrow\rangle``.
+
+Making a single "tJ" site or collection of N "tJ" sites
+```
+s = siteind("tJ")
+sites = siteinds("tJ",N)
+```
+
+Available keyword arguments for enabling and customizing quantum numbers (QN) subspaces:
+- `conserve_qns` (default: false): conserve total number of fermions
+- `conserve_nf` (default: conserve_qns): conserve total number of fermions
+- `conserve_nfparity` (default: conserve_qns): conserve total fermion number parity
+- `qnname_nf` (default: "Nf"): name of total fermion number QN
+- `qnname_nfparity` (default: "NfParity"): name of total fermion number parity QN
+For example:
+```
+sites = siteinds("tJ",N; conserve_nfparity=true)
+```
+
+Operators associated with "tJ" sites can be made using the `op` function,
+for example
+```
+Cup = op("Cup",s)
+Cup4 = op("Cup",sites[4])
+```
+
+Single-fermion operators:
+- `"Ntot"` (aliases: `"ntot"`) Total density operator
+- `"Nup"` (aliases: `"n↑"`) Up density operator
+- `"Ndn"` (aliases: `"n↓"`) Down density operator
+- `"Cup"` (aliases: `"c↑"`) Up-spin annihilation operator
+- `"Cdn"` (aliases: `"c↓"`) Down-spin annihilation operator
+- `"Cdagup"` (aliases: `"c†↑"`) Up-spin creation operator
+- `"Cdagdn"` (aliases: `"c†↓"`) Down-spin creation operator
+- `"Sz"` (aliases: `"Sᶻ"`) 
+- `"Sx"` (aliases: `"Sˣ"`) 
+- `"S+"` (aliases: `"Sp"`, `"S⁺"`,`"Splus"`) 
+- `"S-"` (aliases: `"Sm"`, `"S⁻"`, `"Sminus"`) 
+- `"F"` Jordan-Wigner string operator
+- `"Fup"` (aliases: `"F↑"`) Up-spin Jordan-Wigner string operator
+- `"Fdn"` (aliases: `"F↓"`) Down-spin Jordan-Wigner string operator
+
+Non-fermionic single particle operators (these do not have Jordan-Wigner string attached,
+so will commute within systems such as OpSum or the `apply` function):
+- `"Aup"` (aliases: `"a↑"`) Up-spin annihilation operator
+- `"Adn"` (aliases: `"a↓"`) Down-spin annihilation operator
+- `"Adagup"` (aliases: `"a†↑"`) Up-spin creation operator
+- `"Adagdn"` (aliases: `"a†↓"`) Down-spin creation operator
+
diff --git a/docs/src/MPSandMPO.md b/docs/src/MPSandMPO.md
index 3562f4caa3..796a63100d 100644
--- a/docs/src/MPSandMPO.md
+++ b/docs/src/MPSandMPO.md
@@ -112,8 +112,8 @@ settags(::typeof(siteinds), ::typeof(uniqueinds), ::ITensors.AbstractMPS, ::ITen
 ## Operations
 
 ```@docs
-expect(::MPS,::AbstractString...)
-correlation_matrix(::MPS,::AbstractString,::AbstractString)
+expect(::MPS, ::Any)
+correlation_matrix(::MPS, ::AbstractString, ::AbstractString)
 dag(::ITensors.AbstractMPS)
 dense(::ITensors.AbstractMPS)
 movesite(::ITensors.AbstractMPS, ::Pair{Int, Int};orthocenter::Int,kwargs...)
@@ -135,15 +135,23 @@ product(::Vector{ <: ITensor}, ::ITensors.AbstractMPS)
 ## Algebra Operations
 
 ```@docs
+inner(::MPST, ::MPST) where {MPST <: ITensors.AbstractMPS}
 dot(::MPST, ::MPST) where {MPST <: ITensors.AbstractMPS}
+loginner(::MPST, ::MPST) where {MPST <: ITensors.AbstractMPS}
 logdot(::MPST, ::MPST) where {MPST <: ITensors.AbstractMPS}
+inner(::MPS, ::MPO, ::MPS)
+dot(::MPS, ::MPO, ::MPS)
+inner(::MPO, ::MPS, ::MPO, ::MPS)
+dot(::MPO, ::MPS, ::MPO, ::MPS)
 norm(::ITensors.AbstractMPS)
 normalize(::ITensors.AbstractMPS)
 normalize!(::ITensors.AbstractMPS)
 lognorm(::ITensors.AbstractMPS)
 +(::MPS, ::MPS)
 contract(::MPO, ::MPS)
+apply(::MPO, ::MPS)
 contract(::MPO, ::MPO)
+apply(::MPO, ::MPO)
 outer(::MPS, ::MPS)
 projector(::MPS)
 ```
diff --git a/docs/src/Observer.md b/docs/src/Observer.md
index 212fbbc9c2..07cdc892ba 100644
--- a/docs/src/Observer.md
+++ b/docs/src/Observer.md
@@ -97,7 +97,7 @@ which include:
    - psi: the current wavefunction MPS 
    - bond: the bond `b` that was just optimized, corresponding to sites `(b,b+1)` in the two-site DMRG algorihtm
    - sweep: the current sweep number
-   - sweep_is_done: true if at the end of the current sweep, otherwise false
+   - sweep\_is\_done: true if at the end of the current sweep, otherwise false
    - half_sweep: the half-sweep number, equal to 1 for a left-to-right, first half sweep, or 2 for the second, right-to-left half sweep
    - spec: the Spectrum object returned from factorizing the local superblock wavefunction tensor in two-site DMRG
    - outputlevel: an integer specifying the amount of output to show
diff --git a/docs/src/examples/ITensor.md b/docs/src/examples/ITensor.md
index 9536eafbb9..66bc998034 100644
--- a/docs/src/examples/ITensor.md
+++ b/docs/src/examples/ITensor.md
@@ -442,6 +442,63 @@ Note the use of the optional `positive=true` keyword argument, which ensures tha
 the diagonal elements of `R` are non-negative. With this option, the QR factorization
 is *unique*, which can be useful in certain cases.
 
+## Combining Multiple Indices into One Index
+
+It can be very useful to combine or merge multiple indices of an ITensor into a 
+single Index. Say we have an ITensor with indices `i,j,k` and we want to combine
+Index `i` and Index `k` into a new Index. This new Index (call it `c`) will have
+a dimension whose size is the dimension of `i` times the dimension of `k`.
+
+To carry out this procedure we can make a special kind of ITensor: a combiner.
+To make a combiner, call the function `combiner`, passing the indices you
+want to combine:
+```@example combiner
+using ITensors # hide
+i = Index(4,"i") # hide
+j = Index(3,"j") # hide
+k = Index(2,"k") # hide
+C = combiner(i,k; tags="c")
+nothing # hide
+```
+
+Then if we have an ITensor
+```@example combiner
+T = randomITensor(i,j,k)
+@show inds(T)
+```
+we can combine indices `i` and `k` by contracting with the combiner:
+```@example combiner
+CT = C * T
+nothing # hide
+```
+
+Printing out the indices of the new ITensor `CT` we can see that it 
+has only two indices:
+```@example combiner
+@show inds(CT)
+```
+The first is the newly made combined Index, which was made for us by
+the `combiner` function and the second is the `j` Index of `T`
+which was not part of the combining process. To access the combined
+Index you can call the `combinedind` function on the combiner:
+```@example combiner
+ci = combinedind(C)
+```
+
+We can visualize all of the steps above as follows:
+![](combiner_itensor.png)
+
+Combining is not limited to two indices and you can
+combine any number of indices, in any order, using a combiner.
+
+To undo the combining process and uncombine the Index `c` back into `i,k`,
+just contract with the conjugate of the combiner ITensor `dag(C)`. 
+```@example combiner
+UT = dag(C) * CT
+@show inds(UT)
+```
+
+
 ## Write and Read an ITensor to Disk with HDF5
 
 Saving ITensors to disk can be very useful. For example, you
diff --git a/docs/src/examples/MPSandMPO.md b/docs/src/examples/MPSandMPO.md
index dda047a22e..aea9a9ced5 100644
--- a/docs/src/examples/MPSandMPO.md
+++ b/docs/src/examples/MPSandMPO.md
@@ -418,7 +418,7 @@ sites = siteinds(psi) # Get site indices from your MPS
 H = MPO(ampo,sites)
 
 # Compute <psi|H|psi>
-energy_psi = inner(psi,H,psi)
+energy_psi = inner(psi',H,psi)
 ```
 
 
diff --git a/docs/src/examples/Physics.md b/docs/src/examples/Physics.md
index 9fd67b600f..d97b762cb1 100644
--- a/docs/src/examples/Physics.md
+++ b/docs/src/examples/Physics.md
@@ -66,33 +66,24 @@ using ITensors
 
 ITensors.space(::SiteType"S=3/2") = 4
 
-function ITensors.op!(Op::ITensor,
-                      ::OpName"Sz",
-                      ::SiteType"S=3/2",
-                      s::Index)
-  Op[s'=>1,s=>1] = +3/2
-  Op[s'=>2,s=>2] = +1/2
-  Op[s'=>3,s=>3] = -1/2
-  Op[s'=>4,s=>4] = -3/2
-end
-
-function ITensors.op!(Op::ITensor,
-                      ::OpName"S+",
-                      ::SiteType"S=3/2",
-                      s::Index)
-  Op[s'=>1,s=>2] = sqrt(3)
-  Op[s'=>2,s=>3] = 2
-  Op[s'=>3,s=>4] = sqrt(3)
-end
+ITensors.op(::OpName"Sz",::SiteType"S=3/2") =
+  [+3/2   0    0    0
+     0  +1/2   0    0 
+     0    0  -1/2   0
+     0    0    0  -3/2]
+
+ITensors.op(::OpName"S+",::SiteType"S=3/2") =
+  [0  √3  0  0
+   0   0  2  0
+   0   0  0 √3
+   0   0  0  0] 
+
+ITensors.op(::OpName"S-",::SiteType"S=3/2") =
+  [0   0  0   0
+   √3  0  0   0
+   0   2  0   0
+   0   0  √3  0] 
 
-function ITensors.op!(Op::ITensor,
-                      ::OpName"S-",
-                      ::SiteType"S=3/2",
-                      s::Index)
-  Op[s'=>2,s=>1] = sqrt(3)
-  Op[s'=>3,s=>2] = 2
-  Op[s'=>4,s=>3] = sqrt(3)
-end
 ```
 
 Now let's look at each part of the code above.
@@ -169,23 +160,21 @@ operator as:
 
 ```@example S32
 using ITensors # hide
-function ITensors.op!(Op::ITensor,
-                      ::OpName"Sz",
-                      ::SiteType"S=3/2",
-                      s::Index)
-  Op[s'=>1,s=>1] = +3/2
-  Op[s'=>2,s=>2] = +1/2
-  Op[s'=>3,s=>3] = -1/2
-  Op[s'=>4,s=>4] = -3/2
-end
+
+ITensors.op(::OpName"Sz",::SiteType"S=3/2") =
+  [+3/2   0    0    0
+     0  +1/2   0    0 
+     0    0  -1/2   0
+     0    0    0  -3/2]
 ```
 
-As you can see, the function is passed an ITensor `Op` and an Index `s`. The other
-arguments are there to select which of the various functions named `op!` get called.
-It is guaranteed by the `op` system that the ITensor `Op` will have indices `s` and `s'`.
+As you can see, the function is passed two objects: an `OpName` and a `SiteType`.
+The strings `"Sz"` and `"S=3/2"` are also part of the type of these objects, and 
+have the meaning of which operator name we are defining and which site type these
+operators are defined for.
 
-The body of this overload of `ITensors.op!` is just setting the elements of the `Op`
-ITensor to the correct values that define the `"Sz"` operator for an ``S=3/2`` spin.
+The body of this overload of `ITensors.op` constructs and returns a Julia matrix
+which gives the matrix elements of the operator we are defining.
 
 Once this function is defined, and if you have an Index such as
 
@@ -204,7 +193,7 @@ println(Sz)
 Again, through the magic of the `SiteType`
 system, the ITensor library takes your Index, reads off its tags, 
 notices that one of them is `"S=3/2"`, and converts this into the type 
-`SiteType"S=3/2"` in order to call the specialized function `ITensors.op!` defined above.
+`SiteType"S=3/2"` in order to call the specialized function `ITensors.op` defined above.
 
 You can use the `op` function yourself with a set of site indices created from
 the `siteinds` function like this:
@@ -227,15 +216,14 @@ operator names into OpSum and it will know how to use these operators.
 **Further Steps**
 
 See how the built-in site types are defined inside the ITensor library:
-* [S=1/2 sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/spinhalf.jl) - Dimension 2 local Hilbert space. Similar to the ``Qubit`` site type, shares many of the same operator definitions.
-* [Qubit sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/qubit.jl) - Dimension 2 local Hilbert space. Similar to the ``S=1/2`` site type, shares many of the same operator definitions.
+* [S=1/2 sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/spinhalf.jl) - Dimension 2 local Hilbert space. Similar to the `"Qubit"` site type, shares many of the same operator definitions.
+* [Qubit sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/qubit.jl) - Dimension 2 local Hilbert space. Similar to the `"S=1/2"` site type, shares many of the same operator definitions.
 * [S=1 sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/spinone.jl) - Dimension 3 local Hilbert space.
 * [Fermion sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/fermion.jl) - Dimension 2 local Hilbert space. Spinless fermion site type.
 * [Electron sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/electron.jl) - Dimension 4 local Hilbert space. Spinfull fermion site type.
 * [tJ sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/tj.jl) - Dimension 3 local Hilbert space. Spinfull fermion site type but without a doubly occupied state in the Hilbert space.
-* [Boson sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/boson.jl) - General d-dimensional local Hilbert space. Shares the same operator definitions as the ``Qudit`` site type.
-* [Qudit sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/qudit.jl) - General d-dimensional local Hilbert space. Generalization of the ``Qubit`` site type, shares the same operator definitions as the ``Boson`` site type.
-
+* [Boson sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/boson.jl) - General d-dimensional local Hilbert space. Shares the same operator definitions as the `"Qudit"` site type.
+* [Qudit sites](https://github.com/ITensor/ITensors.jl/blob/main/src/physics/site_types/qudit.jl) - General d-dimensional local Hilbert space. Generalization of the `"Qubit"` site type, shares the same operator definitions as the ``Boson`` site type.
 
 
 ## Make a Custom Local Hilbert Space with QNs
@@ -269,33 +257,25 @@ function ITensors.space(::SiteType"S=3/2";
   return 4
 end
 
-function ITensors.op!(Op::ITensor,
-                      ::OpName"Sz",
-                      ::SiteType"S=3/2",
-                      s::Index)
-  Op[s'=>1,s=>1] = +3/2
-  Op[s'=>2,s=>2] = +1/2
-  Op[s'=>3,s=>3] = -1/2
-  Op[s'=>4,s=>4] = -3/2
-end
+ITensors.op(::OpName"Sz",::SiteType"S=3/2") =
+  [+3/2   0    0    0
+     0  +1/2   0    0 
+     0    0  -1/2   0
+     0    0    0  -3/2]
+
+ITensors.op(::OpName"S+",::SiteType"S=3/2") =
+  [0  √3  0  0
+   0   0  2  0
+   0   0  0 √3
+   0   0  0  0] 
+
+ITensors.op(::OpName"S-",::SiteType"S=3/2") =
+  [0   0  0   0
+   √3  0  0   0
+   0   2  0   0
+   0   0  √3  0] 
 
-function ITensors.op!(Op::ITensor,
-                      ::OpName"S+",
-                      ::SiteType"S=3/2",
-                      s::Index)
-  Op[s'=>1,s=>2] = sqrt(3)
-  Op[s'=>2,s=>3] = 2
-  Op[s'=>3,s=>4] = sqrt(3)
-end
 
-function ITensors.op!(Op::ITensor,
-                      ::OpName"S-",
-                      ::SiteType"S=3/2",
-                      s::Index)
-  Op[s'=>2,s=>1] = sqrt(3)
-  Op[s'=>3,s=>2] = 2
-  Op[s'=>4,s=>3] = sqrt(3)
-end
 ```
 
 Now let's look at each part of the code above.
@@ -337,9 +317,9 @@ to obtain an array of N `"S=3/2"` indices which carry quantum numbers.
 
 **The op Function in the Quantum Number Case**
 
-Note that the `op!` function overloads are exactly the same as for the
+Note that the `op` function overloads are exactly the same as for the
 more basic case of defining an `"S=3/2"` Index type that does not carry
-quantum numbers. There is no need to upgrade any of the `op!` functions 
+quantum numbers. There is no need to upgrade any of the `op` functions 
 for the QN-conserving case. 
 The reason is that all QN, block-sparse information
 about an ITensor is deduced from the indices of the tensor, and setting elements
@@ -356,7 +336,6 @@ on, thus it does not have a well-defined QN flux. But it is perfectly fine to de
 non-QN-conserving ITensors or when ``S^z`` is not conserved.
 
 
-
 ## Extending an Existing Local Hilbert Space
 
 In the two previous examples above, we discussed the basics
@@ -410,12 +389,9 @@ code
 ```julia
 using ITensors
 
-function ITensors.op!(Op::ITensor,
-                      ::OpName"Pup",
-                      ::SiteType"S=1/2",
-                      s::Index)
-  Op[s'=>1,s=>1] = 1.0
-end
+ITensors.op(::OpName"Pup",::SiteType"S=1/2") =
+ [1 0
+  0 0]
 ```
 
 This code can be defined anywhere, such as in your own personal application code and does 
@@ -441,7 +417,6 @@ Pup1 = op("Pup",s[1])
 Pup3 = op("Pup",s[3])
 ```
 
-
 **Using Custom Operators in OpSum (AutoMPO)**
 
 A key use of these `op` system extensions is allowing additional operator names to
diff --git a/docs/src/examples/combiner_itensor.png b/docs/src/examples/combiner_itensor.png
new file mode 100644
index 0000000000..b52357410e
Binary files /dev/null and b/docs/src/examples/combiner_itensor.png differ
diff --git a/docs/src/faq/DMRG.md b/docs/src/faq/DMRG.md
index cd6d2f9d86..b0ed88ef2d 100644
--- a/docs/src/faq/DMRG.md
+++ b/docs/src/faq/DMRG.md
@@ -42,7 +42,7 @@ We list some of these with the most fundamental and important ones first:
 
   ```julia
   H2 = inner(H,psi,H,psi)
-  E = inner(psi,H,psi)
+  E = inner(psi',H,psi)
   var = H2-E^2
   @show var
   ```
diff --git a/docs/src/faq/JuliaPkg.md b/docs/src/faq/JuliaPkg.md
new file mode 100644
index 0000000000..d3a36a0069
--- /dev/null
+++ b/docs/src/faq/JuliaPkg.md
@@ -0,0 +1,31 @@
+# Julia Package Manager Frequently Asked Questions
+
+## What if I can't upgrade ITensors.jl to the latest version?
+
+Sometimes you may find that doing `] update ITensors` or equivalently doing `] up ITensors` within
+Julia package manager mode doesn't result in the ITensors package
+actually being upgraded. You may see that the current version
+you have remains stuck to a version that is lower than the latest one which you 
+can [check here](https://github.com/ITensor/ITensors.jl).
+
+What is most likely going on is that you have other packages installed which
+are blocking ITensors from being updated.
+
+To get more information into which packages may be doing this, and what versions
+they are requiring, you can do the following. First [look up the latest version of ITensors.jl](https://github.com/ITensor/ITensors.jl). Let's say for this example that it is `v0.3.0`. 
+
+Next, input the following command while in package manager mode:
+
+```
+julia> ]
+pkg> add ITensors@v0.3.0
+```
+
+If the package manager cannot update to this version, it will list all of the other packages that are blocking this from happening and give information about why. To go into a little more depth, each package has a compatibility or "compat" entry in its Project.toml file which says which versions of the ITensors package it is compatible with. If these versions do not include the latest one, perhaps because the package has not been updated, then it can block the ITensors package from being updated on your system.
+
+Generally the solution is to just update each of these packages, then try again to update ITensors. If that does not work, then check the following
+* Are any of the blocking packages in "dev mode" meaning you called `dev PackageName` on them in the past? Try doing `free PackageName` if so to bring them out of dev mode.
+* Are any of the blocking packages unregistered packages that were installed through a GitHub repo link? If so, you may need to do something like `add https://github.com/Org/PackageName#main` to force update that package to the latest code available on its main branch.
+
+If you still can't get the ITensors package update, feel free to [post a question](https://itensor.org/support) or [contact us](https://itensor.org/about.html#collaboration) for help.
+
diff --git a/docs/src/getting_started/Installing.md b/docs/src/getting_started/Installing.md
index 5ae6aefcb2..6f2271985e 100644
--- a/docs/src/getting_started/Installing.md
+++ b/docs/src/getting_started/Installing.md
@@ -37,10 +37,15 @@ are assumed to be executed in your home directory):
 ```
 $ cd
 $ mkdir -p bin
-$ wget https://julialang-s3.julialang.org/bin/linux/x64/1.5/julia-1.5.3-linux-x86_64.tar.gz
-$ tar xvzf julia-1.5.3-linux-x86_64.tar.gz
-$ ln -s julia-1.5.3/bin/julia  bin/julia
+$ wget https://julialang-s3.julialang.org/bin/linux/x64/1.7/julia-1.7.2-linux-x86_64.tar.gz
+$ tar xvzf julia-1.7.2-linux-x86_64.tar.gz
+$ ln -s julia-1.7.2/bin/julia  bin/julia
 ```
+If you want to install Julia 1.6.6, you would change `1.7` to `1.6` and `1.7.2` to `1.6.6`.
+In general we recommend using the current stable release of Julia, which you can find out by
+going to [the Julia Downloads page](https://julialang.org/downloads/).
+We also don't recommend using versions of Julia below 1.6, which are no longer compatible
+with ITensors.jl as of ITensors 0.3.
 
 After these steps, you should be able to type `julia` from your terminal to run Julia 
 in interactive mode. If that works, then you have the Julia language and can run it in
@@ -51,7 +56,7 @@ Explanation of the sample commands above:
  - The first command `cd` goes to your home directory. 
  - The second command makes a new folder `bin/` under your home directory if it does not already exist. 
  - The third command downloads the Julia language as a compressed tar.gz file. (You may want to do this step and the follwing steps in a different folder of your choosing.) 
- - The fourth command uncompresses the tar.gz file into a folder called (in this example) `julia-1.5.3`. 
+ - The fourth command uncompresses the tar.gz file into a folder called (in this example) `julia-1.7.2`. 
  - The last command makes a soft link called `julia` in your `bin` directory which links to the Julia language binary within the folder you just unpacked containing the Julia language.
 
 ## Installing ITensor (ITensors.jl Package)
diff --git a/docs/src/index.md b/docs/src/index.md
index 9df314c674..a8996596d4 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -37,7 +37,9 @@ Development of ITensor is supported by the Flatiron Institute, a division of the
 
 ## News
 
-ITensors.jl v0.2 has been released, with a few breaking changes as well as a variety of bug fixes
+- March 25, 2022: ITensors.jl v0.3 has been released. The main breaking change is that we no longer support versions of Julia below 1.6. Julia 1.6 is the long term support version of Julia (LTS), which means that going forward versions below Julia 1.6 won't be as well supported with bug fixes and improvements. Additionally, Julia 1.6 introduced many improvements including syntax improvements that we would like to start using with ITensors.jl, which becomes challenging if we try to support Julia versions below 1.6. See [here](https://www.oxinabox.net/2021/02/13/Julia-1.6-what-has-changed-since-1.0.html) and [here](https://julialang.org/blog/2021/03/julia-1.6-highlights/) for some nice summaries of the Julia 1.6 release.
+
+-  Jun 09, 2021: ITensors.jl v0.2 has been released, with a few breaking changes as well as a variety of bug fixes
 and new features. Take a look at the [upgrade guide](https://itensor.github.io/ITensors.jl/stable/UpgradeGuide_0.1_to_0.2.html)
 for help upgrading your code as well as the [change log](https://github.com/ITensor/ITensors.jl/blob/main/NEWS.md)
 for a comprehensive list of changes.
diff --git a/docs/src/tutorials/MPSTimeEvolution.md b/docs/src/tutorials/MPSTimeEvolution.md
index 3065899406..6b1ee815a2 100644
--- a/docs/src/tutorials/MPSTimeEvolution.md
+++ b/docs/src/tutorials/MPSTimeEvolution.md
@@ -71,45 +71,40 @@ let
   tau = 0.1
   ttotal = 5.0
 
-  # Compute the number of steps to do
-  Nsteps = Int(ttotal/tau)
-
   # Make an array of 'site' indices
-  s = siteinds("S=1/2",N;conserve_qns=true)
+  s = siteinds("S=1/2", N; conserve_qns=true)
 
   # Make gates (1,2),(2,3),(3,4),...
   gates = ITensor[]
-  for j=1:N-1
+  for j in 1:(N - 1)
     s1 = s[j]
-    s2 = s[j+1]
-    hj =       op("Sz",s1) * op("Sz",s2) +
-         1/2 * op("S+",s1) * op("S-",s2) +
-         1/2 * op("S-",s1) * op("S+",s2)
-    Gj = exp(-1.0im * tau/2 * hj)
-    push!(gates,Gj)
+    s2 = s[j + 1]
+    hj =
+      op("Sz", s1) * op("Sz", s2) +
+      1 / 2 * op("S+", s1) * op("S-", s2) +
+      1 / 2 * op("S-", s1) * op("S+", s2)
+    Gj = exp(-im * tau / 2 * hj)
+    push!(gates, Gj)
   end
   # Include gates in reverse order too
   # (N,N-1),(N-1,N-2),...
-  append!(gates,reverse(gates))
+  append!(gates, reverse(gates))
 
   # Initialize psi to be a product state (alternating up and down)
   psi = productMPS(s, n -> isodd(n) ? "Up" : "Dn")
 
-  c = div(N,2) # center site
+  c = div(N, 2) # center site
+
+  # Compute and print <Sz> at each time step
+  # then apply the gates to go to the next time
+  for t in 0.0:tau:ttotal
+    Sz = expect(psi, "Sz"; sites=c)
+    println("$t $Sz")
 
-  # Compute and print initial <Sz> value on site c
-  t = 0.0
-  Sz = expect(psi,"Sz";site_range=c:c)
-  println("$t $Sz")
+    t≈ttotal && break
 
-  # Do the time evolution by applying the gates
-  # for Nsteps steps and printing <Sz> on site c
-  for step=1:Nsteps
-    psi = apply(gates, psi; cutoff=cutoff)
+    psi = apply(gates, psi; cutoff)
     normalize!(psi)
-    t += tau
-    Sz = expect(psi,"Sz";site_range=c:c)
-    println("$t $Sz")
   end
 
   return
@@ -118,8 +113,7 @@ end
 
 **Steps of The Code**
 
-After setting some parameters, like the system size N and time step ``\tau`` to use,
-we compute the number of time evolution steps `Nsteps` that will be needed.
+First we setsome parameters, like the system size N and time step ``\tau`` to use.
 
 The line `s = siteinds("S=1/2",N;conserve_qns=true)` defines an array of 
 spin 1/2 tensor indices (Index objects) which will be the site or physical
@@ -153,7 +147,7 @@ a factor ``-i \tau/2`` and then append or push this onto the end of the
 gate array `gates`.
 
 ```julia
-Gj = exp(-1.0im * tau/2 * hj)
+Gj = exp(-im * tau/2 * hj)
 push!(gates,Gj)
 ```
 
@@ -164,24 +158,23 @@ formula. Here we can conveniently do that by just calling the Julia
 gates we have made so far. This can
 be done in a single line of code `append!(gates,reverse(gates))`.
 
-So that the code produces interesting output, we define a function
-called `measure_Sz` that we will pass our MPS into and which will
-return the expected value of ``S^z`` on a given site, which
-we will take to be near the center of the MPS. The details of this 
-function are outside the scope of this tutorial, but are explained in the
-example code for measuring MPS.
-
 The line of code `psi = productMPS(s, n -> isodd(n) ? "Up" : "Dn")`
 initializes our MPS `psi` as a product state of alternating 
-up and down spins. We call `measure_Sz` before starting the
-time evolution.
+up and down spins.
+
+To carry out the time evolution we loop over
+the range of times from 0.0 to `ttotal` in steps of `tau`,
+using the Julia range notation `0.0:tau:ttotal` to easily 
+set up this loop as `for t in 0.0:tau:ttotal`.
+
+Inside the loop, we use the `expect` function to measure
+the expected value of the `"Sz"` operator on the center 
+site.
 
-Finally, to carry out the time evolution we loop over
-the step number `for step=1:Nsteps` and during each
-step call the function 
+To evolve the MPS to the next time, we call the function 
 
 ```julia
-psi = apply(gates, psi; cutoff=cutoff)
+psi = apply(gates, psi; cutoff)
 ```
 
 which applies the array of ITensors called `gates` to our current
diff --git a/docs/src/tutorials/QN_DMRG.md b/docs/src/tutorials/QN_DMRG.md
index bf35f738bd..ac6aae94d8 100644
--- a/docs/src/tutorials/QN_DMRG.md
+++ b/docs/src/tutorials/QN_DMRG.md
@@ -73,7 +73,7 @@ Sample output:
  3: QN("Sz",-2) => 1
 ```
 
-In the sample output above, note than in addition to the dimension of these indices being 3, each of the three settings of the Index have a unique QN associated to them. The number after the QN on each line is the dimension of that subspace, which is 1 for each subspace of the Index objects above. Note also that `"Sz"` quantum numbers in ITensor are measured in units of ``1/2``, so `QN("Sz",2)` corresponds to ``S^z=1`` in conventional physics units.
+In the sample output above, note that in addition to the dimension of these indices being 3, each of the three settings of the Index have a unique QN associated to them. The number after the QN on each line is the dimension of that subspace, which is 1 for each subspace of the Index objects above. Note also that `"Sz"` quantum numbers in ITensor are measured in units of ``1/2``, so `QN("Sz",2)` corresponds to ``S^z=1`` in conventional physics units.
 
 **Change 2: Initial State**
 
diff --git a/docs/src/tutorials/tebd.jl b/docs/src/tutorials/tebd.jl
index 8f94dd6b18..b393aa69cc 100644
--- a/docs/src/tutorials/tebd.jl
+++ b/docs/src/tutorials/tebd.jl
@@ -6,9 +6,6 @@ let
   tau = 0.1
   ttotal = 5.0
 
-  # Compute the number of steps to do
-  Nsteps = Int(ttotal / tau)
-
   # Make an array of 'site' indices
   s = siteinds("S=1/2", N; conserve_qns=true)
 
@@ -33,19 +30,16 @@ let
 
   c = div(N, 2) # center site
 
-  # Compute and print initial <Sz> value on site c
-  t = 0.0
-  Sz = expect(psi, "Sz"; site_range=c:c)
-  println("$t $Sz")
+  # Compute and print <Sz> at each time step
+  # then apply the gates to go to the next time
+  for t in 0.0:tau:ttotal
+    Sz = expect(psi, "Sz"; sites=c)
+    println("$t $Sz")
+
+    t ≈ ttotal && break
 
-  # Do the time evolution by applying the gates
-  # for Nsteps steps and printing <Sz> on site c
-  for step in 1:Nsteps
-    psi = apply(gates, psi; cutoff=cutoff)
+    psi = apply(gates, psi; cutoff)
     normalize!(psi)
-    t += tau
-    Sz = expect(psi, "Sz"; site_range=c:c)
-    println("$t $Sz")
   end
 
   return nothing
diff --git a/examples/autodiff/mps_autodiff.jl b/examples/autodiff/mps_autodiff.jl
new file mode 100644
index 0000000000..5130a8a641
--- /dev/null
+++ b/examples/autodiff/mps_autodiff.jl
@@ -0,0 +1,49 @@
+using ITensors
+using OptimKit
+using Zygote
+
+function ising(n; J, h)
+  os = OpSum()
+  for j in 1:(n - 1)
+    os += -J, "Z", j, "Z", j + 1
+  end
+  for j in 1:n
+    os += -h, "X", j
+  end
+  return os
+end
+
+function loss(H, ψ)
+  n = length(ψ)
+  ψHψ = ITensor(1.0)
+  ψψ = ITensor(1.0)
+  for j in 1:n
+    ψHψ = ψHψ * dag(ψ[j]') * H[j] * ψ[j]
+    ψψ = ψψ * replaceinds(dag(ψ[j]'), s[j]' => s[j]) * ψ[j]
+  end
+  return ψHψ[] / ψψ[]
+end
+
+n = 10
+s = siteinds("S=1/2", n)
+J = 1.0
+h = 0.5
+
+# Loss function only works with `Vector{ITensor}`,
+# extract with `ITensors.data`.
+ψ0 = ITensors.data(randomMPS(s; linkdims=10))
+H = ITensors.data(MPO(ising(n; J, h), s))
+
+loss(ψ) = loss(H, ψ)
+
+optimizer = LBFGS(; maxiter=25, verbosity=2)
+function loss_and_grad(x)
+  y, (∇,) = withgradient(loss, x)
+  return y, ∇
+end
+ψ, fs, gs, niter, normgradhistory = optimize(loss_and_grad, ψ0, optimizer)
+Edmrg, ψdmrg = dmrg(MPO(H), MPS(ψ0); nsweeps=10, cutoff=1e-8)
+
+@show loss(ψ0), norm(loss'(ψ0))
+@show loss(ψ), norm(loss'(ψ))
+@show loss(ITensors.data(ψdmrg)), norm(loss'(ITensors.data(ψdmrg)))
diff --git a/examples/exact_diagonalization/exact_diagonalization.jl b/examples/exact_diagonalization/exact_diagonalization.jl
new file mode 100644
index 0000000000..1b883086c9
--- /dev/null
+++ b/examples/exact_diagonalization/exact_diagonalization.jl
@@ -0,0 +1,63 @@
+using ITensors
+using KrylovKit
+using LinearAlgebra
+using MKL
+
+include("fuse_inds.jl")
+
+ITensors.Strided.disable_threads()
+ITensors.disable_threaded_blocksparse()
+
+function heisenberg(n)
+  os = OpSum()
+  for j in 1:(n - 1)
+    os += 1 / 2, "S+", j, "S-", j + 1
+    os += 1 / 2, "S-", j, "S+", j + 1
+    os += "Sz", j, "Sz", j + 1
+  end
+  return os
+end
+
+function main(n; blas_num_threads=Sys.CPU_THREADS, fuse=true, binary=true)
+  if n > 16
+    @warn "System size of $n is likely too large for exact diagonalization."
+  end
+
+  BLAS.set_num_threads(blas_num_threads)
+
+  # Hilbert space
+  s = siteinds("S=1/2", n; conserve_qns=true)
+  H = MPO(heisenberg(n), s)
+  initstate(j) = isodd(j) ? "↑" : "↓"
+  ψ0 = randomMPS(s, initstate; linkdims=10)
+
+  edmrg, ψdmrg = dmrg(H, ψ0; nsweeps=10, cutoff=1e-6)
+
+  if fuse
+    if binary
+      println("Fuse the indices using a binary tree")
+      T = fusion_tree_binary(s)
+      H_full = @time fuse_inds_binary(H, T)
+      ψ0_full = @time fuse_inds_binary(ψ0, T)
+    else
+      println("Fuse the indices using an unbalances tree")
+      T = fusion_tree(s)
+      H_full = @time fuse_inds(H, T)
+      ψ0_full = @time fuse_inds(ψ0, T)
+    end
+  else
+    println("Don't fuse the indices")
+    @disable_warn_order begin
+      H_full = @time contract(H)
+      ψ0_full = @time contract(ψ0)
+    end
+  end
+
+  vals, vecs, info = @time eigsolve(
+    H_full, ψ0_full, 1, :SR; ishermitian=true, tol=1e-6, krylovdim=30, eager=true
+  )
+
+  @show edmrg, vals[1]
+end
+
+main(14)
diff --git a/examples/exact_diagonalization/fuse_inds.jl b/examples/exact_diagonalization/fuse_inds.jl
new file mode 100644
index 0000000000..4813559de2
--- /dev/null
+++ b/examples/exact_diagonalization/fuse_inds.jl
@@ -0,0 +1,91 @@
+using ITensors
+
+function fusion_tree(s::Vector{<:Index})
+  n = length(s)
+  Cs = Vector{ITensor}(undef, n - 1)
+  cj = s[1]
+  for j in 1:(n - 1)
+    fuse_inds = (cj, s[j + 1])
+    Cj = combiner(fuse_inds...)
+    Cs[j] = Cj
+    cj = uniqueind(Cj, fuse_inds)
+  end
+  return Cs
+end
+
+function fuse_inds(A::MPS, fusion_tree::Vector{ITensor})
+  n = length(A)
+  A_fused = A[1]
+  for j in 2:n
+    A_fused = A_fused * A[j] * fusion_tree[j - 1]
+  end
+  return A_fused
+end
+
+function fuse_inds(A::MPO, fusion_tree::Vector{ITensor})
+  n = length(A)
+  A_fused = A[1]
+  for j in 2:n
+    A_fused = A_fused * A[j] * dag(fusion_tree[j - 1]) * fusion_tree[j - 1]'
+  end
+  return A_fused
+end
+
+function fusion_tree_binary_layer(s::Vector{IndexT}; layer=1) where {IndexT<:Index}
+  n = length(s)
+  Cs = ITensor[]
+  cs = IndexT[]
+  for j in 1:2:(n - 1)
+    fuse_inds = (s[j], s[j + 1])
+    Cj = combiner(fuse_inds...; tags="n=$(j)⊗$(j + 1),l=$(layer)")
+    push!(Cs, Cj)
+    cj = uniqueind(Cj, fuse_inds)
+    push!(cs, cj)
+  end
+  if isodd(n)
+    push!(cs, last(s))
+  end
+  return Cs, cs
+end
+
+function fusion_tree_binary(s::Vector{<:Index}; depth=ceil(Int, log2(length(s))))
+  Cs = Vector{ITensor}[]
+  c_layer = s
+  for layer in 1:depth
+    C_layer, c_layer = fusion_tree_binary_layer(c_layer; layer)
+    push!(Cs, C_layer)
+  end
+  return Cs
+end
+
+function fuse_tensors(A::MPS, fusion_tree_layer::Vector{ITensor}, j::Int)
+  return A[j] * A[j + 1] * fusion_tree_layer[(j + 1) ÷ 2]
+end
+
+function fuse_tensors(A::MPO, fusion_tree_layer::Vector{ITensor}, j::Int)
+  return A[j] *
+         A[j + 1] *
+         dag(fusion_tree_layer[(j + 1) ÷ 2]) *
+         fusion_tree_layer[(j + 1) ÷ 2]'
+end
+
+function fuse_inds_binary_layer(A::Union{MPS,MPO}, fusion_tree_layer::Vector{ITensor})
+  n = length(fusion_tree_layer)
+  A_fused = ITensor[]
+  for j in 1:2:(2n)
+    push!(A_fused, fuse_tensors(A, fusion_tree_layer, j))
+  end
+  if isodd(length(A))
+    push!(A_fused, A[end])
+  end
+  return typeof(A)(A_fused)
+end
+
+function fuse_inds_binary(A::Union{MPS,MPO}, fusion_tree::Vector{Vector{ITensor}})
+  depth = length(fusion_tree)
+  A_fused = A
+  for layer in 1:depth
+    A_fused = fuse_inds_binary_layer(A_fused, fusion_tree[layer])
+  end
+  return only(A_fused)
+end
diff --git a/examples/finite_temperature/metts.jl b/examples/finite_temperature/metts.jl
new file mode 100644
index 0000000000..6d68e97e22
--- /dev/null
+++ b/examples/finite_temperature/metts.jl
@@ -0,0 +1,115 @@
+using ITensors
+using Printf
+
+#=
+
+This example code implements the minimally entangled typical thermal state (METTS).
+For more information on METTS, see the following references:
+- "Minimally entangled typical quantum states at finite temperature", Steven R. White,
+  Phys. Rev. Lett. 102, 190601 (2009)
+  and arxiv:0902.4475 (https://arxiv.org/abs/0902.4475)
+- "Minimally entangled typical thermal state algorithms", E M Stoudenmire and Steven R White,
+  New Journal of Physics 12, 055026 (2010) https://doi.org/10.1088/1367-2630/12/5/055026
+
+=#
+
+function ITensors.op(::OpName"expτSS", ::SiteType"S=1/2", s1::Index, s2::Index; τ)
+  h =
+    1 / 2 * op("S+", s1) * op("S-", s2) +
+    1 / 2 * op("S-", s1) * op("S+", s2) +
+    op("Sz", s1) * op("Sz", s2)
+  return exp(τ * h)
+end
+
+"""
+Given a Vector of numbers, returns
+the average and the standard error
+(= the width of distribution of the numbers)
+"""
+function avg_err(v::Vector)
+  N = length(v)
+  avg = v[1] / N
+  avg2 = v[1]^2 / N
+  for j in 2:N
+    avg += v[j] / N
+    avg2 += v[j]^2 / N
+  end
+  return avg, √((avg2 - avg^2) / N)
+end
+
+function main(; N=10, cutoff=1E-8, δτ=0.1, beta=2.0, NMETTS=3000, Nwarm=10)
+
+  # Make an array of 'site' indices
+  s = siteinds("S=1/2", N)
+
+  # Make gates (1,2),(2,3),(3,4),...
+  gates = ops([("expτSS", (n, n + 1), (τ=-δτ / 2,)) for n in 1:(N - 1)], s)
+  # Include gates in reverse order to complete Trotter formula
+  append!(gates, reverse(gates))
+
+  # Make y-rotation gates to use in METTS collapses
+  Ry_gates = ops([("Ry", n, (θ=π / 2,)) for n in 1:N], s)
+
+  # Arbitrary initial state
+  psi = randomMPS(s)
+
+  # Make H for measuring the energy
+  terms = OpSum()
+  for j in 1:(N - 1)
+    terms += 1 / 2, "S+", j, "S-", j + 1
+    terms += 1 / 2, "S-", j, "S+", j + 1
+    terms += "Sz", j, "Sz", j + 1
+  end
+  H = MPO(terms, s)
+
+  # Make τ_range and check δτ is commensurate
+  τ_range = δτ:δτ:(beta / 2)
+  if norm(length(τ_range) * δτ - beta / 2) > 1E-10
+    error("Time step δτ=$δτ not commensurate with beta/2=$(beta/2)")
+  end
+
+  energies = Float64[]
+
+  for step in 1:(Nwarm + NMETTS)
+    if step <= Nwarm
+      println("Making warmup METTS number $step")
+    else
+      println("Making METTS number $(step-Nwarm)")
+    end
+
+    # Do the time evolution by applying the gates
+    for τ in τ_range
+      psi = apply(gates, psi; cutoff)
+      normalize!(psi)
+    end
+
+    # Measure properties after >= Nwarm 
+    # METTS have been made
+    if step > Nwarm
+      energy = inner(psi', H, psi)
+      push!(energies, energy)
+      @printf("  Energy of METTS %d = %.4f\n", step - Nwarm, energy)
+      a_E, err_E = avg_err(energies)
+      @printf(
+        "  Estimated Energy = %.4f +- %.4f  [%.4f,%.4f]\n",
+        a_E,
+        err_E,
+        a_E - err_E,
+        a_E + err_E
+      )
+    end
+
+    # Measure in X or Z basis on alternating steps
+    if step % 2 == 1
+      psi = apply(Ry_gates, psi)
+      samp = sample!(psi)
+      new_state = [samp[j] == 1 ? "X+" : "X-" for j in 1:N]
+    else
+      samp = sample!(psi)
+      new_state = [samp[j] == 1 ? "Z+" : "Z-" for j in 1:N]
+    end
+    psi = productMPS(s, new_state)
+  end
+
+  return nothing
+end
diff --git a/examples/finite_temperature/purification.jl b/examples/finite_temperature/purification.jl
new file mode 100644
index 0000000000..d4b3535f7d
--- /dev/null
+++ b/examples/finite_temperature/purification.jl
@@ -0,0 +1,56 @@
+using ITensors
+using Printf
+
+#=
+
+This example code implements the purification or "ancilla" method for 
+finite temperature quantum systems.
+
+For more information see the following references:
+- "Finite-temperature density matrix renormalization using an enlarged Hilbert space",
+  Adrian E. Feiguin and Steven R. White, Phys. Rev. B 72, 220401(R)
+  and arxiv:cond-mat/0510124 (https://arxiv.org/abs/cond-mat/0510124)
+
+=#
+
+function ITensors.op(::OpName"expτSS", ::SiteType"S=1/2", s1::Index, s2::Index; τ)
+  h =
+    1 / 2 * op("S+", s1) * op("S-", s2) +
+    1 / 2 * op("S-", s1) * op("S+", s2) +
+    op("Sz", s1) * op("Sz", s2)
+  return exp(τ * h)
+end
+
+function main(; N=10, cutoff=1E-8, δτ=0.1, beta_max=2.0)
+
+  # Make an array of 'site' indices
+  s = siteinds("S=1/2", N; conserve_qns=true)
+
+  # Make gates (1,2),(2,3),(3,4),...
+  gates = ops([("expτSS", (n, n + 1), (τ=-δτ / 2,)) for n in 1:(N - 1)], s)
+  # Include gates in reverse order to complete Trotter formula
+  append!(gates, reverse(gates))
+
+  # Initial state is infinite-temperature mixed state
+  rho = MPO(s, "Id") ./ √2
+
+  # Make H for measuring the energy
+  terms = OpSum()
+  for j in 1:(N - 1)
+    terms += 1 / 2, "S+", j, "S-", j + 1
+    terms += 1 / 2, "S-", j, "S+", j + 1
+    terms += "Sz", j, "Sz", j + 1
+  end
+  H = MPO(terms, s)
+
+  # Do the time evolution by applying the gates
+  # for Nsteps steps
+  for β in 0:δτ:beta_max
+    energy = inner(rho, H)
+    @printf("β = %.2f energy = %.8f\n", β, energy)
+    rho = apply(gates, rho; cutoff)
+    rho = rho / tr(rho)
+  end
+
+  return nothing
+end
diff --git a/jenkins/Jenkinsfile b/jenkins/Jenkinsfile
index 65c0f5c0e9..4f32d66f93 100644
--- a/jenkins/Jenkinsfile
+++ b/jenkins/Jenkinsfile
@@ -9,7 +9,7 @@ pipeline {
       parallel {
         stage('julia-1.6') {
 	  options {
-            timeout(time: 30, unit: 'MINUTES')
+            timeout(time: 45, unit: 'MINUTES')
           }
           agent {
             dockerfile {
@@ -36,7 +36,7 @@ pipeline {
         }
         stage('julia-1.7') {
 	  options {
-            timeout(time: 30, unit: 'MINUTES')
+            timeout(time: 45, unit: 'MINUTES')
           }
           agent {
             dockerfile {
diff --git a/src/Deprecated/Deprecated.jl b/src/Deprecated/Deprecated.jl
new file mode 100644
index 0000000000..e2c919dffa
--- /dev/null
+++ b/src/Deprecated/Deprecated.jl
@@ -0,0 +1,7 @@
+module Deprecated
+
+using ..ITensors
+
+include("autompo/autompo.jl")
+
+end
diff --git a/src/Deprecated/autompo/autompo.jl b/src/Deprecated/autompo/autompo.jl
new file mode 100644
index 0000000000..564357d4b4
--- /dev/null
+++ b/src/Deprecated/autompo/autompo.jl
@@ -0,0 +1,12 @@
+using ITensors:
+  parity_sign, using_auto_fermion, QNIndex, Out, blockdim, qnblocknum, BlockSparseTensor
+
+import Base: +, -, *, ==, convert, copy, isempty, isless, length, push!
+import ITensors: MPO
+
+include("opsum.jl")
+include("matelem.jl")
+include("qnmatelem.jl")
+include("opsum_to_mpo_generic.jl")
+include("opsum_to_mpo.jl")
+include("opsum_to_mpo_qn.jl")
diff --git a/src/Deprecated/autompo/matelem.jl b/src/Deprecated/autompo/matelem.jl
new file mode 100644
index 0000000000..5baa776a1d
--- /dev/null
+++ b/src/Deprecated/autompo/matelem.jl
@@ -0,0 +1,40 @@
+##################################
+# MatElem (simple sparse matrix) #
+##################################
+
+struct MatElem{T}
+  row::Int
+  col::Int
+  val::T
+end
+
+#function Base.show(io::IO,m::MatElem)
+#  print(io,"($(m.row),$(m.col),$(m.val))")
+#end
+
+function toMatrix(els::Vector{MatElem{T}})::Matrix{T} where {T}
+  nr = 0
+  nc = 0
+  for el in els
+    nr = max(nr, el.row)
+    nc = max(nc, el.col)
+  end
+  M = zeros(T, nr, nc)
+  for el in els
+    M[el.row, el.col] = el.val
+  end
+  return M
+end
+
+function Base.:(==)(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  return (m1.row == m2.row && m1.col == m2.col && m1.val == m2.val)
+end
+
+function Base.isless(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  if m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
diff --git a/src/Deprecated/autompo/opsum.jl b/src/Deprecated/autompo/opsum.jl
new file mode 100644
index 0000000000..879e15ff96
--- /dev/null
+++ b/src/Deprecated/autompo/opsum.jl
@@ -0,0 +1,365 @@
+###########################
+# SiteOp                  # 
+###########################
+
+struct SiteOp{O,N}
+  name::O
+  site::NTuple{N,Int}
+  params::NamedTuple
+end
+
+SiteOp(op::AbstractArray, site::Tuple) = SiteOp(op, site, NamedTuple())
+SiteOp(op::AbstractArray, site::Int...) = SiteOp(op, site)
+
+# Change NamedTuple() to (;) when we drop older Julia versions
+SiteOp(name::String, site::Tuple) = SiteOp(name, site, NamedTuple())
+SiteOp(name::String, site::Int...) = SiteOp(name, site)
+function SiteOp(name::String, site_params::Union{Int,NamedTuple}...)
+  return SiteOp(name, Base.front(site_params), last(site_params))
+end
+SiteOp(name::String, params::NamedTuple, site::Tuple) = SiteOp(name, site, params)
+SiteOp(name::String, params::NamedTuple, site::Int...) = SiteOp(name, site, params)
+
+function convert(::Type{SiteOp}, op::Pair{Union{String,AbstractArray},Int})
+  return SiteOp(first(op), last(op))
+end
+
+name(s::SiteOp) = s.name
+site(s::SiteOp) = only(s.site)
+sites(s::SiteOp) = s.site
+params(s::SiteOp) = s.params
+
+site_or_sites(s::SiteOp{1}) = site(s)
+site_or_sites(s::SiteOp) = sites(s)
+
+string_site_or_sites(s::SiteOp{1}) = string(site(s))
+string_site_or_sites(s::SiteOp) = string(sites(s))[2:(end - 1)]
+
+show(io::IO, s::SiteOp) = print(io, "\"$(name(s))\"($(string_site_or_sites(s)))")
+
+(s1::SiteOp == s2::SiteOp) = (s1.site == s2.site && s1.name == s2.name)
+
+function isless(s1::SiteOp, s2::SiteOp)
+  if site(s1) != site(s2)
+    return site(s1) < site(s2)
+  end
+  return name(s1) < name(s2)
+end
+
+###########################
+# OpTerm                  # 
+###########################
+
+const OpTerm = Vector{SiteOp}
+
+function (o1::OpTerm == o2::OpTerm)
+  (length(o1) == length(o2)) || return false
+  @inbounds for n in 1:length(o1)
+    (o1[n] != o2[n]) && return false
+  end
+  return true
+end
+
+function isless(o1::OpTerm, o2::OpTerm)
+  if length(o1) != length(o2)
+    return length(o1) < length(o2)
+  end
+  for n in 1:length(o1)
+    if o1[n] != o2[n]
+      return (o1[n] < o2[n])
+    end
+  end
+  return false
+end
+
+mult(t1::OpTerm, t2::OpTerm) = isempty(t2) ? t1 : vcat(t1, t2)
+
+function isfermionic(t::OpTerm, sites)::Bool
+  p = +1
+  for op in t
+    if has_fermion_string(name(op), sites[site(op)])
+      p *= -1
+    end
+  end
+  return (p == -1)
+end
+
+###########################
+# MPOTerm                 # 
+###########################
+
+mutable struct MPOTerm
+  coef::ComplexF64
+  ops::OpTerm
+end
+coef(op::MPOTerm) = op.coef
+ops(op::MPOTerm) = op.ops
+
+copy(t::MPOTerm) = MPOTerm(coef(t), copy(ops(t)))
+
+function (t1::MPOTerm == t2::MPOTerm)
+  return coef(t1) ≈ coef(t2) && ops(t1) == ops(t2)
+end
+
+function isless(t1::MPOTerm, t2::MPOTerm)
+  if ops(t1) == ops(t2)
+    if coef(t1) ≈ coef(t2)
+      return false
+    else
+      ct1 = coef(t1)
+      ct2 = coef(t2)
+      #"lexicographic" ordering on  complex numbers
+      return real(ct1) < real(ct2) || (real(ct1) ≈ real(ct2) && imag(ct1) < imag(ct2))
+    end
+  end
+  return ops(t1) < ops(t2)
+end
+
+function MPOTerm(c::Number, op1::Union{String,AbstractArray{<:Number}}, ops_rest...) #where T<:Number
+  ops = (op1, ops_rest...)
+  starts = findall(x -> (x isa String) || (x isa AbstractArray{<:Number}), ops)
+  N = length(starts)
+  vop = SiteOp[]
+  for n in 1:N
+    start = starts[n]
+    stop = (n == N) ? lastindex(ops) : (starts[n + 1] - 1)
+    vop = [vop; [SiteOp(ops[start:stop]...)]]
+  end
+  return MPOTerm(c, OpTerm(vop))
+end
+
+function MPOTerm(op1::Union{String,AbstractArray}, ops...)
+  return MPOTerm(one(Float64), op1, ops...)
+end
+
+function MPOTerm(ops::Vector{<:Pair})
+  return MPOTerm(Iterators.flatten(ops)...)
+end
+
+function Base.show(io::IO, op::MPOTerm)
+  c = coef(op)
+  if iszero(imag(c))
+    print(io, "$(real(c)) ")
+  elseif iszero(real(c))
+    print(io, "$(imag(c))im ")
+  else
+    print(io, "($c) ")
+  end
+  for o in ops(op)
+    print(io, "\"$(name(o))\"($(string_site_or_sites(o))) ")
+    !isempty(params(o)) && print(io, params(o))
+  end
+end
+
+(α::Number * op::MPOTerm) = MPOTerm(α * coef(op), ops(op))
+(op::MPOTerm * α::Number) = α * op
+(op::MPOTerm / α::Number) = MPOTerm(coef(op) / α, ops(op))
+
+############################
+## OpSum                 #
+############################
+
+"""
+An `OpSum` represents a sum of operator
+terms.
+
+Often it is used to create matrix
+product operator (`MPO`) approximation
+of the sum of the terms in the `OpSum` oject.
+Each term is a product of local operators
+specified by names such as `"Sz"` or `"N"`,
+times an optional coefficient which
+can be real or complex.
+
+Which local operator names are available
+is determined by the function `op`
+associated with the `TagType` defined by
+special Index tags, such as `"S=1/2"`, `"S=1"`,
+`"Fermion"`, and `"Electron"`.
+"""
+mutable struct OpSum
+  data::Vector{MPOTerm}
+  OpSum(terms::Vector{MPOTerm}) = new(terms)
+end
+
+length(os::OpSum) = length(data(os))
+getindex(os::OpSum, I::Int) = data(os)[I]
+
+const AutoMPO = OpSum
+
+"""
+    OpSum()
+    
+Construct an empty `OpSum`.
+"""
+OpSum() = OpSum(Vector{MPOTerm}())
+
+data(ampo::OpSum) = ampo.data
+setdata!(ampo::OpSum, ndata) = (ampo.data = ndata)
+
+push!(ampo::OpSum, term) = push!(data(ampo), term)
+
+Base.:(==)(ampo1::OpSum, ampo2::OpSum) = data(ampo1) == data(ampo2)
+
+Base.copy(ampo::OpSum) = OpSum(copy(data(ampo)))
+
+function Base.deepcopy(ampo::OpSum)
+  return OpSum(map(copy, data(ampo)))
+end
+
+Base.size(ampo::OpSum) = size(data(ampo))
+
+Base.iterate(os::OpSum, args...) = iterate(data(os), args...)
+
+"""
+    add!(ampo::OpSum,
+         op1::String, i1::Int)
+
+    add!(ampo::OpSum,
+         coef::Number,
+         op1::String, i1::Int)
+
+    add!(ampo::OpSum,
+         op1::String, i1::Int,
+         op2::String, i2::Int,
+         ops...)
+
+    add!(ampo::OpSum,
+         coef::Number,
+         op1::String, i1::Int,
+         op2::String, i2::Int,
+         ops...)
+
+    +(ampo:OpSum, term::Tuple)
+
+Add a single- or multi-site operator 
+term to the OpSum `ampo`. Each operator
+is specified by a name (String) and a
+site number (Int). The second version
+accepts a real or complex coefficient.
+
+The `+` operator version of this function
+accepts a tuple with entries either
+(String,Int,String,Int,...) or
+(Number,String,Int,String,Int,...)
+where these tuple values are the same
+as valid inputs to the `add!` function.
+For inputting a very large number of
+terms (tuples) to an OpSum, consider
+using the broadcasted operator `.+=`
+which avoids reallocating the OpSum
+after each addition.
+
+# Examples
+```julia
+ampo = OpSum()
+
+add!(ampo,"Sz",2,"Sz",3)
+
+ampo += ("Sz",3,"Sz",4)
+
+ampo += (0.5,"S+",4,"S-",5)
+
+ampo .+= (0.5,"S+",5,"S-",6)
+```
+"""
+add!(os::OpSum, t::MPOTerm) = push!(os, t)
+
+add!(os::OpSum, args...) = add!(os, MPOTerm(args...))
+
+"""
+    subtract!(ampo::OpSum,
+              op1::String, i1::Int,
+              op2::String, i2::Int,
+              ops...)
+
+    subtract!(ampo::OpSum,
+              coef::Number,
+              op1::String, i1::Int,
+              op2::String, i2::Int,
+              ops...)
+
+Subtract a multi-site operator term
+from the OpSum `ampo`. Each operator
+is specified by a name (String) and a
+site number (Int). The second version
+accepts a real or complex coefficient.
+"""
+subtract!(os::OpSum, args...) = add!(os, -MPOTerm(args...))
+
+-(t::MPOTerm) = MPOTerm(-coef(t), ops(t))
+
+function (ampo::OpSum + term::MPOTerm)
+  ampo_plus_term = copy(ampo)
+  add!(ampo_plus_term, term)
+  return ampo_plus_term
+end
+
+(ampo::OpSum + term::Tuple) = ampo + MPOTerm(term...)
+(ampo::OpSum + term::Vector{<:Pair}) = ampo + MPOTerm(term)
+
+function (ampo::OpSum - term::Tuple)
+  ampo_plus_term = copy(ampo)
+  subtract!(ampo_plus_term, term...)
+  return ampo_plus_term
+end
+
+function +(o1::OpSum, o2::OpSum; kwargs...)
+  return prune!(sortmergeterms!(OpSum([o1..., o2...])), kwargs...)
+end
+
+"""
+    prune!(os::OpSum; cutoff = 1e-15)
+
+Remove any MPOTerm with norm(coef) < cutoff
+"""
+function prune!(os::OpSum; atol=1e-15)
+  OS = OpSum()
+  for o in os
+    norm(ITensors.coef(o)) > atol && push!(OS, o)
+  end
+  os = OS
+  return os
+end
+
+#
+# ampo .+= ("Sz",1) syntax using broadcasting
+#
+
+struct OpSumStyle <: Broadcast.BroadcastStyle end
+Base.BroadcastStyle(::Type{<:OpSum}) = OpSumStyle()
+
+struct OpSumAddTermStyle <: Broadcast.BroadcastStyle end
+
+Base.broadcastable(ampo::OpSum) = ampo
+
+Base.BroadcastStyle(::OpSumStyle, ::Broadcast.Style{Tuple}) = OpSumAddTermStyle()
+
+Broadcast.instantiate(bc::Broadcast.Broadcasted{OpSumAddTermStyle}) = bc
+
+function Base.copyto!(ampo, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(+)})
+  add!(ampo, bc.args[2]...)
+  return ampo
+end
+
+#
+# ampo .-= ("Sz",1) syntax using broadcasting
+#
+
+function Base.copyto!(ampo, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(-)})
+  subtract!(ampo, bc.args[2]...)
+  return ampo
+end
+
+(α::Number * os::OpSum) = OpSum([α * o for o in os])
+(os::OpSum * α::Number) = α * os
+(os::OpSum / α::Number) = OpSum([o / α for o in os])
+
+(o1::OpSum - o2::OpSum) = o1 + (-1) * o2
+
+function Base.show(io::IO, ampo::OpSum)
+  println(io, "OpSum:")
+  for term in data(ampo)
+    println(io, "  $term")
+  end
+end
diff --git a/src/Deprecated/autompo/opsum_to_mpo.jl b/src/Deprecated/autompo/opsum_to_mpo.jl
new file mode 100644
index 0000000000..296ba7a03e
--- /dev/null
+++ b/src/Deprecated/autompo/opsum_to_mpo.jl
@@ -0,0 +1,143 @@
+function svdMPO(os::OpSum, sites; kwargs...)::MPO
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, 10000)
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(data(os))
+
+  Vs = [Matrix{ValType}(undef, 1, 1) for n in 1:N]
+  tempMPO = [MatElem{MPOTerm}[] for n in 1:N]
+
+  crosses_bond(t::MPOTerm, n::Int) = (site(ops(t)[1]) <= n <= site(ops(t)[end]))
+
+  rightmap = Dict{OpTerm,Int}()
+  next_rightmap = Dict{OpTerm,Int}()
+
+  for n in 1:N
+    leftbond_coefs = MatElem{ValType}[]
+
+    leftmap = Dict{OpTerm,Int}()
+    for term in data(os)
+      crosses_bond(term, n) || continue
+
+      left::OpTerm = filter(t -> (site(t) < n), ops(term))
+      onsite::OpTerm = filter(t -> (site(t) == n), ops(term))
+      right::OpTerm = filter(t -> (site(t) > n), ops(term))
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left)
+        bond_col = posInLink!(rightmap, mult(onsite, right))
+        bond_coef = convert(ValType, coef(term))
+        push!(leftbond_coefs, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right)
+      site_coef = 1.0 + 0.0im
+      if A_row == -1
+        site_coef = coef(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, SiteOp("F", n))
+        else
+          push!(onsite, SiteOp("Id", n))
+        end
+      end
+      el = MatElem(A_row, A_col, MPOTerm(site_coef, onsite))
+      push!(tempMPO[n], el)
+    end
+    rightmap = next_rightmap
+    next_rightmap = Dict{OpTerm,Int}()
+
+    remove_dups!(tempMPO[n])
+
+    if n > 1 && !isempty(leftbond_coefs)
+      M = toMatrix(leftbond_coefs)
+      U, S, V = svd(M)
+      P = S .^ 2
+      truncate!(P; maxdim=maxdim, cutoff=cutoff, mindim=mindim)
+      tdim = length(P)
+      nc = size(M, 2)
+      Vs[n - 1] = Matrix{ValType}(V[1:nc, 1:tdim])
+    end
+  end
+
+  llinks = Vector{Index{Int}}(undef, N + 1)
+  llinks[1] = Index(2, "Link,l=0")
+
+  H = MPO(sites)
+
+  for n in 1:N
+    VL = Matrix{ValType}(undef, 1, 1)
+    if n > 1
+      VL = Vs[n - 1]
+    end
+    VR = Vs[n]
+    tdim = size(VR, 2)
+
+    llinks[n + 1] = Index(2 + tdim, "Link,l=$n")
+
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    H[n] = ITensor()
+
+    for el in tempMPO[n]
+      A_row = el.row
+      A_col = el.col
+      t = el.val
+      (abs(coef(t)) > eps()) || continue
+
+      M = zeros(ValType, dim(ll), dim(rl))
+
+      ct = convert(ValType, coef(t))
+      if A_row == -1 && A_col == -1 #onsite term
+        M[end, 1] += ct
+      elseif A_row == -1 #term starting on site n
+        for c in 1:size(VR, 2)
+          z = ct * VR[A_col, c]
+          M[end, 1 + c] += z
+        end
+      elseif A_col == -1 #term ending on site n
+        for r in 1:size(VL, 2)
+          z = ct * conj(VL[A_row, r])
+          M[1 + r, 1] += z
+        end
+      else
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          z = ct * conj(VL[A_row, r]) * VR[A_col, c]
+          M[1 + r, 1 + c] += z
+        end
+      end
+
+      T = itensor(M, ll, rl)
+      H[n] += T * computeSiteProd(sites, ops(t))
+    end
+
+    #
+    # Special handling of starting and 
+    # ending identity operators:
+    #
+    idM = zeros(ValType, dim(ll), dim(rl))
+    idM[1, 1] = 1.0
+    idM[end, end] = 1.0
+    T = itensor(idM, ll, rl)
+    H[n] += T * computeSiteProd(sites, SiteOp[SiteOp("Id", n)])
+  end
+
+  L = ITensor(llinks[1])
+  L[end] = 1.0
+
+  R = ITensor(llinks[N + 1])
+  R[1] = 1.0
+
+  H[1] *= L
+  H[N] *= R
+
+  return H
+end #svdMPO
diff --git a/src/Deprecated/autompo/opsum_to_mpo_generic.jl b/src/Deprecated/autompo/opsum_to_mpo_generic.jl
new file mode 100644
index 0000000000..d65890d16e
--- /dev/null
+++ b/src/Deprecated/autompo/opsum_to_mpo_generic.jl
@@ -0,0 +1,172 @@
+isempty(op_qn::Pair{OpTerm,QN}) = isempty(op_qn.first)
+
+# the key type is OpTerm for the dense case
+# and is Pair{OpTerm,QN} for the QN conserving case
+function posInLink!(linkmap::Dict{K,Int}, k::K)::Int where {K}
+  isempty(k) && return -1
+  pos = get(linkmap, k, -1)
+  if pos == -1
+    pos = length(linkmap) + 1
+    linkmap[k] = pos
+  end
+  return pos
+end
+
+function determineValType(terms::Vector{MPOTerm})
+  for t in terms
+    (!isreal(coef(t))) && return ComplexF64
+  end
+  return Float64
+end
+
+function computeSiteProd(sites, ops::OpTerm)::ITensor
+  i = site(ops[1])
+  T = op(sites[i], ops[1].name; ops[1].params...)
+  for j in 2:length(ops)
+    (site(ops[j]) != i) && error("Mismatch of site number in computeSiteProd")
+    opj = op(sites[i], ops[j].name; ops[j].params...)
+    T = product(T, opj)
+  end
+  return T
+end
+
+function remove_dups!(v::Vector{T}) where {T}
+  N = length(v)
+  (N == 0) && return nothing
+  sort!(v)
+  n = 1
+  u = 2
+  while u <= N
+    while u < N && v[u] == v[n]
+      u += 1
+    end
+    if v[u] != v[n]
+      v[n + 1] = v[u]
+      n += 1
+    end
+    u += 1
+  end
+  resize!(v, n)
+  return nothing
+end #remove_dups!
+
+function sorteachterm!(os::OpSum, sites)
+  os = copy(os)
+  isless_site(o1::SiteOp, o2::SiteOp) = site(o1) < site(o2)
+  N = length(sites)
+  for t in data(os)
+    Nt = length(t.ops)
+    prevsite = N + 1 #keep track of whether we are switching
+    #to a new site to make sure F string
+    #is only placed at most once for each site
+
+    # Sort operators in t by site order,
+    # and keep the permutation used, perm, for analysis below
+    perm = Vector{Int}(undef, Nt)
+    sortperm!(perm, t.ops; alg=InsertionSort, lt=isless_site)
+
+    t.ops = t.ops[perm]
+
+    # Identify fermionic operators,
+    # zeroing perm for bosonic operators,
+    # and inserting string "F" operators
+    parity = +1
+    for n in Nt:-1:1
+      currsite = site(t.ops[n])
+      fermionic = has_fermion_string(name(t.ops[n]), sites[site(t.ops[n])])
+      if !using_auto_fermion() && (parity == -1) && (currsite < prevsite)
+        # Put local piece of Jordan-Wigner string emanating
+        # from fermionic operators to the right
+        # (Remaining F operators will be put in by svdMPO)
+        t.ops[n] = SiteOp("$(name(t.ops[n])) * F", site(t.ops[n]))
+      end
+      prevsite = currsite
+
+      if fermionic
+        parity = -parity
+      else
+        # Ignore bosonic operators in perm
+        # by zeroing corresponding entries
+        perm[n] = 0
+      end
+    end
+    if parity == -1
+      error("Parity-odd fermionic terms not yet supported by AutoMPO")
+    end
+
+    # Keep only fermionic op positions (non-zero entries)
+    filter!(!iszero, perm)
+    # and account for anti-commuting, fermionic operators 
+    # during above sort; put resulting sign into coef
+    t.coef *= parity_sign(perm)
+  end
+  return os
+end
+
+function check_numerical_opsum(os::OpSum)
+  mpoterms = data(os)
+  for mpoterm in mpoterms
+    operators = ops(mpoterm)
+    for operator in name.(operators)
+      operator isa Array{<:Number} && return true
+    end
+  end
+  return false
+end
+
+function sortmergeterms!(os::OpSum)
+  check_numerical_opsum(os) && return os
+  sort!(data(os))
+  # Merge (add) terms with same operators
+  da = data(os)
+  ndata = MPOTerm[]
+  last_term = copy(da[1])
+  for n in 2:length(da)
+    if ops(da[n]) == ops(last_term)
+      last_term.coef += coef(da[n])
+    else
+      push!(ndata, last_term)
+      last_term = copy(da[n])
+    end
+  end
+  push!(ndata, last_term)
+
+  setdata!(os, ndata)
+  return os
+end
+
+"""
+    MPO(os::OpSum,sites::Vector{<:Index};kwargs...)
+       
+Convert an OpSum object `os` to an
+MPO, with indices given by `sites`. The
+resulting MPO will have the indices
+`sites[1], sites[1]', sites[2], sites[2]'`
+etc. The conversion is done by an algorithm
+that compresses the MPO resulting from adding
+the OpSum terms together, often achieving
+the minimum possible bond dimension.
+
+# Examples
+```julia
+os = OpSum()
+os += ("Sz",1,"Sz",2)
+os += ("Sz",2,"Sz",3)
+os += ("Sz",3,"Sz",4)
+
+sites = siteinds("S=1/2",4)
+H = MPO(os,sites)
+```
+"""
+function MPO(os::OpSum, sites::Vector{<:Index}; kwargs...)::MPO
+  length(data(os)) == 0 && error("OpSum has no terms")
+
+  os = deepcopy(os)
+  sorteachterm!(os, sites)
+  sortmergeterms!(os)
+
+  if hasqns(sites[1])
+    return qn_svdMPO(os, sites; kwargs...)
+  end
+  return svdMPO(os, sites; kwargs...)
+end
diff --git a/src/Deprecated/autompo/opsum_to_mpo_qn.jl b/src/Deprecated/autompo/opsum_to_mpo_qn.jl
new file mode 100644
index 0000000000..c12eafdb14
--- /dev/null
+++ b/src/Deprecated/autompo/opsum_to_mpo_qn.jl
@@ -0,0 +1,245 @@
+function qn_svdMPO(os::OpSum, sites; kwargs...)::MPO
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, typemax(Int))
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(data(os))
+
+  Vs = [Dict{QN,Matrix{ValType}}() for n in 1:(N + 1)]
+  sparse_MPO = [QNMatElem{MPOTerm}[] for n in 1:N]
+
+  crosses_bond(t::MPOTerm, n::Int) = (site(ops(t)[1]) <= n <= site(ops(t)[end]))
+
+  # A cache of the ITensor operators on a certain site
+  # of a certain type
+  op_cache = Dict{Pair{String,Int},ITensor}()
+  function calcQN(term::OpTerm)
+    q = QN()
+    for st in term
+      op_tensor = get(op_cache, name(st) => site(st), nothing)
+      if op_tensor === nothing
+        op_tensor = op(sites[site(st)], name(st); params(st)...)
+        op_cache[name(st) => site(st)] = op_tensor
+      end
+      q -= flux(op_tensor)
+    end
+    return q
+  end
+
+  Hflux = -calcQN(ops(first(data(os))))
+
+  rightmap = Dict{Pair{OpTerm,QN},Int}()
+  next_rightmap = Dict{Pair{OpTerm,QN},Int}()
+
+  for n in 1:N
+    h_sparse = Dict{QN,Vector{MatElem{ValType}}}()
+
+    leftmap = Dict{Pair{OpTerm,QN},Int}()
+    for term in data(os)
+      crosses_bond(term, n) || continue
+
+      left::OpTerm = filter(t -> (site(t) < n), ops(term))
+      onsite::OpTerm = filter(t -> (site(t) == n), ops(term))
+      right::OpTerm = filter(t -> (site(t) > n), ops(term))
+
+      lqn = calcQN(left)
+      sqn = calcQN(onsite)
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left => lqn)
+        bond_col = posInLink!(rightmap, mult(onsite, right) => lqn)
+        bond_coef = convert(ValType, coef(term))
+        q_h_sparse = get!(h_sparse, lqn, MatElem{ValType}[])
+        push!(q_h_sparse, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      rqn = sqn + lqn
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right => rqn)
+      site_coef = 1.0 + 0.0im
+      if A_row == -1
+        site_coef = coef(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, SiteOp("F", n))
+        else
+          push!(onsite, SiteOp("Id", n))
+        end
+      end
+      el = QNMatElem(lqn, rqn, A_row, A_col, MPOTerm(site_coef, onsite))
+      push!(sparse_MPO[n], el)
+    end
+    remove_dups!(sparse_MPO[n])
+
+    if n > 1 && !isempty(h_sparse)
+      for (q, mat) in h_sparse
+        h = toMatrix(mat)
+        U, S, V = svd(h)
+        P = S .^ 2
+        truncate!(P; maxdim, cutoff, mindim)
+        tdim = length(P)
+        Vs[n][q] = Matrix{ValType}(V[:, 1:tdim])
+      end
+    end
+
+    rightmap = next_rightmap
+    next_rightmap = Dict{Pair{OpTerm,QN},Int}()
+  end
+
+  #
+  # Make MPO link indices
+  #
+  llinks = Vector{QNIndex}(undef, N + 1)
+  # Set dir=In for fermionic ordering, avoid arrow sign
+  # <fermions>:
+  linkdir = using_auto_fermion() ? In : Out
+  llinks[1] = Index([QN() => 1, Hflux => 1]; tags="Link,l=0", dir=linkdir)
+  for n in 1:N
+    qi = Vector{Pair{QN,Int}}()
+    push!(qi, QN() => 1)
+    for (q, Vq) in Vs[n + 1]
+      cols = size(Vq, 2)
+      if using_auto_fermion() # <fermions>
+        push!(qi, (-q) => cols)
+      else
+        push!(qi, q => cols)
+      end
+    end
+    push!(qi, Hflux => 1)
+    llinks[n + 1] = Index(qi...; tags="Link,l=$n", dir=linkdir)
+  end
+
+  H = MPO(N)
+
+  # Find location where block of Index i
+  # matches QN q, but *not* 1 or dim(i)
+  # which are special ending/starting states
+  function qnblock(i::Index, q::QN)
+    for b in 2:(nblocks(i) - 1)
+      flux(i, Block(b)) == q && return b
+    end
+    return error("Could not find block of QNIndex with matching QN")
+  end
+  qnblockdim(i::Index, q::QN) = blockdim(i, qnblock(i, q))
+
+  for n in 1:N
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    begin_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+    cont_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+    end_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+    onsite_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+
+    for el in sparse_MPO[n]
+      t = el.val
+      (abs(coef(t)) > eps()) || continue
+      A_row = el.row
+      A_col = el.col
+      ct = convert(ValType, coef(t))
+
+      ldim = (A_row == -1) ? 1 : qnblockdim(ll, el.rowqn)
+      rdim = (A_col == -1) ? 1 : qnblockdim(rl, el.colqn)
+      zero_mat() = zeros(ValType, ldim, rdim)
+
+      if A_row == -1 && A_col == -1
+        # Onsite term
+        M = get!(onsite_block, (el.rowqn, ops(t)), zeros(ValType, 1, 1))
+        M[1, 1] += ct
+      elseif A_row == -1
+        # Operator beginning a term on site n
+        M = get!(begin_block, (el.rowqn, ops(t)), zero_mat())
+        VR = Vs[n + 1][el.colqn]
+        for c in 1:size(VR, 2)
+          M[1, c] += ct * VR[A_col, c]
+        end
+      elseif A_col == -1
+        # Operator ending a term on site n
+        M = get!(end_block, (el.rowqn, ops(t)), zero_mat())
+        VL = Vs[n][el.rowqn]
+        for r in 1:size(VL, 2)
+          M[r, 1] += ct * conj(VL[A_row, r])
+        end
+      else
+        # Operator continuing a term on site n
+        M = get!(cont_block, (el.rowqn, ops(t)), zero_mat())
+        VL = Vs[n][el.rowqn]
+        VR = Vs[n + 1][el.colqn]
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          M[r, c] += ct * conj(VL[A_row, r]) * VR[A_col, c]
+        end
+      end
+    end
+
+    H[n] = ITensor()
+
+    # Helper functions to compute block locations
+    # of various blocks within the onsite blocks,
+    # begin blocks, etc.
+    loc_onsite(rq, cq) = Block(nblocks(ll), 1)
+    loc_begin(rq, cq) = Block(nblocks(ll), qnblock(rl, cq))
+    loc_cont(rq, cq) = Block(qnblock(ll, rq), qnblock(rl, cq))
+    loc_end(rq, cq) = Block(qnblock(ll, rq), 1)
+
+    for (loc, block) in (
+      (loc_onsite, onsite_block),
+      (loc_begin, begin_block),
+      (loc_end, end_block),
+      (loc_cont, cont_block),
+    )
+      for (q_op, M) in block
+        op_prod = q_op[2]
+        Op = computeSiteProd(sites, op_prod)
+
+        rq = q_op[1]
+        sq = flux(Op)
+        cq = rq - sq
+
+        if using_auto_fermion()
+          # <fermions>:
+          # MPO is defined with Index order
+          # of (rl,s[n]',s[n],cl) where rl = row link, cl = col link
+          # so compute sign that would result by permuting cl from
+          # second position to last position:
+          if fparity(sq) == 1 && fparity(cq) == 1
+            Op .*= -1
+          end
+        end
+
+        b = loc(rq, cq)
+        T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+        T[b] .= M
+
+        H[n] += (itensor(T) * Op)
+      end
+    end
+
+    # Put in ending identity operator
+    Id = op("Id", sites[n])
+    b = Block(1, 1)
+    T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+    T[b] = 1
+    H[n] += (itensor(T) * Id)
+
+    # Put in starting identity operator
+    b = Block(nblocks(ll), nblocks(rl))
+    T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+    T[b] = 1
+    H[n] += (itensor(T) * Id)
+  end # for n in 1:N
+
+  L = ITensor(llinks[1])
+  L[llinks[1] => end] = 1.0
+  H[1] *= L
+
+  R = ITensor(dag(llinks[N + 1]))
+  R[dag(llinks[N + 1]) => 1] = 1.0
+  H[N] *= R
+
+  return H
+end #qn_svdMPO
diff --git a/src/Deprecated/autompo/qnmatelem.jl b/src/Deprecated/autompo/qnmatelem.jl
new file mode 100644
index 0000000000..7ec55c4aae
--- /dev/null
+++ b/src/Deprecated/autompo/qnmatelem.jl
@@ -0,0 +1,30 @@
+struct QNMatElem{T}
+  rowqn::QN
+  colqn::QN
+  row::Int
+  col::Int
+  val::T
+end
+
+function Base.:(==)(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  return (
+    m1.row == m2.row &&
+    m1.col == m2.col &&
+    m1.val == m2.val &&
+    m1.rowqn == m2.rowqn &&
+    m1.colqn == m2.colqn
+  )
+end
+
+function Base.isless(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  if m1.rowqn != m2.rowqn
+    return m1.rowqn < m2.rowqn
+  elseif m1.colqn != m2.colqn
+    return m1.colqn < m2.colqn
+  elseif m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
diff --git a/src/Deprecated/backup/autompo.jl b/src/Deprecated/backup/autompo.jl
new file mode 100644
index 0000000000..73a0bcefdc
--- /dev/null
+++ b/src/Deprecated/backup/autompo.jl
@@ -0,0 +1,633 @@
+##################################
+# MatElem (simple sparse matrix) #
+##################################
+
+struct MatElem{T}
+  row::Int
+  col::Int
+  val::T
+end
+
+#function Base.show(io::IO,m::MatElem)
+#  print(io,"($(m.row),$(m.col),$(m.val))")
+#end
+
+function toMatrix(els::Vector{MatElem{T}})::Matrix{T} where {T}
+  nr = 0
+  nc = 0
+  for el in els
+    nr = max(nr, el.row)
+    nc = max(nc, el.col)
+  end
+  M = zeros(T, nr, nc)
+  for el in els
+    M[el.row, el.col] = el.val
+  end
+  return M
+end
+
+function Base.:(==)(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  return (m1.row == m2.row && m1.col == m2.col && m1.val == m2.val)
+end
+
+function Base.isless(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  if m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
+
+struct QNMatElem{T}
+  rowqn::QN
+  colqn::QN
+  row::Int
+  col::Int
+  val::T
+end
+
+function Base.:(==)(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  return (
+    m1.row == m2.row &&
+    m1.col == m2.col &&
+    m1.val == m2.val &&
+    m1.rowqn == m2.rowqn &&
+    m1.colqn == m2.colqn
+  )
+end
+
+function Base.isless(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  if m1.rowqn != m2.rowqn
+    return m1.rowqn < m2.rowqn
+  elseif m1.colqn != m2.colqn
+    return m1.colqn < m2.colqn
+  elseif m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
+
+isempty(op_qn::Pair{OpTerm,QN}) = isempty(op_qn.first)
+
+# the key type is OpTerm for the dense case
+# and is Pair{OpTerm,QN} for the QN conserving case
+function posInLink!(linkmap::Dict{K,Int}, k::K)::Int where {K}
+  isempty(k) && return -1
+  pos = get(linkmap, k, -1)
+  if pos == -1
+    pos = length(linkmap) + 1
+    linkmap[k] = pos
+  end
+  return pos
+end
+
+function determineValType(terms::Vector{MPOTerm})
+  for t in terms
+    (!isreal(coef(t))) && return ComplexF64
+  end
+  return Float64
+end
+
+function computeSiteProd(sites, ops::OpTerm)::ITensor
+  i = site(ops[1])
+  T = op(sites[i], ops[1].name; ops[1].params...)
+  for j in 2:length(ops)
+    (site(ops[j]) != i) && error("Mismatch of site number in computeSiteProd")
+    opj = op(sites[i], ops[j].name; ops[j].params...)
+    T = product(T, opj)
+  end
+  return T
+end
+
+function remove_dups!(v::Vector{T}) where {T}
+  N = length(v)
+  (N == 0) && return nothing
+  sort!(v)
+  n = 1
+  u = 2
+  while u <= N
+    while u < N && v[u] == v[n]
+      u += 1
+    end
+    if v[u] != v[n]
+      v[n + 1] = v[u]
+      n += 1
+    end
+    u += 1
+  end
+  resize!(v, n)
+  return nothing
+end #remove_dups!
+
+function svdMPO(ampo::OpSum, sites; kwargs...)::MPO
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, typemax(Int))
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(data(ampo))
+
+  Vs = [Matrix{ValType}(undef, 1, 1) for n in 1:N]
+  sparse_MPO = [MatElem{MPOTerm}[] for n in 1:N]
+
+  crosses_bond(t::MPOTerm, n::Int) = (site(ops(t)[1]) <= n <= site(ops(t)[end]))
+
+  rightmap = Dict{OpTerm,Int}()
+  next_rightmap = Dict{OpTerm,Int}()
+
+  for n in 1:N
+    h_sparse = MatElem{ValType}[]
+
+    leftmap = Dict{OpTerm,Int}()
+    for term in data(ampo)
+      crosses_bond(term, n) || continue
+
+      left::OpTerm = filter(t -> (site(t) < n), ops(term))
+      onsite::OpTerm = filter(t -> (site(t) == n), ops(term))
+      right::OpTerm = filter(t -> (site(t) > n), ops(term))
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left)
+        bond_col = posInLink!(rightmap, mult(onsite, right))
+        bond_coef = convert(ValType, coef(term))
+        push!(h_sparse, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right)
+      site_coef = 1.0 + 0.0im
+      if A_row == -1
+        site_coef = coef(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, SiteOp("F", n))
+        else
+          push!(onsite, SiteOp("Id", n))
+        end
+      end
+      el = MatElem(A_row, A_col, MPOTerm(site_coef, onsite))
+      push!(sparse_MPO[n], el)
+    end
+    remove_dups!(sparse_MPO[n])
+
+    if n > 1 && !isempty(h_sparse)
+      M = toMatrix(h_sparse)
+      U, S, V = svd(M)
+      P = S .^ 2
+      truncate!(P; maxdim, cutoff, mindim)
+      tdim = length(P)
+      Vs[n - 1] = Matrix{ValType}(V[:, 1:tdim])
+    end
+
+    rightmap = next_rightmap
+    next_rightmap = Dict{OpTerm,Int}()
+  end
+
+  llinks = Vector{Index{Int}}(undef, N + 1)
+  llinks[1] = Index(2, "Link,l=0")
+
+  H = MPO(sites)
+
+  for n in 1:N
+    VL = Matrix{ValType}(undef, 1, 1)
+    if n > 1
+      VL = Vs[n - 1]
+    end
+    VR = Vs[n]
+    tdim = size(VR, 2)
+
+    llinks[n + 1] = Index(2 + tdim, "Link,l=$n")
+
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    H[n] = ITensor()
+
+    for el in sparse_MPO[n]
+      A_row = el.row
+      A_col = el.col
+      t = el.val
+      (abs(coef(t)) > eps()) || continue
+
+      M = zeros(ValType, dim(ll), dim(rl))
+
+      ct = convert(ValType, coef(t))
+      if A_row == -1 && A_col == -1 #onsite term
+        M[end, 1] += ct
+      elseif A_row == -1 #term starting on site n
+        for c in 1:size(VR, 2)
+          z = ct * VR[A_col, c]
+          M[end, 1 + c] += z
+        end
+      elseif A_col == -1 #term ending on site n
+        for r in 1:size(VL, 2)
+          z = ct * conj(VL[A_row, r])
+          M[1 + r, 1] += z
+        end
+      else
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          z = ct * conj(VL[A_row, r]) * VR[A_col, c]
+          M[1 + r, 1 + c] += z
+        end
+      end
+
+      T = itensor(M, ll, rl)
+      H[n] += T * computeSiteProd(sites, ops(t))
+    end
+
+    #
+    # Special handling of starting and 
+    # ending identity operators:
+    #
+    idM = zeros(ValType, dim(ll), dim(rl))
+    idM[1, 1] = 1.0
+    idM[end, end] = 1.0
+    T = itensor(idM, ll, rl)
+    H[n] += T * computeSiteProd(sites, SiteOp[SiteOp("Id", n)])
+  end
+
+  L = ITensor(llinks[1])
+  L[end] = 1.0
+
+  R = ITensor(llinks[N + 1])
+  R[1] = 1.0
+
+  H[1] *= L
+  H[N] *= R
+
+  return H
+end #svdMPO
+
+function qn_svdMPO(ampo::OpSum, sites; kwargs...)::MPO
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, typemax(Int))
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(data(ampo))
+
+  Vs = [Dict{QN,Matrix{ValType}}() for n in 1:(N + 1)]
+  sparse_MPO = [QNMatElem{MPOTerm}[] for n in 1:N]
+
+  crosses_bond(t::MPOTerm, n::Int) = (site(ops(t)[1]) <= n <= site(ops(t)[end]))
+
+  # A cache of the ITensor operators on a certain site
+  # of a certain type
+  op_cache = Dict{Pair{String,Int},ITensor}()
+  function calcQN(term::OpTerm)
+    q = QN()
+    for st in term
+      op_tensor = get(op_cache, name(st) => site(st), nothing)
+      if op_tensor === nothing
+        op_tensor = op(sites[site(st)], name(st); params(st)...)
+        op_cache[name(st) => site(st)] = op_tensor
+      end
+      q -= flux(op_tensor)
+    end
+    return q
+  end
+
+  Hflux = -calcQN(ops(first(data(ampo))))
+
+  rightmap = Dict{Pair{OpTerm,QN},Int}()
+  next_rightmap = Dict{Pair{OpTerm,QN},Int}()
+
+  for n in 1:N
+    h_sparse = Dict{QN,Vector{MatElem{ValType}}}()
+
+    leftmap = Dict{Pair{OpTerm,QN},Int}()
+    for term in data(ampo)
+      crosses_bond(term, n) || continue
+
+      left::OpTerm = filter(t -> (site(t) < n), ops(term))
+      onsite::OpTerm = filter(t -> (site(t) == n), ops(term))
+      right::OpTerm = filter(t -> (site(t) > n), ops(term))
+
+      lqn = calcQN(left)
+      sqn = calcQN(onsite)
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left => lqn)
+        bond_col = posInLink!(rightmap, mult(onsite, right) => lqn)
+        bond_coef = convert(ValType, coef(term))
+        q_h_sparse = get!(h_sparse, lqn, MatElem{ValType}[])
+        push!(q_h_sparse, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      rqn = sqn + lqn
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right => rqn)
+      site_coef = 1.0 + 0.0im
+      if A_row == -1
+        site_coef = coef(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, SiteOp("F", n))
+        else
+          push!(onsite, SiteOp("Id", n))
+        end
+      end
+      el = QNMatElem(lqn, rqn, A_row, A_col, MPOTerm(site_coef, onsite))
+      push!(sparse_MPO[n], el)
+    end
+    remove_dups!(sparse_MPO[n])
+
+    if n > 1 && !isempty(h_sparse)
+      for (q, mat) in h_sparse
+        h = toMatrix(mat)
+        U, S, V = svd(h)
+        P = S .^ 2
+        truncate!(P; maxdim, cutoff, mindim)
+        tdim = length(P)
+        Vs[n][q] = Matrix{ValType}(V[:, 1:tdim])
+      end
+    end
+
+    rightmap = next_rightmap
+    next_rightmap = Dict{Pair{OpTerm,QN},Int}()
+  end
+
+  #
+  # Make MPO link indices
+  #
+  llinks = Vector{QNIndex}(undef, N + 1)
+  # Set dir=In for fermionic ordering, avoid arrow sign
+  # <fermions>:
+  linkdir = using_auto_fermion() ? In : Out
+  llinks[1] = Index([QN() => 1, Hflux => 1]; tags="Link,l=0", dir=linkdir)
+  for n in 1:N
+    qi = Vector{Pair{QN,Int}}()
+    push!(qi, QN() => 1)
+    for (q, Vq) in Vs[n + 1]
+      cols = size(Vq, 2)
+      if using_auto_fermion() # <fermions>
+        push!(qi, (-q) => cols)
+      else
+        push!(qi, q => cols)
+      end
+    end
+    push!(qi, Hflux => 1)
+    llinks[n + 1] = Index(qi...; tags="Link,l=$n", dir=linkdir)
+  end
+
+  H = MPO(N)
+
+  # Find location where block of Index i
+  # matches QN q, but *not* 1 or dim(i)
+  # which are special ending/starting states
+  function qnblock(i::Index, q::QN)
+    for b in 2:(nblocks(i) - 1)
+      flux(i, Block(b)) == q && return b
+    end
+    return error("Could not find block of QNIndex with matching QN")
+  end
+  qnblockdim(i::Index, q::QN) = blockdim(i, qnblock(i, q))
+
+  for n in 1:N
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    begin_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+    cont_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+    end_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+    onsite_block = Dict{Tuple{QN,OpTerm},Matrix{ValType}}()
+
+    for el in sparse_MPO[n]
+      t = el.val
+      (abs(coef(t)) > eps()) || continue
+      A_row = el.row
+      A_col = el.col
+      ct = convert(ValType, coef(t))
+
+      ldim = (A_row == -1) ? 1 : qnblockdim(ll, el.rowqn)
+      rdim = (A_col == -1) ? 1 : qnblockdim(rl, el.colqn)
+      zero_mat() = zeros(ValType, ldim, rdim)
+
+      if A_row == -1 && A_col == -1
+        # Onsite term
+        M = get!(onsite_block, (el.rowqn, ops(t)), zeros(ValType, 1, 1))
+        M[1, 1] += ct
+      elseif A_row == -1
+        # Operator beginning a term on site n
+        M = get!(begin_block, (el.rowqn, ops(t)), zero_mat())
+        VR = Vs[n + 1][el.colqn]
+        for c in 1:size(VR, 2)
+          M[1, c] += ct * VR[A_col, c]
+        end
+      elseif A_col == -1
+        # Operator ending a term on site n
+        M = get!(end_block, (el.rowqn, ops(t)), zero_mat())
+        VL = Vs[n][el.rowqn]
+        for r in 1:size(VL, 2)
+          M[r, 1] += ct * conj(VL[A_row, r])
+        end
+      else
+        # Operator continuing a term on site n
+        M = get!(cont_block, (el.rowqn, ops(t)), zero_mat())
+        VL = Vs[n][el.rowqn]
+        VR = Vs[n + 1][el.colqn]
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          M[r, c] += ct * conj(VL[A_row, r]) * VR[A_col, c]
+        end
+      end
+    end
+
+    H[n] = ITensor()
+
+    # Helper functions to compute block locations
+    # of various blocks within the onsite blocks,
+    # begin blocks, etc.
+    loc_onsite(rq, cq) = Block(nblocks(ll), 1)
+    loc_begin(rq, cq) = Block(nblocks(ll), qnblock(rl, cq))
+    loc_cont(rq, cq) = Block(qnblock(ll, rq), qnblock(rl, cq))
+    loc_end(rq, cq) = Block(qnblock(ll, rq), 1)
+
+    for (loc, block) in (
+      (loc_onsite, onsite_block),
+      (loc_begin, begin_block),
+      (loc_end, end_block),
+      (loc_cont, cont_block),
+    )
+      for (q_op, M) in block
+        op_prod = q_op[2]
+        Op = computeSiteProd(sites, op_prod)
+
+        rq = q_op[1]
+        sq = flux(Op)
+        cq = rq - sq
+
+        if using_auto_fermion()
+          # <fermions>:
+          # MPO is defined with Index order
+          # of (rl,s[n]',s[n],cl) where rl = row link, cl = col link
+          # so compute sign that would result by permuting cl from
+          # second position to last position:
+          if fparity(sq) == 1 && fparity(cq) == 1
+            Op .*= -1
+          end
+        end
+
+        b = loc(rq, cq)
+        T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+        T[b] .= M
+
+        H[n] += (itensor(T) * Op)
+      end
+    end
+
+    # Put in ending identity operator
+    Id = op("Id", sites[n])
+    b = Block(1, 1)
+    T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+    T[b] = 1
+    H[n] += (itensor(T) * Id)
+
+    # Put in starting identity operator
+    b = Block(nblocks(ll), nblocks(rl))
+    T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+    T[b] = 1
+    H[n] += (itensor(T) * Id)
+  end # for n in 1:N
+
+  L = ITensor(llinks[1])
+  L[llinks[1] => end] = 1.0
+  H[1] *= L
+
+  R = ITensor(dag(llinks[N + 1]))
+  R[dag(llinks[N + 1]) => 1] = 1.0
+  H[N] *= R
+
+  return H
+end #qn_svdMPO
+
+function sorteachterm!(ampo::OpSum, sites)
+  ampo = copy(ampo)
+  isless_site(o1::SiteOp, o2::SiteOp) = site(o1) < site(o2)
+  N = length(sites)
+  for t in data(ampo)
+    Nt = length(t.ops)
+    prevsite = N + 1 #keep track of whether we are switching
+    #to a new site to make sure F string
+    #is only placed at most once for each site
+
+    # Sort operators in t by site order,
+    # and keep the permutation used, perm, for analysis below
+    perm = Vector{Int}(undef, Nt)
+    sortperm!(perm, t.ops; alg=InsertionSort, lt=isless_site)
+
+    t.ops = t.ops[perm]
+
+    # Identify fermionic operators,
+    # zeroing perm for bosonic operators,
+    # and inserting string "F" operators
+    parity = +1
+    for n in Nt:-1:1
+      currsite = site(t.ops[n])
+      fermionic = has_fermion_string(name(t.ops[n]), sites[site(t.ops[n])])
+      if !using_auto_fermion() && (parity == -1) && (currsite < prevsite)
+        # Put local piece of Jordan-Wigner string emanating
+        # from fermionic operators to the right
+        # (Remaining F operators will be put in by svdMPO)
+        t.ops[n] = SiteOp("$(name(t.ops[n])) * F", site(t.ops[n]))
+      end
+      prevsite = currsite
+
+      if fermionic
+        parity = -parity
+      else
+        # Ignore bosonic operators in perm
+        # by zeroing corresponding entries
+        perm[n] = 0
+      end
+    end
+    if parity == -1
+      error("Parity-odd fermionic terms not yet supported by AutoMPO")
+    end
+
+    # Keep only fermionic op positions (non-zero entries)
+    filter!(!iszero, perm)
+    # and account for anti-commuting, fermionic operators 
+    # during above sort; put resulting sign into coef
+    t.coef *= parity_sign(perm)
+  end
+  return ampo
+end
+
+function check_numerical_opsum(ampo::OpSum)
+  mpoterms = data(ampo)
+  for mpoterm in mpoterms
+    operators = ops(mpoterm)
+    for operator in name.(operators)
+      operator isa Array{<:Number} && return true
+    end
+  end
+  return false
+end
+
+function sortmergeterms!(ampo::OpSum)
+  check_numerical_opsum(ampo) && return ampo
+  sort!(data(ampo))
+  # Merge (add) terms with same operators
+  da = data(ampo)
+  ndata = MPOTerm[]
+  last_term = copy(da[1])
+  for n in 2:length(da)
+    if ops(da[n]) == ops(last_term)
+      last_term.coef += coef(da[n])
+    else
+      push!(ndata, last_term)
+      last_term = copy(da[n])
+    end
+  end
+  push!(ndata, last_term)
+
+  setdata!(ampo, ndata)
+  return ampo
+end
+
+"""
+    MPO(ampo::OpSum,sites::Vector{<:Index};kwargs...)
+       
+Convert an OpSum object `ampo` to an
+MPO, with indices given by `sites`. The
+resulting MPO will have the indices
+`sites[1], sites[1]', sites[2], sites[2]'`
+etc. The conversion is done by an algorithm
+that compresses the MPO resulting from adding
+the OpSum terms together, often achieving
+the minimum possible bond dimension.
+
+# Examples
+```julia
+ampo = OpSum()
+ampo += ("Sz",1,"Sz",2)
+ampo += ("Sz",2,"Sz",3)
+ampo += ("Sz",3,"Sz",4)
+
+sites = siteinds("S=1/2",4)
+H = MPO(ampo,sites)
+```
+"""
+function MPO(ampo::OpSum, sites::Vector{<:Index}; kwargs...)::MPO
+  length(data(ampo)) == 0 && error("OpSum has no terms")
+
+  ampo = deepcopy(ampo)
+  sorteachterm!(ampo, sites)
+  sortmergeterms!(ampo)
+
+  if hasqns(sites[1])
+    return qn_svdMPO(ampo, sites; kwargs...)
+  end
+  return svdMPO(ampo, sites; kwargs...)
+end
diff --git a/src/physics/autompo.jl b/src/Deprecated/backup/opsum.jl
similarity index 57%
rename from src/physics/autompo.jl
rename to src/Deprecated/backup/opsum.jl
index fc9fb85ac3..79bb05d857 100644
--- a/src/physics/autompo.jl
+++ b/src/Deprecated/backup/opsum.jl
@@ -1,446 +1,3 @@
-#
-# Optimizations:
-#  - replace leftmap, rightmap with sorted vectors
-# 
-
-###########################
-# SiteOp                  # 
-###########################
-
-struct SiteOp{O,N}
-  name::O
-  site::NTuple{N,Int}
-  params::NamedTuple
-end
-
-SiteOp(op::AbstractArray, site::Tuple) = SiteOp(op, site, NamedTuple())
-SiteOp(op::AbstractArray, site::Int...) = SiteOp(op, site)
-
-# Change NamedTuple() to (;) when we drop older Julia versions
-SiteOp(name::String, site::Tuple) = SiteOp(name, site, NamedTuple())
-SiteOp(name::String, site::Int...) = SiteOp(name, site)
-function SiteOp(name::String, site_params::Union{Int,NamedTuple}...)
-  return SiteOp(name, Base.front(site_params), last(site_params))
-end
-SiteOp(name::String, params::NamedTuple, site::Tuple) = SiteOp(name, site, params)
-SiteOp(name::String, params::NamedTuple, site::Int...) = SiteOp(name, site, params)
-
-function convert(::Type{SiteOp}, op::Pair{Union{String,AbstractArray},Int})
-  return SiteOp(first(op), last(op))
-end
-
-name(s::SiteOp) = s.name
-site(s::SiteOp) = only(s.site)
-sites(s::SiteOp) = s.site
-params(s::SiteOp) = s.params
-
-site_or_sites(s::SiteOp{1}) = site(s)
-site_or_sites(s::SiteOp) = sites(s)
-
-string_site_or_sites(s::SiteOp{1}) = string(site(s))
-string_site_or_sites(s::SiteOp) = string(sites(s))[2:(end - 1)]
-
-show(io::IO, s::SiteOp) = print(io, "\"$(name(s))\"($(string_site_or_sites(s)))")
-
-(s1::SiteOp == s2::SiteOp) = (s1.site == s2.site && s1.name == s2.name)
-
-function isless(s1::SiteOp, s2::SiteOp)
-  if site(s1) != site(s2)
-    return site(s1) < site(s2)
-  end
-  return name(s1) < name(s2)
-end
-
-###########################
-# OpTerm                  # 
-###########################
-
-const OpTerm = Vector{SiteOp}
-
-function (o1::OpTerm == o2::OpTerm)
-  (length(o1) == length(o2)) || return false
-  @inbounds for n in 1:length(o1)
-    (o1[n] != o2[n]) && return false
-  end
-  return true
-end
-
-function isless(o1::OpTerm, o2::OpTerm)
-  if length(o1) != length(o2)
-    return length(o1) < length(o2)
-  end
-  for n in 1:length(o1)
-    if o1[n] != o2[n]
-      return (o1[n] < o2[n])
-    end
-  end
-  return false
-end
-
-mult(t1::OpTerm, t2::OpTerm) = isempty(t2) ? t1 : vcat(t1, t2)
-
-function isfermionic(t::OpTerm, sites)::Bool
-  p = +1
-  for op in t
-    if has_fermion_string(name(op), sites[site(op)])
-      p *= -1
-    end
-  end
-  return (p == -1)
-end
-
-###########################
-# MPOTerm                 # 
-###########################
-
-mutable struct MPOTerm
-  coef::ComplexF64
-  ops::OpTerm
-end
-coef(op::MPOTerm) = op.coef
-ops(op::MPOTerm) = op.ops
-
-copy(t::MPOTerm) = MPOTerm(coef(t), copy(ops(t)))
-
-function (t1::MPOTerm == t2::MPOTerm)
-  return coef(t1) ≈ coef(t2) && ops(t1) == ops(t2)
-end
-
-function isless(t1::MPOTerm, t2::MPOTerm)
-  if ops(t1) == ops(t2)
-    if coef(t1) ≈ coef(t2)
-      return false
-    else
-      ct1 = coef(t1)
-      ct2 = coef(t2)
-      #"lexicographic" ordering on  complex numbers
-      return real(ct1) < real(ct2) || (real(ct1) ≈ real(ct2) && imag(ct1) < imag(ct2))
-    end
-  end
-  return ops(t1) < ops(t2)
-end
-
-function MPOTerm(c::Number, op1::Union{String,AbstractArray{<:Number}}, ops_rest...) #where T<:Number
-  ops = (op1, ops_rest...)
-  starts = findall(x -> (x isa String) || (x isa AbstractArray{<:Number}), ops)
-  N = length(starts)
-  vop = SiteOp[]
-  for n in 1:N
-    start = starts[n]
-    stop = (n == N) ? lastindex(ops) : (starts[n + 1] - 1)
-    vop = [vop; [SiteOp(ops[start:stop]...)]]
-  end
-  return MPOTerm(c, OpTerm(vop))
-end
-
-function MPOTerm(op1::Union{String,AbstractArray}, ops...)
-  return MPOTerm(one(Float64), op1, ops...)
-end
-
-function MPOTerm(ops::Vector{Pair{String,Int}})
-  return MPOTerm(Iterators.flatten(ops)...)
-end
-
-function Base.show(io::IO, op::MPOTerm)
-  c = coef(op)
-  if iszero(imag(c))
-    print(io, "$(real(c)) ")
-  elseif iszero(real(c))
-    print(io, "$(imag(c))im ")
-  else
-    print(io, "($c) ")
-  end
-  for o in ops(op)
-    print(io, "\"$(name(o))\"($(string_site_or_sites(o))) ")
-    !isempty(params(o)) && print(io, params(o))
-  end
-end
-
-(α::Number * op::MPOTerm) = MPOTerm(α * coef(op), ops(op))
-(op::MPOTerm * α::Number) = α * op
-(op::MPOTerm / α::Number) = MPOTerm(coef(op) / α, ops(op))
-
-############################
-## OpSum                 #
-############################
-
-"""
-An `OpSum` represents a sum of operator
-terms.
-
-Often it is used to create matrix
-product operator (`MPO`) approximation
-of the sum of the terms in the `OpSum` oject.
-Each term is a product of local operators
-specified by names such as `"Sz"` or `"N"`,
-times an optional coefficient which
-can be real or complex.
-
-Which local operator names are available
-is determined by the function `op`
-associated with the `TagType` defined by
-special Index tags, such as `"S=1/2"`, `"S=1"`,
-`"Fermion"`, and `"Electron"`.
-"""
-mutable struct OpSum
-  data::Vector{MPOTerm}
-  OpSum(terms::Vector{MPOTerm}) = new(terms)
-end
-
-length(os::OpSum) = length(data(os))
-getindex(os::OpSum, I::Int) = data(os)[I]
-
-const AutoMPO = OpSum
-
-"""
-    OpSum()
-    
-Construct an empty `OpSum`.
-"""
-OpSum() = OpSum(Vector{MPOTerm}())
-
-data(ampo::OpSum) = ampo.data
-setdata!(ampo::OpSum, ndata) = (ampo.data = ndata)
-
-push!(ampo::OpSum, term) = push!(data(ampo), term)
-
-Base.:(==)(ampo1::OpSum, ampo2::OpSum) = data(ampo1) == data(ampo2)
-
-Base.copy(ampo::OpSum) = OpSum(copy(data(ampo)))
-
-function Base.deepcopy(ampo::OpSum)
-  return OpSum(map(copy, data(ampo)))
-end
-
-Base.size(ampo::OpSum) = size(data(ampo))
-
-Base.iterate(os::OpSum, args...) = iterate(data(os), args...)
-
-"""
-    add!(ampo::OpSum,
-         op1::String, i1::Int)
-
-    add!(ampo::OpSum,
-         coef::Number,
-         op1::String, i1::Int)
-
-    add!(ampo::OpSum,
-         op1::String, i1::Int,
-         op2::String, i2::Int,
-         ops...)
-
-    add!(ampo::OpSum,
-         coef::Number,
-         op1::String, i1::Int,
-         op2::String, i2::Int,
-         ops...)
-
-    +(ampo:OpSum, term::Tuple)
-
-Add a single- or multi-site operator 
-term to the OpSum `ampo`. Each operator
-is specified by a name (String) and a
-site number (Int). The second version
-accepts a real or complex coefficient.
-
-The `+` operator version of this function
-accepts a tuple with entries either
-(String,Int,String,Int,...) or
-(Number,String,Int,String,Int,...)
-where these tuple values are the same
-as valid inputs to the `add!` function.
-For inputting a very large number of
-terms (tuples) to an OpSum, consider
-using the broadcasted operator `.+=`
-which avoids reallocating the OpSum
-after each addition.
-
-# Examples
-```julia
-ampo = OpSum()
-
-add!(ampo,"Sz",2,"Sz",3)
-
-ampo += ("Sz",3,"Sz",4)
-
-ampo += (0.5,"S+",4,"S-",5)
-
-ampo .+= (0.5,"S+",5,"S-",6)
-```
-"""
-add!(os::OpSum, t::MPOTerm) = push!(os, t)
-
-add!(os::OpSum, args...) = add!(os, MPOTerm(args...))
-
-"""
-    subtract!(ampo::OpSum,
-              op1::String, i1::Int,
-              op2::String, i2::Int,
-              ops...)
-
-    subtract!(ampo::OpSum,
-              coef::Number,
-              op1::String, i1::Int,
-              op2::String, i2::Int,
-              ops...)
-
-Subtract a multi-site operator term
-from the OpSum `ampo`. Each operator
-is specified by a name (String) and a
-site number (Int). The second version
-accepts a real or complex coefficient.
-"""
-subtract!(os::OpSum, args...) = add!(os, -MPOTerm(args...))
-
--(t::MPOTerm) = MPOTerm(-coef(t), ops(t))
-
-function (ampo::OpSum + term::MPOTerm)
-  ampo_plus_term = copy(ampo)
-  add!(ampo_plus_term, term)
-  return ampo_plus_term
-end
-
-(ampo::OpSum + term::Tuple) = ampo + MPOTerm(term...)
-(ampo::OpSum + term::Vector{Pair{String,Int64}}) = ampo + MPOTerm(term)
-
-function (ampo::OpSum - term::Tuple)
-  ampo_plus_term = copy(ampo)
-  subtract!(ampo_plus_term, term...)
-  return ampo_plus_term
-end
-
-function +(o1::OpSum, o2::OpSum; kwargs...)
-  return prune!(sortmergeterms!(OpSum([o1..., o2...])), kwargs...)
-end
-
-"""
-    prune!(os::OpSum; cutoff = 1e-15)
-
-Remove any MPOTerm with norm(coef) < cutoff
-"""
-function prune!(os::OpSum; atol=1e-15)
-  OS = OpSum()
-  for o in os
-    norm(ITensors.coef(o)) > atol && push!(OS, o)
-  end
-  os = OS
-  return os
-end
-
-#
-# ampo .+= ("Sz",1) syntax using broadcasting
-#
-
-struct OpSumStyle <: Broadcast.BroadcastStyle end
-Base.BroadcastStyle(::Type{<:OpSum}) = OpSumStyle()
-
-struct OpSumAddTermStyle <: Broadcast.BroadcastStyle end
-
-Base.broadcastable(ampo::OpSum) = ampo
-
-Base.BroadcastStyle(::OpSumStyle, ::Broadcast.Style{Tuple}) = OpSumAddTermStyle()
-
-Broadcast.instantiate(bc::Broadcast.Broadcasted{OpSumAddTermStyle}) = bc
-
-function Base.copyto!(ampo, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(+)})
-  add!(ampo, bc.args[2]...)
-  return ampo
-end
-
-#
-# ampo .-= ("Sz",1) syntax using broadcasting
-#
-
-function Base.copyto!(ampo, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(-)})
-  subtract!(ampo, bc.args[2]...)
-  return ampo
-end
-
-(α::Number * os::OpSum) = OpSum([α * o for o in os])
-(os::OpSum * α::Number) = α * os
-(os::OpSum / α::Number) = OpSum([o / α for o in os])
-
-(o1::OpSum - o2::OpSum) = o1 + (-1) * o2
-
-function Base.show(io::IO, ampo::OpSum)
-  println(io, "OpSum:")
-  for term in data(ampo)
-    println(io, "  $term")
-  end
-end
-
-##################################
-# MatElem (simple sparse matrix) #
-##################################
-
-struct MatElem{T}
-  row::Int
-  col::Int
-  val::T
-end
-
-#function Base.show(io::IO,m::MatElem)
-#  print(io,"($(m.row),$(m.col),$(m.val))")
-#end
-
-function toMatrix(els::Vector{MatElem{T}})::Matrix{T} where {T}
-  nr = 0
-  nc = 0
-  for el in els
-    nr = max(nr, el.row)
-    nc = max(nc, el.col)
-  end
-  M = zeros(T, nr, nc)
-  for el in els
-    M[el.row, el.col] = el.val
-  end
-  return M
-end
-
-function Base.:(==)(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
-  return (m1.row == m2.row && m1.col == m2.col && m1.val == m2.val)
-end
-
-function Base.isless(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
-  if m1.row != m2.row
-    return m1.row < m2.row
-  elseif m1.col != m2.col
-    return m1.col < m2.col
-  end
-  return m1.val < m2.val
-end
-
-struct QNMatElem{T}
-  rowqn::QN
-  colqn::QN
-  row::Int
-  col::Int
-  val::T
-end
-
-function Base.:(==)(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
-  return (
-    m1.row == m2.row &&
-    m1.col == m2.col &&
-    m1.val == m2.val &&
-    m1.rowqn == m2.rowqn &&
-    m1.colqn == m2.colqn
-  )
-end
-
-function Base.isless(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
-  if m1.rowqn != m2.rowqn
-    return m1.rowqn < m2.rowqn
-  elseif m1.colqn != m2.colqn
-    return m1.colqn < m2.colqn
-  elseif m1.row != m2.row
-    return m1.row < m2.row
-  elseif m1.col != m2.col
-    return m1.col < m2.col
-  end
-  return m1.val < m2.val
-end
-
 isempty(op_qn::Pair{OpTerm,QN}) = isempty(op_qn.first)
 
 # the key type is OpTerm for the dense case
diff --git a/src/ITensorChainRules/ITensorChainRules.jl b/src/ITensorChainRules/ITensorChainRules.jl
index 515d6516bc..c500df4456 100644
--- a/src/ITensorChainRules/ITensorChainRules.jl
+++ b/src/ITensorChainRules/ITensorChainRules.jl
@@ -1,266 +1,35 @@
 module ITensorChainRules
 
+using ITensors.NDTensors
+using ITensors.Ops
+
+using ITensors: Indices
+
 using ChainRulesCore
 using ..ITensors
 
 import ChainRulesCore: rrule
 
+ITensors.dag(z::AbstractZero) = z
+
+if VERSION < v"1.7"
+  map_notangent(a) = map(_ -> NoTangent(), a)
+else
+  map_notangent(a) = map(Returns(NoTangent()), a)
+end
+
+include("projection.jl")
 include(joinpath("NDTensors", "tensor.jl"))
 include(joinpath("NDTensors", "dense.jl"))
 include("indexset.jl")
 include("itensor.jl")
 include(joinpath("physics", "sitetype.jl"))
+include(joinpath("mps", "abstractmps.jl"))
+include(joinpath("mps", "mpo.jl"))
 include(joinpath("LazyApply", "LazyApply.jl"))
-include(joinpath("Ops", "Ops.jl"))
 include("zygoterules.jl")
 
-ITensors.dag(z::AbstractZero) = z
-
-function ChainRulesCore.rrule(::typeof(getindex), x::ITensor, I...)
-  y = getindex(x, I...)
-  function getindex_pullback(ȳ)
-    # TODO: add definition `ITensor(::Tuple{}) = ITensor()`
-    # to ITensors.jl so no splatting is needed here.
-    x̄ = ITensor(inds(x)...)
-    x̄[I...] = unthunk(ȳ)
-    Ī = broadcast_notangent(I)
-    return (NoTangent(), x̄, Ī...)
-  end
-  return y, getindex_pullback
-end
-
-# Specialized version in order to avoid call to `setindex!`
-# within the pullback, should be better for taking higher order
-# derivatives in Zygote.
-function ChainRulesCore.rrule(::typeof(getindex), x::ITensor)
-  y = x[]
-  function getindex_pullback(ȳ)
-    x̄ = ITensor(unthunk(ȳ))
-    return (NoTangent(), x̄)
-  end
-  return y, getindex_pullback
-end
-
-function setinds_pullback(ȳ, x, a...)
-  x̄ = ITensors.setinds(ȳ, inds(x))
-  ā = broadcast_notangent(a)
-  return (NoTangent(), x̄, ā...)
-end
-
-function inv_op(f::Function, args...; kwargs...)
-  return error(
-    "Trying to differentiate `$f` but the inverse of the operation (`inv_op`) `$f` with arguments $args and keyword arguments $kwargs is not defined.",
-  )
-end
-
-function inv_op(::typeof(prime), x, n::Integer=1; kwargs...)
-  return prime(x, -n; kwargs...)
-end
-
-function inv_op(::typeof(replaceprime), x, n1n2::Pair; kwargs...)
-  return replaceprime(x, reverse(n1n2); kwargs...)
-end
-
-function inv_op(::typeof(swapprime), x, n1n2::Pair; kwargs...)
-  return swapprime(x, reverse(n1n2); kwargs...)
-end
-
-function inv_op(::typeof(addtags), x, args...; kwargs...)
-  return removetags(x, args...; kwargs...)
-end
-
-function inv_op(::typeof(removetags), x, args...; kwargs...)
-  return addtags(x, args...; kwargs...)
-end
-
-function inv_op(::typeof(replacetags), x, n1n2::Pair; kwargs...)
-  return replacetags(x, reverse(n1n2); kwargs...)
-end
-
-function inv_op(::typeof(swaptags), x, n1n2::Pair; kwargs...)
-  return swaptags(x, reverse(n1n2); kwargs...)
-end
-
-function inv_op(::typeof(replaceind), x, n1n2::Pair; kwargs...)
-  return replaceind(x, reverse(n1n2); kwargs...)
-end
-
-function inv_op(::typeof(replaceinds), x, n1n2::Pair; kwargs...)
-  return replaceinds(x, reverse(n1n2); kwargs...)
-end
-
-function inv_op(::typeof(swapind), x, args...; kwargs...)
-  return swapind(x, reverse(args)...; kwargs...)
-end
-
-function inv_op(::typeof(swapinds), x, args...; kwargs...)
-  return swapinds(x, reverse(args)...; kwargs...)
-end
-
-_check_inds(x::ITensor, y::ITensor) = hassameinds(x, y)
-_check_inds(x::MPS, y::MPS) = hassameinds(siteinds, x, y)
-_check_inds(x::MPO, y::MPO) = hassameinds(siteinds, x, y)
-
-for fname in (
-  :prime,
-  :setprime,
-  :noprime,
-  :replaceprime,
-  :swapprime,
-  :addtags,
-  :removetags,
-  :replacetags,
-  :settags,
-  :swaptags,
-  :replaceind,
-  :replaceinds,
-  :swapind,
-  :swapinds,
-)
-  @eval begin
-    function ChainRulesCore.rrule(
-      f::typeof($fname), x::Union{ITensor,MPS,MPO}, a...; kwargs...
-    )
-      y = f(x, a...; kwargs...)
-      function f_pullback(ȳ)
-        x̄ = inv_op(f, unthunk(ȳ), a...; kwargs...)
-        if !_check_inds(x, x̄)
-          error(
-            "Trying to differentiate function `$f` with arguments $a and keyword arguments $kwargs. The forward pass indices $(inds(x)) do not match the reverse pass indices $(inds(x̄)). Likely this is because the priming/tagging operation you tried to perform is not invertible. Please write your code in a way where the index manipulation operation you are performing is invertible. For example, `prime(A::ITensor)` is invertible, with an inverse `prime(A, -1)`. However, `noprime(A)` is in general not invertible since the information about the prime levels of the original tensor are lost. Instead, you might try `prime(A, -1)` or `replaceprime(A, 1 => 0)` which are invertible.",
-          )
-        end
-        ā = broadcast_notangent(a)
-        return (NoTangent(), x̄, ā...)
-      end
-      return y, f_pullback
-    end
-  end
-end
-
-# TODO: This is not being called by Zygote for some reason,
-# using a Zygote overload directly instead. Figure out
-# why, maybe raise an issue.
-#function ChainRulesCore.rrule(::typeof(adjoint), x::ITensor)
-#  y = prime(x)
-#  function adjoint_pullback(ȳ)
-#    return setinds_pullback(ȳ, x)
-#  end
-#  return y, adjoint_pullback
-#end
-
-# Special case for contracting a pair of ITensors
-function ChainRulesCore.rrule(::typeof(*), x1::ITensor, x2::ITensor)
-  y = x1 * x2
-  function contract_pullback(ȳ)
-    x̄1 = ȳ * dag(x2)
-    x̄2 = dag(x1) * ȳ
-    return (NoTangent(), x̄1, x̄2)
-  end
-  return y, contract_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(*), x1::Number, x2::ITensor)
-  y = x1 * x2
-  function contract_pullback(ȳ)
-    x̄1 = ȳ * dag(x2)
-    x̄2 = dag(x1) * ȳ
-    return (NoTangent(), x̄1[], x̄2)
-  end
-  return y, contract_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(*), x1::ITensor, x2::Number)
-  y = x1 * x2
-  function contract_pullback(ȳ)
-    x̄1 = ȳ * dag(x2)
-    x̄2 = dag(x1) * ȳ
-    return (NoTangent(), x̄1, x̄2[])
-  end
-  return y, contract_pullback
-end
-
-# TODO: use some contraction sequence optimization here
-function ChainRulesCore.rrule(::typeof(*), x1::ITensor, x2::ITensor, xs::ITensor...)
-  y = *(x1, x2, xs...)
-  function contract_pullback(ȳ)
-    tn = [x1, x2, xs...]
-    N = length(tn)
-    env_contracted = Vector{ITensor}(undef, N)
-    for n in 1:length(tn)
-      tn_left = tn[1:(n - 1)]
-      # TODO: define contract([]) = ITensor(1.0)
-      env_left = isempty(tn_left) ? ITensor(1.0) : contract(tn_left)
-      tn_right = tn[reverse((n + 1):end)]
-      env_right = isempty(tn_right) ? ITensor(1.0) : contract(tn_right)
-      env_contracted[n] = dag(env_left) * ȳ * dag(env_right)
-    end
-    return (NoTangent(), env_contracted...)
-  end
-  return y, contract_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(+), x1::ITensor, x2::ITensor)
-  y = x1 + x2
-  function add_pullback(ȳ)
-    return (NoTangent(), ȳ, ȳ)
-  end
-  return y, add_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(itensor), x::Array, a...)
-  y = itensor(x, a...)
-  function itensor_pullback(ȳ)
-    uȳ = permute(unthunk(ȳ), a...)
-    x̄ = reshape(array(uȳ), size(x))
-    ā = broadcast_notangent(a)
-    return (NoTangent(), x̄, ā...)
-  end
-  return y, itensor_pullback
-end
-
-function ChainRulesCore.rrule(::Type{ITensor}, x::Array{<:Number}, a...)
-  y = ITensor(x, a...)
-  function ITensor_pullback(ȳ)
-    # TODO: define `Array(::ITensor)` directly
-    uȳ = Array(unthunk(ȳ), a...)
-    x̄ = reshape(uȳ, size(x))
-    ā = broadcast_notangent(a)
-    return (NoTangent(), x̄, ā...)
-  end
-  return y, ITensor_pullback
-end
-
-function ChainRulesCore.rrule(::Type{ITensor}, x::Number)
-  y = ITensor(x)
-  function ITensor_pullback(ȳ)
-    x̄ = ȳ[]
-    return (NoTangent(), x̄)
-  end
-  return y, ITensor_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(dag), x)
-  y = dag(x)
-  function dag_pullback(ȳ)
-    x̄ = dag(unthunk(ȳ))
-    return (NoTangent(), x̄)
-  end
-  return y, dag_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(permute), x::ITensor, a...)
-  y = permute(x, a...)
-  function permute_pullback(ȳ)
-    x̄ = permute(unthunk(ȳ), inds(x))
-    ā = broadcast_notangent(a)
-    return (NoTangent(), x̄, ā...)
-  end
-  return y, permute_pullback
-end
-
-broadcast_notangent(a) = broadcast(_ -> NoTangent(), a)
-
-@non_differentiable broadcast_notangent(::Any)
+@non_differentiable map_notangent(::Any)
 @non_differentiable Index(::Any...)
 @non_differentiable delta(::Any...)
 @non_differentiable dag(::Index)
@@ -273,147 +42,8 @@ broadcast_notangent(a) = broadcast(_ -> NoTangent(), a)
 @non_differentiable addtags(::TagSet, ::Any)
 @non_differentiable ITensors.filter_inds_set_function(::Function, ::Function, ::Any...)
 @non_differentiable ITensors.filter_inds_set_function(::Function, ::Any...)
-
-#
-# MPO/MPS
-#
-
-# TODO: Define a more general version in ITensors.jl
-function _contract(::Type{ITensor}, ψ::Union{MPS,MPO}, ϕ::Union{MPS,MPO}; kwargs...)
-  T = ITensor(1)
-  for n in 1:length(ψ)
-    T = T * ψ[n] * ϕ[n]
-  end
-  return T
-end
-
-function _contract(::Type{MPO}, ψ::MPS, ϕ::MPS; kwargs...)
-  ψmat = convert(MPO, ψ)
-  ϕmat = convert(MPO, ϕ)
-  return contract(ψmat, ϕmat; kwargs...)
-end
-
-function ChainRulesCore.rrule(
-  ::typeof(apply), x1::Vector{ITensor}, x2::Union{MPS,MPO}; kwargs...
-)
-  N = length(x1) + 1
-  apply_dag = x2 isa MPO ? kwargs[:apply_dag] : nothing
-
-  # Apply circuit and store intermediates in the forward direction
-  x1x2 = Vector{typeof(x2)}(undef, N)
-  x1x2[1] = x2
-  for n in 2:N
-    x1x2[n] = apply(x1[n - 1], x1x2[n - 1]; move_sites_back=true, kwargs...)
-  end
-  y = x1x2[end]
-
-  function apply_pullback(ȳ)
-    x1x2dag = dag.(x1x2)
-    x1dag = [swapprime(dag(x), 0 => 1) for x in x1]
-
-    # Apply circuit and store intermediates in the reverse direction
-    x1dag_ȳ = Vector{typeof(x2)}(undef, N)
-    x1dag_ȳ[end] = ȳ
-    for n in (N - 1):-1:1
-      x1dag_ȳ[n] = apply(x1dag[n], x1dag_ȳ[n + 1]; move_sites_back=true, kwargs...)
-    end
-
-    x̄1 = similar(x1)
-    for n in 1:length(x1)
-      # check if it's not a noisy gate (rank-3 tensor)
-      if iseven(length(inds(x1[n])))
-        gateinds = inds(x1[n]; plev=0)
-        if x2 isa MPS
-          ξ̃ = prime(x1dag_ȳ[n + 1], gateinds)
-          ϕ̃ = x1x2dag[n]
-        else
-          # apply U on one side of the MPO
-          if apply_dag
-            ϕ̃ = swapprime(x1x2dag[n], 0 => 1)
-            ϕ̃ = apply(x1[n], ϕ̃; move_sites_back=true, apply_dag=false)
-            ϕ̃ = mapprime(ϕ̃, 1 => 2, 0 => 1)
-            ϕ̃ = replaceprime(ϕ̃, 1 => 0; inds=gateinds')
-            ξ̃ = 2 * dag(x1dag_ȳ[n + 1])'
-          else
-            ϕ̃ = mapprime(x1x2dag[n], 0 => 2)
-            ϕ̃ = replaceprime(ϕ̃, 1 => 0; inds=gateinds')
-            ξ̃ = mapprime(x1dag_ȳ[n + 1], 0 => 2)
-          end
-        end
-        x̄1[n] = _contract(ITensor, ξ̃, ϕ̃)
-      else
-        s = inds(x1[n])
-        x̄1[n] = itensor(zeros(dim.(s)), s...)
-      end
-    end
-    x̄2 = x1dag_ȳ[end]
-    return (NoTangent(), x̄1, x̄2)
-  end
-  return y, apply_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(inner), x1::MPS, x2::MPO, x3::MPS; kwargs...)
-  if !hassameinds(siteinds, x1, (x2, x3)) || !hassameinds(siteinds, x3, (x2, x1))
-    error(
-      "Taking gradients of `inner(x::MPS, A::MPO, y::MPS)` is not supported if the site indices of the input MPS and MPO don't match. Try using if you input `inner(x, A, y), try `inner(x', A, y)` instead.",
-    )
-  end
-
-  y = inner(x1, x2, x3; kwargs...)
-  function inner_pullback(ȳ)
-    x̄1 = dag(ȳ) * contract(x2, x3; kwargs...)
-    x̄2 = ȳ * dag(_contract(MPO, dag(x1), x3; kwargs...))
-    x̄3 = contract(dag(x2), x1; kwargs...) * ȳ
-
-    @assert siteinds(x1) == siteinds(x̄1)
-    @assert hassameinds(siteinds, x2, x̄2)
-    @assert siteinds(x3) == siteinds(x̄3)
-
-    return (NoTangent(), x̄1, x̄2, x̄3)
-  end
-  return y, inner_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(inner), x1::MPS, x2::MPS; kwargs...)
-  if !hassameinds(siteinds, x1, x2)
-    error(
-      "Taking gradients of `inner(::MPS, ::MPS)` is not supported if the site indices of the input MPS don't match. If you input `inner(x, Ay)` where `Ay` is the result of something like `contract(A::MPO, y::MPS)`, try `inner(x', Ay)` or `inner(x, replaceprime(Ay, 1 => 0))`instead.",
-    )
-  end
-  y = inner(x1, x2)
-  function inner_pullback(ȳ)
-    x̄1 = dag(ȳ) * x2
-    # `dag` of `x1` gets reversed by `inner`
-    x̄2 = x1 * ȳ
-    return (NoTangent(), x̄1, x̄2)
-  end
-  return y, inner_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(*), x1::MPO, x2::MPO; kwargs...)
-  y = *(x1, x2; kwargs...)
-  function contract_pullback(ȳ)
-    x̄1 = *(ȳ, dag(x2); kwargs...)
-    x̄2 = *(dag(x1), ȳ; kwargs...)
-    return (NoTangent(), x̄1, x̄2)
-  end
-  return y, contract_pullback
-end
-
-function ChainRulesCore.rrule(::typeof(tr), x::MPO; kwargs...)
-  y = tr(x; kwargs...)
-  function contract_pullback(ȳ)
-    s = noprime(firstsiteinds(x))
-    n = length(s)
-    x̄ = ȳ * MPO(s, "Id")
-
-    plev = get(kwargs, :plev, 0 => 1)
-    for j in 1:n
-      x̄[j] = mapprime(x̄[j], 0 => first(plev), 1 => last(plev))
-    end
-    return (NoTangent(), ȳ * x̄)
-  end
-  return y, contract_pullback
-end
+@non_differentiable ITensors.indpairs(::Any...)
+@non_differentiable onehot(::Any...)
+@non_differentiable Base.convert(::Type{TagSet}, str::String)
 
 end
diff --git a/src/ITensorChainRules/LazyApply/LazyApply.jl b/src/ITensorChainRules/LazyApply/LazyApply.jl
index ce4ecb21b8..6b3011af54 100644
--- a/src/ITensorChainRules/LazyApply/LazyApply.jl
+++ b/src/ITensorChainRules/LazyApply/LazyApply.jl
@@ -1,28 +1,16 @@
-using ITensors.LazyApply: Applied, AppliedTupleVector
-
-function rrule(f::Type{<:Applied}, x1, x2::Tuple)
-  y = f(x1, x2)
+function rrule(::Type{Applied}, x1, x2::Tuple, x3::NamedTuple)
+  y = Applied(x1, x2, x3)
   function Applied_pullback(ȳ)
-    x̄1 = NoTangent()
+    x̄1 = ȳ.f
     x̄2 = ȳ.args
-    return (NoTangent(), x̄1, x̄2)
-  end
-  return (y, Applied_pullback)
-end
-
-function rrule(f::Type{<:AppliedTupleVector}, x1::Vector)
-  y = f(x1)
-  function Applied_pullback(ȳ)
-    x̄1 = ȳ.args[1]
-    return (NoTangent(), x̄1)
+    x̄3 = ȳ.kwargs
+    return (NoTangent(), x̄1, x̄2, x̄3)
   end
   function Applied_pullback(ȳ::Vector)
-    x̄1 = ȳ
-    return (NoTangent(), x̄1)
-  end
-  function Applied_pullback(ȳ::ZeroTangent)
-    x̄1 = ȳ
-    return (NoTangent(), x̄1)
+    x̄1 = NoTangent()
+    x̄2 = (ȳ,)
+    x̄3 = NoTangent()
+    return (NoTangent(), x̄1, x̄2, x̄3)
   end
-  return (y, Applied_pullback)
+  return y, Applied_pullback
 end
diff --git a/src/ITensorChainRules/Ops/Ops.jl b/src/ITensorChainRules/Ops/Ops.jl
deleted file mode 100644
index d5ccb25923..0000000000
--- a/src/ITensorChainRules/Ops/Ops.jl
+++ /dev/null
@@ -1,19 +0,0 @@
-function Tangent_to_NamedTuple(t)
-  return NamedTuple((k => t[k] for k in keys(t)))
-end
-
-Tangent_to_NamedTuple(::ZeroTangent) = ZeroTangent()
-
-function rrule(::Type{Op}, x1, x2, x3)
-  y = Op(x1, x2, x3)
-  function Op_pullback(ȳ)
-    x̄1 = x1
-    x̄2 = x2
-    t = ȳ.params
-    x̄3 = Tangent_to_NamedTuple(t)
-    return (NoTangent(), x̄1, x̄2, x̄3)
-  end
-  return y, Op_pullback
-end
-
-@non_differentiable Ops.sites(::Any)
diff --git a/src/ITensorChainRules/indexset.jl b/src/ITensorChainRules/indexset.jl
index 149ea87781..253a8157c8 100644
--- a/src/ITensorChainRules/indexset.jl
+++ b/src/ITensorChainRules/indexset.jl
@@ -1,3 +1,51 @@
-using ITensors: Indices
+for fname in (
+  :prime,
+  :setprime,
+  :noprime,
+  :replaceprime,
+  :swapprime,
+  :addtags,
+  :removetags,
+  :replacetags,
+  :settags,
+  :swaptags,
+  :replaceind,
+  :replaceinds,
+  :swapind,
+  :swapinds,
+)
+  @eval begin
+    function rrule(f::typeof($fname), x::ITensor, a...; kwargs...)
+      y = f(x, a...; kwargs...)
+      function f_pullback(ȳ)
+        x̄ = replaceinds(unthunk(ȳ), inds(y) => inds(x))
+        ā = map_notangent(a)
+        return (NoTangent(), x̄, ā...)
+      end
+      return y, f_pullback
+    end
+  end
+end
+
+for fname in (
+  :prime, :setprime, :noprime, :replaceprime, :addtags, :removetags, :replacetags, :settags
+)
+  @eval begin
+    function rrule(f::typeof($fname), x::Union{MPS,MPO}, a...; kwargs...)
+      y = f(x, a...; kwargs...)
+      function f_pullback(ȳ)
+        x̄ = copy(unthunk(ȳ))
+        for j in eachindex(x̄)
+          x̄[j] = replaceinds(ȳ[j], inds(y[j]) => inds(x[j]))
+        end
+        ā = map_notangent(a)
+        return (NoTangent(), x̄, ā...)
+      end
+      return y, f_pullback
+    end
+  end
+end
+
+rrule(::typeof(adjoint), x::Union{ITensor,MPS,MPO}) = rrule(prime, x)
 
 @non_differentiable permute(::Indices, ::Indices)
diff --git a/src/ITensorChainRules/itensor.jl b/src/ITensorChainRules/itensor.jl
index e91953299d..a830cc77bd 100644
--- a/src/ITensorChainRules/itensor.jl
+++ b/src/ITensorChainRules/itensor.jl
@@ -1,4 +1,27 @@
-using ITensors: Indices
+function rrule(::typeof(getindex), x::ITensor, I...)
+  y = getindex(x, I...)
+  function getindex_pullback(ȳ)
+    # TODO: add definition `ITensor(::Tuple{}) = ITensor()`
+    # to ITensors.jl so no splatting is needed here.
+    x̄ = ITensor(inds(x)...)
+    x̄[I...] = unthunk(ȳ)
+    Ī = map_notangent(I)
+    return (NoTangent(), x̄, Ī...)
+  end
+  return y, getindex_pullback
+end
+
+# Specialized version in order to avoid call to `setindex!`
+# within the pullback, should be better for taking higher order
+# derivatives in Zygote.
+function rrule(::typeof(getindex), x::ITensor)
+  y = x[]
+  function getindex_pullback(ȳ)
+    x̄ = ITensor(unthunk(ȳ))
+    return (NoTangent(), x̄)
+  end
+  return y, getindex_pullback
+end
 
 function rrule(::Type{ITensor}, x1::AllowAlias, x2::TensorStorage, x3)
   y = ITensor(x1, x2, x3)
@@ -67,4 +90,115 @@ function rrule(::typeof(tensor), x1::ITensor)
   return y, tensor_pullback
 end
 
+# Special case for contracting a pair of ITensors
+function rrule(::typeof(contract), x1::ITensor, x2::ITensor)
+  project_x1 = ProjectTo(x1)
+  project_x2 = ProjectTo(x2)
+  function contract_pullback(ȳ)
+    x̄1 = project_x1(ȳ * dag(x2))
+    x̄2 = project_x2(dag(x1) * ȳ)
+    return (NoTangent(), x̄1, x̄2)
+  end
+  return x1 * x2, contract_pullback
+end
+
+@non_differentiable ITensors.optimal_contraction_sequence(::Any)
+
+function rrule(::typeof(*), x1::Number, x2::ITensor)
+  project_x1 = ProjectTo(x1)
+  project_x2 = ProjectTo(x2)
+  function contract_pullback(ȳ)
+    x̄1 = project_x1((ȳ * dag(x2))[])
+    x̄2 = project_x2(dag(x1) * ȳ)
+    return (NoTangent(), x̄1, x̄2)
+  end
+  return x1 * x2, contract_pullback
+end
+
+function rrule(::typeof(*), x1::ITensor, x2::Number)
+  project_x1 = ProjectTo(x1)
+  project_x2 = ProjectTo(x2)
+  function contract_pullback(ȳ)
+    x̄1 = project_x1(ȳ * dag(x2))
+    x̄2 = project_x2((dag(x1) * ȳ)[])
+    return (NoTangent(), x̄1, x̄2)
+  end
+  return x1 * x2, contract_pullback
+end
+
+function rrule(::typeof(+), x1::ITensor, x2::ITensor)
+  function add_pullback(ȳ)
+    return (NoTangent(), ȳ, ȳ)
+  end
+  return x1 + x2, add_pullback
+end
+
+function rrule(::typeof(-), x1::ITensor, x2::ITensor)
+  function subtract_pullback(ȳ)
+    return (NoTangent(), ȳ, -ȳ)
+  end
+  return x1 - x2, subtract_pullback
+end
+
+function rrule(::typeof(-), x::ITensor)
+  function minus_pullback(ȳ)
+    return (NoTangent(), -ȳ)
+  end
+  return -x, minus_pullback
+end
+
+function rrule(::typeof(itensor), x::Array, a...)
+  function itensor_pullback(ȳ)
+    uȳ = permute(unthunk(ȳ), a...)
+    x̄ = reshape(array(uȳ), size(x))
+    ā = map_notangent(a)
+    return (NoTangent(), x̄, ā...)
+  end
+  return itensor(x, a...), itensor_pullback
+end
+
+function rrule(::Type{ITensor}, x::Array{<:Number}, a...)
+  function ITensor_pullback(ȳ)
+    # TODO: define `Array(::ITensor)` directly
+    uȳ = Array(unthunk(ȳ), a...)
+    x̄ = reshape(uȳ, size(x))
+    ā = map_notangent(a)
+    return (NoTangent(), x̄, ā...)
+  end
+  return ITensor(x, a...), ITensor_pullback
+end
+
+function rrule(::Type{ITensor}, x::Number)
+  function ITensor_pullback(ȳ)
+    x̄ = ȳ[]
+    return (NoTangent(), x̄)
+  end
+  return ITensor(x), ITensor_pullback
+end
+
+function rrule(::typeof(dag), x::ITensor)
+  function dag_pullback(ȳ)
+    x̄ = dag(unthunk(ȳ))
+    return (NoTangent(), x̄)
+  end
+  return dag(x), dag_pullback
+end
+
+function rrule(::typeof(permute), x::ITensor, a...)
+  y = permute(x, a...)
+  function permute_pullback(ȳ)
+    x̄ = permute(unthunk(ȳ), inds(x))
+    ā = map_notangent(a)
+    return (NoTangent(), x̄, ā...)
+  end
+  return y, permute_pullback
+end
+
+# Needed because by default it was calling the generic
+# `rrule` for `tr` inside ChainRules.
+# TODO: Raise an issue with ChainRules.
+function rrule(config::RuleConfig{>:HasReverseMode}, ::typeof(tr), x::ITensor; kwargs...)
+  return rrule_via_ad(config, ITensors._tr, x; kwargs...)
+end
+
 @non_differentiable combiner(::Indices)
diff --git a/src/ITensorChainRules/mps/abstractmps.jl b/src/ITensorChainRules/mps/abstractmps.jl
new file mode 100644
index 0000000000..04218590b1
--- /dev/null
+++ b/src/ITensorChainRules/mps/abstractmps.jl
@@ -0,0 +1,113 @@
+function rrule(::Type{T}, x::Vector{<:ITensor}; kwargs...) where {T<:Union{MPS,MPO}}
+  y = T(x; kwargs...)
+  function T_pullback(ȳ)
+    ȳtensors = ȳ.data
+    n = length(ȳtensors)
+    envL = [ȳtensors[1] * dag(x[1])]
+    envR = [ȳtensors[n] * dag(x[n])]
+    for j in 2:(n - 1)
+      push!(envL, envL[j - 1] * ȳtensors[j] * dag(x[j]))
+      push!(envR, envR[j - 1] * ȳtensors[n + 1 - j] * dag(x[n + 1 - j]))
+    end
+
+    x̄ = ITensor[]
+    push!(x̄, ȳtensors[1] * envR[n - 1])
+    for j in 2:(n - 1)
+      push!(x̄, envL[j - 1] * ȳtensors[j] * envR[n - j])
+    end
+    push!(x̄, envL[n - 1] * ȳtensors[n])
+    return (NoTangent(), x̄)
+  end
+  return y, T_pullback
+end
+
+function rrule(::typeof(inner), x1::T, x2::T; kwargs...) where {T<:Union{MPS,MPO}}
+  if !hassameinds(siteinds, x1, x2)
+    error(
+      "Taking gradients of `inner(::MPS, ::MPS)` is not supported if the site indices of the input MPS don't match. If you input `inner(x, Ay)` where `Ay` is the result of something like `contract(A::MPO, y::MPS)`, try `inner(x', Ay)` or `inner(x, replaceprime(Ay, 1 => 0))`instead.",
+    )
+  end
+  y = inner(x1, x2)
+  function inner_pullback(ȳ)
+    x̄1 = dag(ȳ) * x2
+    # `dag` of `x1` gets reversed by `inner`
+    x̄2 = x1 * ȳ
+    return (NoTangent(), x̄1, x̄2)
+  end
+  return y, inner_pullback
+end
+
+# TODO: Define a more general version in ITensors.jl
+function _contract(::Type{ITensor}, ψ::Union{MPS,MPO}, ϕ::Union{MPS,MPO}; kwargs...)
+  T = ITensor(1)
+  for n in 1:length(ψ)
+    T = T * ψ[n] * ϕ[n]
+  end
+  return T
+end
+
+function _contract(::Type{MPO}, ψ::MPS, ϕ::MPS; kwargs...)
+  ψmat = convert(MPO, ψ)
+  ϕmat = convert(MPO, ϕ)
+  return contract(ψmat, ϕmat; kwargs...)
+end
+
+function rrule(
+  ::typeof(apply), x1::Vector{ITensor}, x2::Union{MPS,MPO}; apply_dag=false, kwargs...
+)
+  N = length(x1) + 1
+
+  # Apply circuit and store intermediates in the forward direction
+  x1x2 = Vector{typeof(x2)}(undef, N)
+  x1x2[1] = x2
+  for n in 2:N
+    x1x2[n] = apply(x1[n - 1], x1x2[n - 1]; move_sites_back=true, apply_dag, kwargs...)
+  end
+  y = x1x2[end]
+
+  function apply_pullback(ȳ)
+    x1x2dag = dag.(x1x2)
+    x1dag = [swapprime(dag(x), 0 => 1) for x in x1]
+
+    # Apply circuit and store intermediates in the reverse direction
+    x1dag_ȳ = Vector{typeof(x2)}(undef, N)
+    x1dag_ȳ[end] = ȳ
+    for n in (N - 1):-1:1
+      x1dag_ȳ[n] = apply(
+        x1dag[n], x1dag_ȳ[n + 1]; move_sites_back=true, apply_dag, kwargs...
+      )
+    end
+
+    x̄1 = similar(x1)
+    for n in 1:length(x1)
+      # check if it's not a noisy gate (rank-3 tensor)
+      if iseven(length(inds(x1[n])))
+        gateinds = inds(x1[n]; plev=0)
+        if x2 isa MPS
+          ξ̃ = prime(x1dag_ȳ[n + 1], gateinds)
+          ϕ̃ = x1x2dag[n]
+        else
+          # apply U on one side of the MPO
+          if apply_dag
+            ϕ̃ = swapprime(x1x2dag[n], 0 => 1)
+            ϕ̃ = apply(x1[n], ϕ̃; move_sites_back=true, apply_dag=false, kwargs...)
+            ϕ̃ = mapprime(ϕ̃, 1 => 2, 0 => 1)
+            ϕ̃ = replaceprime(ϕ̃, 1 => 0; inds=gateinds')
+            ξ̃ = 2 * dag(x1dag_ȳ[n + 1])'
+          else
+            ϕ̃ = mapprime(x1x2dag[n], 0 => 2)
+            ϕ̃ = replaceprime(ϕ̃, 1 => 0; inds=gateinds')
+            ξ̃ = mapprime(x1dag_ȳ[n + 1], 0 => 2)
+          end
+        end
+        x̄1[n] = _contract(ITensor, ξ̃, ϕ̃; kwargs...)
+      else
+        s = inds(x1[n])
+        x̄1[n] = itensor(zeros(dim.(s)), s...)
+      end
+    end
+    x̄2 = x1dag_ȳ[end]
+    return (NoTangent(), x̄1, x̄2)
+  end
+  return y, apply_pullback
+end
diff --git a/src/ITensorChainRules/mps/mpo.jl b/src/ITensorChainRules/mps/mpo.jl
new file mode 100644
index 0000000000..c33b620ab8
--- /dev/null
+++ b/src/ITensorChainRules/mps/mpo.jl
@@ -0,0 +1,63 @@
+function rrule(::typeof(contract), x1::MPO, x2::MPO; kwargs...)
+  y = contract(x1, x2; kwargs...)
+  function contract_pullback(ȳ)
+    x̄1 = contract(ȳ, dag(x2); kwargs...)
+    x̄2 = contract(dag(x1), ȳ; kwargs...)
+    return (NoTangent(), x̄1, x̄2)
+  end
+  return y, contract_pullback
+end
+
+function rrule(::typeof(*), x1::MPO, x2::MPO; kwargs...)
+  return rrule(contract, x1, x2; kwargs...)
+end
+
+function rrule(::typeof(+), x1::MPO, x2::MPO; kwargs...)
+  y = +(x1, x2; kwargs...)
+  function add_pullback(ȳ)
+    return (NoTangent(), ȳ, ȳ)
+  end
+  return y, add_pullback
+end
+
+function rrule(::typeof(-), x1::MPO, x2::MPO; kwargs...)
+  return rrule(+, x1, -x2; kwargs...)
+end
+
+function rrule(::typeof(tr), x::MPO; kwargs...)
+  y = tr(x; kwargs...)
+  function tr_pullback(ȳ)
+    s = noprime(firstsiteinds(x))
+    n = length(s)
+    x̄ = MPO(s, "Id")
+
+    plev = get(kwargs, :plev, 0 => 1)
+    for j in 1:n
+      x̄[j] = mapprime(x̄[j], 0 => first(plev), 1 => last(plev))
+    end
+    return (NoTangent(), ȳ * x̄)
+  end
+  return y, tr_pullback
+end
+
+function rrule(::typeof(inner), x1::MPS, x2::MPO, x3::MPS; kwargs...)
+  if !hassameinds(siteinds, x1, (x2, x3)) || !hassameinds(siteinds, x3, (x2, x1))
+    error(
+      "Taking gradients of `inner(x::MPS, A::MPO, y::MPS)` is not supported if the site indices of the input MPS and MPO don't match. Try using if you input `inner(x, A, y), try `inner(x', A, y)` instead.",
+    )
+  end
+
+  y = inner(x1, x2, x3; kwargs...)
+  function inner_pullback(ȳ)
+    x̄1 = dag(ȳ) * contract(x2, x3; kwargs...)
+    x̄2 = ȳ * dag(_contract(MPO, dag(x1), x3; kwargs...))
+    x̄3 = contract(dag(x2), x1; kwargs...) * ȳ
+
+    @assert siteinds(x1) == siteinds(x̄1)
+    @assert hassameinds(siteinds, x2, x̄2)
+    @assert siteinds(x3) == siteinds(x̄3)
+
+    return (NoTangent(), x̄1, x̄2, x̄3)
+  end
+  return y, inner_pullback
+end
diff --git a/src/ITensorChainRules/projection.jl b/src/ITensorChainRules/projection.jl
new file mode 100644
index 0000000000..443d6e5fcb
--- /dev/null
+++ b/src/ITensorChainRules/projection.jl
@@ -0,0 +1,10 @@
+function ChainRulesCore.ProjectTo(x::ITensor)
+  return ProjectTo{ITensor}(; element=ProjectTo(zero(eltype(x))))
+end
+
+function (project::ProjectTo{ITensor})(dx::ITensor)
+  S = eltype(dx)
+  T = ChainRulesCore.project_type(project.element)
+  dy = S <: T ? dx : map(project.element, dx)
+  return dy
+end
diff --git a/src/ITensorChainRules/zygoterules.jl b/src/ITensorChainRules/zygoterules.jl
index 10a3288b6f..3a3607ea8b 100644
--- a/src/ITensorChainRules/zygoterules.jl
+++ b/src/ITensorChainRules/zygoterules.jl
@@ -1,13 +1,10 @@
+using ZygoteRules: @adjoint
 
 # Needed for defining the rule for `adjoint(A::ITensor)`
 # which currently doesn't work by overloading `ChainRulesCore.rrule`
-using ZygoteRules: @adjoint
-
+# since it is defined in `Zygote`, which takes precedent.
 @adjoint function Base.adjoint(x::Union{ITensor,MPS,MPO})
-  y = prime(x)
-  function adjoint_pullback(ȳ)
-    x̄ = inv_op(prime, ȳ)
-    return (x̄,)
-  end
+  y, adjoint_rrule_pullback = rrule(adjoint, x)
+  adjoint_pullback(ȳ) = Base.tail(adjoint_rrule_pullback(ȳ))
   return y, adjoint_pullback
 end
diff --git a/src/ITensors.jl b/src/ITensors.jl
index 98c84affcd..c511de443e 100644
--- a/src/ITensors.jl
+++ b/src/ITensors.jl
@@ -49,6 +49,7 @@ module ITensors
 #####################################
 # External packages
 #
+using BitIntegers
 using ChainRulesCore
 using Compat
 using HDF5
@@ -65,6 +66,11 @@ using StaticArrays
 using TimerOutputs
 using Zeros
 
+#####################################
+# General utility functions
+#
+include("utils.jl")
+
 #####################################
 # ContractionSequenceOptimization
 #
@@ -75,30 +81,14 @@ using .ContractionSequenceOptimization
 # LazyApply
 #
 include("LazyApply/LazyApply.jl")
-using .LazyApply: Applied, Sum, ∑, Prod, ∏, Scaled, α, coefficient
+using .LazyApply
 
 #####################################
 # Ops
 #
 include("Ops/Ops.jl")
 using .Ops
-
-#####################################
-# Directory helper functions (useful for
-# running examples)
-#
-src_dir() = dirname(pathof(@__MODULE__))
-pkg_dir() = joinpath(src_dir(), "..")
-examples_dir() = joinpath(pkg_dir(), "examples")
-
-#####################################
-# Determine version and uuid of the package
-#
-function _parse_project_toml(field::String)
-  return Pkg.TOML.parsefile(joinpath(pkg_dir(), "Project.toml"))[field]
-end
-version() = VersionNumber(_parse_project_toml("version"))
-uuid() = Base.UUID(_parse_project_toml("uuid"))
+import .Ops: sites, name
 
 #####################################
 # Exports
@@ -115,6 +105,13 @@ include("imports.jl")
 #
 include("global_variables.jl")
 
+#####################################
+# Algorithm type for selecting
+# different algorithm backends
+# (for internal or advanced usage)
+#
+include("algorithm.jl")
+
 #####################################
 # Index and IndexSet
 #
@@ -144,6 +141,7 @@ include("qn/qn.jl")
 include("qn/qnindex.jl")
 include("qn/qnindexset.jl")
 include("qn/qnitensor.jl")
+include("nullspace.jl")
 
 #####################################
 # Ops to ITensor conversions
@@ -182,12 +180,16 @@ include("physics/site_types/tj.jl")
 include("physics/site_types/qudit.jl") # EXPERIMENTAL
 include("physics/site_types/boson.jl") # EXPERIMENTAL
 include("physics/fermions.jl")
-include("physics/autompo.jl")
+include("physics/autompo/matelem.jl")
+include("physics/autompo/qnmatelem.jl")
+include("physics/autompo/opsum_to_mpo_generic.jl")
+include("physics/autompo/opsum_to_mpo.jl")
+include("physics/autompo/opsum_to_mpo_qn.jl")
 
 #####################################
 # Ops to MPO conversions
 #
-include("Ops/ops_mpo.jl")
+# include("Ops/ops_mpo.jl")
 
 #####################################
 # Trotter-Suzuki decomposition
@@ -231,6 +233,11 @@ include("packagecompile/compile.jl")
 #
 include("developer_tools.jl")
 
+#####################################
+# Deprecated
+#
+include("Deprecated/Deprecated.jl")
+
 function __init__()
   return resize!(empty!(INDEX_ID_RNGs), Threads.nthreads()) # ensures that we didn't save a bad object
 end
diff --git a/src/LazyApply/LazyApply.jl b/src/LazyApply/LazyApply.jl
index 045c7039c4..b6ed927302 100644
--- a/src/LazyApply/LazyApply.jl
+++ b/src/LazyApply/LazyApply.jl
@@ -1,286 +1,376 @@
 module LazyApply
 
-using Compat
-using Zeros
-
 import Base:
-  *,
-  ^,
+  ==,
   +,
   -,
+  *,
   /,
+  ^,
   exp,
   adjoint,
-  reverse,
+  copy,
   show,
-  ==,
-  convert,
   getindex,
   length,
-  size,
+  isless,
   iterate,
-  lastindex
+  firstindex,
+  lastindex,
+  keys,
+  reverse,
+  size
 
-export coefficient, expand, Sum, Prod, coefficient
+export Applied, Scaled, Sum, Prod, Exp, coefficient, argument, expand, materialize, terms
 
-struct Applied{F,Args}
+struct Applied{F,Args<:Tuple,Kwargs<:NamedTuple}
   f::F
   args::Args
-  function Applied{F,Args}(f, args::Tuple) where {F,Args}
-    return new{F,Args}(f, args)
-  end
+  kwargs::Kwargs
 end
-Applied(f, args::Tuple) = Applied{typeof(f),typeof(args)}(f, args)
-Applied(f, args...) = Applied(f, args)
-
-# TODO: This makes shorthands like `Add(1, 2)` work, but probably
-# it is bad to use `F.instance` to get the function from the type.
-Applied{F,Args}(args::Tuple) where {F,Args} = Applied{F,Args}(F.instance, args)
-Applied{F,Args}(args...) where {F,Args} = Applied{F,Args}(args)
-Applied{F}(args::Tuple) where {F} = Applied{F,typeof(args)}(args)
-Applied{F}(args...) where {F} = Applied{F}(args)
-
-# if VERSION < v"1.6"
-const AppliedTupleAB{F} = Applied{F,Tuple{A,B}} where {A,B}
-const AppliedTupleA{F,B} = Applied{F,Tuple{A,B}} where {A}
-const AppliedTupleVector{F} = Applied{F,Tuple{Vector{T}}} where {T}
-
-# For `Scaled(3.2, "X")`
-## if VERSION > v"1.5"
-##   (Applied{F,Tuple{A,B}} where {A,B})(args::Tuple) where {F} = Applied{F}(args)
-##   (Applied{F,Tuple{A,B}} where {A,B})(args...) where {F} = Applied{F}(args)
-## else
-AppliedTupleAB{F}(args::Tuple) where {F} = Applied{F}(args)
-AppliedTupleAB{F}(args...) where {F} = Applied{F}(args)
-
-# For `Scaled{ComplexF64}(3.2, "X")`
-## if VERSION > v"1.5"
-##   function (Applied{F,Tuple{A,B}} where {A})(args::Tuple{Arg1,Arg2}) where {F,B,Arg1,Arg2}
-##     return Applied{F,Tuple{Arg1,B}}(args)
-##   end
-##   function (Applied{F,Tuple{A,B}} where {A})(args...) where {F,B}
-##     return (Applied{F,Tuple{A,B}} where {A})(args)
-##   end
-## end
-function AppliedTupleA{F,B}(args::Tuple{Arg1,Arg2}) where {F,B,Arg1,Arg2}
-  return Applied{F,Tuple{Arg1,B}}(args)
-end
-function AppliedTupleA{F,B}(args...) where {F,B}
-  return (Applied{F,Tuple{A,B}} where {A})(args)
-end
-
-# For `Sum([1, 2, 3])` and `Prod([1, 2, 3])`
-## (Applied{F,Tuple{Vector{T}}} where {T})(args::Vector) where {F} = Applied{F}((args,))
-AppliedTupleVector{F}(args::Vector) where {F} = Applied{F}((args,))
-
-_empty(::Type{T}) where {T} = error("_empty not implemented for type $T.")
-_empty(::Type{Tuple{T}}) where {T} = (_empty(T),)
-_empty(::Type{Vector{T}}) where {T} = Vector{T}()
-
-function Applied{F,Args}() where {F,Args}
-  return Applied{F,Args}(_empty(Args))
-end
-
-_initialvalue_type(::Type{typeof(+)}) = Zero
-_initialvalue_type(::Type{typeof(sum)}) = Zero
-_initialvalue_type(::Type{typeof(*)}) = One
-_initialvalue_type(::Type{typeof(prod)}) = One
-
-# For `Sum() == Sum{Zero}()` and `Prod() == Prod{One}()`
-## function (Applied{F,Tuple{Vector{T}}} where {T})() where {F}
-##   return Applied{F,Tuple{Vector{_initialvalue_type(F)}}}()
-## end
-function AppliedTupleVector{F}() where {F}
-  return Applied{F,Tuple{Vector{_initialvalue_type(F)}}}()
-end
-
-function (arg1::Applied == arg2::Applied)
-  return (arg1.f == arg2.f) && (arg1.args == arg2.args)
-end
-
-# Shorthands
-const Add{T} = Applied{typeof(+),T}
-const Mul{T} = Applied{typeof(*),T}
-# By default, `A` is the scalar, but the type constraint isn't
-# working for some reason.
-# A scaled operator scaled by a `Float64` of type `Scaled{Op,Float64}`.
-# A scaled operator with an unspecified scalar type is of type `Scaled{Op}`.
-const Scaled{B,A} = Applied{typeof(*),Tuple{A,B}}
-const Sum{T} = Applied{typeof(sum),Tuple{Vector{T}}}
-const Prod{T} = Applied{typeof(prod),Tuple{Vector{T}}}
-const ∑ = Sum
-const ∏ = Prod
-const α = Scaled
-
-const Exp{T} = Applied{typeof(exp),Tuple{T}}
-
-coefficient(arg::Applied) = 𝟏
-
-length(arg::Union{Sum,Prod}) = length(only(arg.args))
-size(arg::Union{Sum,Prod}, args...) = size(only(arg.args), args...)
-lastindex(arg::Union{Sum,Prod}) = length(arg)
-getindex(arg::Union{Sum,Prod}, n) = getindex(arg.args..., n)
-iterate(arg::Union{Sum,Prod}, args...) = iterate(arg.args..., args...)
-
-length(arg::Scaled) = length(arg.args[2])
-getindex(arg::Scaled, n) = getindex(arg.args[2], n)
-coefficient(arg::Scaled) = arg.args[1]
-iterate(arg::Scaled, args...) = iterate(arg.args[2], args...)
-
-Base.convert(::Type{Applied{F,Args}}, arg::Applied{F,Args}) where {F,Args} = arg
-
-# For some reasons this conversion isn't being done automatically.
-function convert(::Type{Applied{F,Args1}}, arg2::Applied{F,Args2}) where {F,Args1,Args2}
-  return Applied{F,Args1}(arg2.f, convert(Args1, arg2.args))
-end
-
-# Just like `Base.promote`, but this doesn't error if
-# a conversion doesn't happen.
-function try_promote(x::T, y::S) where {T,S}
-  R = promote_type(T, S)
-  return (convert(R, x), convert(R, y))
-end
-
-# Conversion
-Sum(arg::Add) = Sum(collect(arg.args))
-Sum(arg::Sum) = arg
-
-# Scalar multiplication (general rules)
-_mul(arg1::Number, arg2) = Mul(arg1, arg2)
-(arg1::Number * arg2::Applied) = _mul(arg1, arg2)
-(arg1::Number * arg2::Prod) = _mul(arg1, arg2)
-
-# Scalar division
-(arg1::Applied / arg2::Number) = inv(arg2) * arg1
-
-# Put the scalar value first by convention
-_mul(arg1, arg2::Number) = Mul(arg2, arg1)
-(arg1::Applied * arg2::Number) = _mul(arg1, arg2)
-(arg1::Prod * arg2::Number) = _mul(arg1, arg2)
-
-# Scalar multiplication (specialized rules)
-(arg1::Number * arg2::Scaled) = Mul(arg1 * arg2.args[1], arg2.args[2])
-(arg1::Scaled * arg2::Scaled) =
-  Mul(arg1.args[1] * arg2.args[1], arg1.args[2] * arg2.args[2])
-(arg1::Scaled * arg2) = Mul(arg1.args[1], arg1.args[2] * arg2)
-(arg1 * arg2::Scaled) = Mul(arg2.args[1], arg1 * arg2.args[2])
-# Scalars are treated special for the sake of multiplication
-Mul(arg1::Number, arg2::Number) = arg1 * arg2
-Mul(arg1::Number, arg2::Scaled) = arg1 * arg2
-Mul(arg1::Scaled, arg2::Number) = arg1 * arg2
-(arg1::Number * arg2::Sum) = Sum(map(a -> Mul(arg1, a), arg2))
-(arg1::Number * arg2::Add) = Add(map(a -> Mul(arg1, a), arg2.args))
-
-# Types should implement `__sum`.
-_sum(arg1, arg2) = __sum(try_promote(arg1, arg2)...)
-
-# Addition (general rules)
-__sum(arg1, arg2) = Sum(vcat(arg1, arg2))
-(arg1::Applied + arg2::Applied) = _sum(arg1, arg2)
-(arg1::Applied + arg2) = _sum(arg1, arg2)
-(arg1 + arg2::Applied) = _sum(arg1, arg2)
-
-# Subtraction (general rules)
-_subtract(arg1, arg2) = _sum(arg1, Mul(-𝟏, arg2))
-(arg1::Applied - arg2::Applied) = _subtract(arg1, arg2)
-(arg1::Applied - arg2) = _subtract(arg1, arg2)
-(arg1 - arg2::Applied) = _subtract(arg1, arg2)
-
-# Addition (specialized rules)
-__sum(arg1::Sum, arg2::Sum) = Sum(vcat(arg1.args..., arg2.args...))
-(arg1::Sum + arg2::Sum) = _sum(arg1, arg2)
-(arg1::Add + arg2::Add) = Add(arg1.args..., arg2.args...)
-
-__sum(arg1::Sum, arg2) = Sum(vcat(arg1.args..., arg2))
-__sum(arg1, arg2::Sum) = Sum(vcat(arg1, arg2.args...))
-(arg1::Sum + arg2) = _sum(arg1, arg2)
-(arg1::Sum + arg2::Applied) = _sum(arg1, arg2)
-
-(arg1 + arg2::Sum) = _sum(arg1, arg2)
-(arg1::Add + arg2) = Add(arg1.args..., arg2)
-(arg1 + arg2::Add) = Add(arg1, arg2.args...)
-
-# Multiplication (general rules)
-(arg1::Applied * arg2::Applied) = Prod([arg1, arg2])
-
-# Multiplication (specialized rules)
-(arg1::Prod * arg2::Prod) = Prod(vcat(arg1.args..., arg2.args...))
-(arg1::Sum * arg2::Sum) = Prod([arg1, arg2])
-
-_prod(arg1::Prod{One}, arg2) = Prod(vcat(arg2))
-_prod(arg1::Prod{One}, arg2::Vector) = Prod(arg2)
-_prod(arg1::Prod, arg2) = Prod(vcat(arg1.args..., arg2))
-(arg1::Prod * arg2) = _prod(arg1, arg2)
-(arg1::Prod * arg2::Applied) = _prod(arg1, arg2)
-
-_prod(arg1, arg2::Prod) = Prod(vcat(arg1, arg2...))
-(arg1 * arg2::Prod) = _prod(arg1, arg2)
-(arg1::Applied * arg2::Prod) = _prod(arg1, arg2)
-
-# Generically make products
-(arg1::Applied * arg2) = Prod(vcat(arg1, arg2))
-(arg1 * arg2::Applied) = Prod(vcat(arg1, arg2))
-
-function (arg1::Applied^arg2::Integer)
-  res = ∏()
-  for n in 1:arg2
-    res *= arg1
-  end
-  return res
+Applied(f, args::Tuple) = Applied(f, args, (;))
+
+function materialize(a::Applied)
+  return a.f(a.args...; a.kwargs...)
+end
+
+function (a1::Applied == a2::Applied)
+  return a1.f == a2.f && a1.args == a2.args && a1.kwargs == a2.kwargs
 end
 
-# Other lazy operations
-exp(arg::Applied) = Applied(exp, arg)
+#
+# Applied algebra
+#
 
-# adjoint
-adjoint(arg::Applied) = Applied(adjoint, arg)
-adjoint(arg::Applied{typeof(adjoint)}) = only(arg.args)
-adjoint(arg::Prod) = ∏(reverse(adjoint.(arg)))
+# Used for dispatch
+const Scaled{C<:Number,A} = Applied{typeof(*),Tuple{C,A},NamedTuple{(),Tuple{}}}
+const Sum{A} = Applied{typeof(sum),Tuple{Vector{A}},NamedTuple{(),Tuple{}}}
+const Prod{A} = Applied{typeof(prod),Tuple{Vector{A}},NamedTuple{(),Tuple{}}}
 
-# reverse
-reverse(arg::Prod) = Prod(reverse(arg.args...))
+# Some convenient empty constructors
+Sum{A}() where {A} = Applied(sum, (A[],))
+Prod{A}() where {A} = Applied(prod, (A[],))
 
-# Materialize
-materialize(a::Number) = a
-materialize(a::AbstractString) = a
-materialize(a::Vector) = materialize.(a)
-materialize(a::Applied) = a.f(materialize.(a.args)...)
+coefficient(co::Scaled{C}) where {C} = co.args[1]
+argument(co::Scaled{C}) where {C} = co.args[2]
+
+#
+# Generic algebra
+#
+
+# 1.3 * Op("X", 1) + 1.3 * Op("X", 2)
+# 1.3 * Op("X", 1) * Op("X", 2) + 1.3 * Op("X", 3) * Op("X", 4)
+function (a1::Scaled{C,A} + a2::Scaled{C,A}) where {C,A}
+  return Sum{Scaled{C,A}}() + a1 + a2
+end
+
+function (a1::Prod{A} + a2::Prod{A}) where {A}
+  return Sum{Prod{A}}() + a1 + a2
+end
+
+(c::Number * a::Scaled{C}) where {C} = (c * coefficient(a)) * argument(a)
+(a::Scaled{C} * c::Number) where {C} = (coefficient(a) * c) * argument(a)
+
+-(a::Scaled{C}) where {C} = (-one(C) * a)
+-(a::Sum) = (-1 * a)
+-(a::Prod) = (-1 * a)
+
+(os::Sum{A} + o::A) where {A} = Applied(sum, (vcat(os.args[1], [o]),))
+(o::A + os::Sum{A}) where {A} = Applied(sum, (vcat([o], os.args[1]),))
+
+(a1::Sum{A} - a2::A) where {C,A} = a1 + (-a2)
+(a1::A - a2::Sum{A}) where {C,A} = a1 + (-a2)
+
+(a1::Sum{A} - a2::Prod{A}) where {A} = a1 + (-a2)
+(a1::Sum{A} - a2::Scaled{C,Prod{A}}) where {C,A} = a1 + (-a2)
+(a1::Sum{A} - a2::Sum{Scaled{C,Prod{A}}}) where {C,A} = a1 + (-a2)
+
+(a1::Prod{A} * a2::A) where {A} = Applied(prod, (vcat(only(a1.args), [a2]),))
+(a1::A * a2::Prod{A}) where {A} = Applied(prod, (vcat([a1], only(a2.args)),))
+
+# Fixes ambiguity error with:
+# *(a1::Applied, a2::Sum)
+# *(os::Prod{A}, o::A)
+(a1::Prod{Sum{A}} * a2::Sum{A}) where {A} = Applied(prod, (vcat(only(a1.args), [a2]),))
+
+# 1.3 * Op("X", 1) + 1 * Op("X", 2)
+# 1.3 * Op("X", 1) * Op("X", 2) + 1 * Op("X", 3)
+# 1.3 * Op("X", 1) * Op("X", 2) + 1 * Op("X", 3) * Op("X", 4)
+function (co1::Scaled{C1,A} + co2::Scaled{C2,A}) where {C1,C2,A}
+  c1, c2 = promote(coefficient(co1), coefficient(co2))
+  return c1 * argument(co1) + c2 * argument(co2)
+end
+
+# (1.3 * Op("X", 1)) * (1.3 * Op("X", 2))
+function (co1::Scaled{C1} * co2::Scaled{C2}) where {C1,C2}
+  c = coefficient(co1) * coefficient(co2)
+  o = argument(co1) * argument(co2)
+  return c * o
+end
+
+function (a1::Prod{A} * a2::Scaled{C,A}) where {C,A}
+  return coefficient(a2) * (a1 * argument(a2))
+end
+
+function (a1::Prod{A} + a2::Scaled{C,A}) where {C,A}
+  return one(C) * a1 + Prod{A}() * a2
+end
+
+# (Op("X", 1) + Op("X", 2)) + (Op("X", 3) + Op("X", 4))
+# (Op("X", 1) * Op("X", 2) + Op("X", 3) * Op("X", 4)) + (Op("X", 5) * Op("X", 6) + Op("X", 7) * Op("X", 8))
+(a1::Sum{A} + a2::Sum{A}) where {A} = Applied(sum, (vcat(a1.args[1], a2.args[1]),))
+(a1::Sum{A} - a2::Sum{A}) where {A} = a1 + (-a2)
+
+(a1::Prod{A} * a2::Prod{A}) where {A} = Applied(prod, (vcat(only(a1.args), only(a2.args)),))
+
+(os::Sum{Scaled{C,A}} + o::A) where {C,A} = os + one(C) * o
+(o::A + os::Sum{Scaled{C,A}}) where {C,A} = one(C) * o + os
+
+# Op("X", 1) + Op("X", 2) + 1.3 * Op("X", 3)
+(os::Sum{A} + co::Scaled{C,A}) where {C,A} = one(C) * os + co
+
+# 1.3 * Op("X", 1) + (Op("X", 2) + Op("X", 3))
+(co::Scaled{C,A} + os::Sum{A}) where {C,A} = co + one(C) * os
+
+# 1.3 * (Op("X", 1) + Op("X", 2))
+(c::Number * os::Sum) = Applied(sum, (c * os.args[1],))
+
+(a1::Applied * a2::Sum) = Applied(sum, (map(a -> a1 * a, only(a2.args)),))
+(a1::Sum * a2::Applied) = Applied(sum, (map(a -> a * a2, only(a1.args)),))
+(a1::Sum * a2::Sum) = Applied(prod, ([a1, a2],))
 
 function _expand(a1::Sum, a2::Sum)
-  return ∑(vec([a1[i] * a2[j] for i in 1:length(a1), j in 1:length(a2)]))
+  return Applied(sum, (vec([a1[i] * a2[j] for i in 1:length(a1), j in 1:length(a2)]),))
 end
 
-# Expression manipulation
-function expand(a::Prod{<:Sum})
+function expand(a::Prod)
   if length(a) == 1
     return a[1]
   elseif length(a) ≥ 2
     a12 = _expand(a[1], a[2])
-    return expand(∏(vcat(a12, a[3:end])))
+    return expand(Applied(prod, (vcat([a12], a[3:end]),)))
   end
 end
 
-_print(io::IO, args...) = print(io, args...)
-function _print(io::IO, a::AbstractVector, args...)
-  print(io, "[")
-  for n in 1:length(a)
-    _print(io, a[n], args...)
-    if n < length(a)
-      print(io, ",\n")
+# (Op("X", 1) + Op("X", 2)) * 1.3
+(os::Sum * c::Number) = c * os
+
+# (Op("X", 1) + Op("X", 2)) / 1.3
+(os::Sum / c::Number) = inv(c) * os
+
+# Promotions
+function (co1::Scaled{C,Prod{A}} + co2::Scaled{C,A}) where {C,A}
+  return co1 + coefficient(co2) * Applied(prod, ([argument(co2)],))
+end
+
+function (a1::Scaled - a2::Scaled) where {C,A}
+  return a1 + (-a2)
+end
+
+function (a1::Prod{A} + a2::A) where {A}
+  return a1 + Applied(prod, ([a2],))
+end
+
+function (a1::Sum{A} + a2::Prod{A}) where {A}
+  return Prod{A}() * a1 + a2
+end
+
+function (a1::Sum{A} + a2::Sum{Scaled{C,Prod{A}}}) where {C,A}
+  return (one(C) * Prod{A}() * a1) + a2
+end
+
+function (a1::Prod{A} - a2::A) where {A}
+  return a1 + (-a2)
+end
+
+function (co1::Sum{Scaled{C,Prod{A}}} + co2::Scaled{C,A}) where {C,A}
+  return co1 + coefficient(co2) * Applied(prod, ([argument(co2)],))
+end
+
+function (a1::Sum{Scaled{C1,Prod{A}}} - a2::Scaled{C2,A}) where {C1,C2,A}
+  return a1 + (-a2)
+end
+
+function (a1::Sum{Scaled{C,Prod{A}}} - a2::Prod{A}) where {C,A}
+  return a1 + (-a2)
+end
+
+function (a1::Sum{Scaled{C1,Prod{A}}} - a2::Scaled{C2,Prod{A}}) where {C1,C2,A}
+  return a1 + (-a2)
+end
+
+function (a1::Sum{A} + a2::Scaled{C,Prod{A}}) where {C,A}
+  return Sum{Scaled{C,Prod{A}}}() + a1 + a2
+end
+
+function (a1::Sum{Scaled{C1,Prod{A}}} + a2::Scaled{C2,A}) where {C1,C2,A}
+  C = promote_type(C1, C2)
+  return one(C) * a1 + one(C) * a2
+end
+
+# (::Sum{Scaled{Bool,Prod{Op}}} + ::Scaled{Float64,Prod{Op}})
+function (a1::Sum{Scaled{C1,A}} + a2::Scaled{C2,A}) where {C1,C2,A}
+  C = promote_type(C1, C2)
+  return one(C) * a1 + one(C) * a2
+end
+
+# TODO: Is this needed? It seems like:
+#
+# (a1::Sum{A} + a2::A)
+#
+# is not being called.
+function (a1::Sum{Scaled{C,A}} + a2::Scaled{C,A}) where {C,A}
+  return Applied(sum, (vcat(only(a1.args), [a2]),))
+end
+
+function (a1::Sum{Scaled{C,Prod{A}}} + a2::Sum{A}) where {C,A}
+  a2 = one(C) * a2
+  a2 = Prod{A}() * a2
+  return a1 + one(C) * Prod{A}() * a2
+end
+
+function (a1::Sum{Prod{A}} + a2::A) where {A}
+  return a1 + (Prod{A}() * a2)
+end
+
+function (a1::Sum{Prod{A}} + a2::Scaled{C,A}) where {C,A}
+  return a1 + (Prod{A}() * a2)
+end
+
+function (a1::Sum{Scaled{C,Prod{A}}} + a2::A) where {C,A}
+  return a1 + one(C) * a2
+end
+(a1::Sum{Scaled{C,Prod{A}}} - a2::A) where {C,A} = a1 + (-a2)
+
+function (a1::Sum{Scaled{C,Prod{A}}} + a2::Sum{Scaled{C,A}}) where {C,A}
+  return a1 + (Prod{A}() * a2)
+end
+
+function (o::A + os::Sum{Scaled{C,Prod{A}}}) where {C,A}
+  return one(C) * o + os
+end
+
+function (a::Sum^n::Int)
+  r = a
+  for _ in 2:n
+    r *= a
+  end
+  return r
+end
+
+function (a::Prod^n::Int)
+  r = a
+  for _ in 2:n
+    r *= a
+  end
+  return r
+end
+
+exp(a::Applied) = Applied(exp, (a,))
+
+const Exp{A} = Applied{typeof(exp),Tuple{A},NamedTuple{(),Tuple{}}}
+const Adjoint{A} = Applied{typeof(adjoint),Tuple{A},NamedTuple{(),Tuple{}}}
+
+argument(a::Exp) = a.args[1]
+
+(c::Number * e::Exp) = Applied(*, (c, e))
+(e::Exp * c::Number) = c * e
+(e1::Exp * e2::Exp) = Applied(prod, ([e1, e2],))
+(e1::Applied * e2::Exp) = Applied(prod, ([e1, e2],))
+(e1::Exp * e2::Applied) = Applied(prod, ([e1, e2],))
+
+function reverse(a::Prod)
+  return Applied(prod, (reverse(only(a.args)),))
+end
+
+adjoint(a::Prod) = Applied(prod, (map(adjoint, reverse(only(a.args))),))
+
+#
+# Convenient indexing
+#
+
+getindex(a::Union{Sum,Prod}, I...) = only(a.args)[I...]
+iterate(a::Union{Sum,Prod}, args...) = iterate(only(a.args), args...)
+size(a::Union{Sum,Prod}) = size(only(a.args))
+length(a::Union{Sum,Prod}) = length(only(a.args))
+firstindex(a::Union{Sum,Prod}) = 1
+lastindex(a::Union{Sum,Prod}) = length(a)
+keys(a::Union{Sum,Prod}) = 1:length(a)
+
+length(a::Scaled{C,<:Sum}) where {C} = length(argument(a))
+length(a::Scaled{C,<:Prod}) where {C} = length(argument(a))
+getindex(a::Scaled{C,<:Sum}, I...) where {C} = getindex(argument(a), I...)
+getindex(a::Scaled{C,<:Prod}, I...) where {C} = getindex(argument(a), I...)
+lastindex(a::Scaled{C,<:Sum}) where {C} = lastindex(argument(a))
+lastindex(a::Scaled{C,<:Prod}) where {C} = lastindex(argument(a))
+
+#
+# Functions convenient for AutoMPO code
+#
+
+terms(a::Union{Sum,Prod}) = only(a.args)
+terms(a::Scaled{C,<:Union{Sum,Prod}}) where {C} = terms(argument(a))
+copy(a::Applied) = Applied(deepcopy(a.f), deepcopy(a.args), deepcopy(a.kwargs))
+Sum(a::Vector) = Applied(sum, (a,))
+Prod(a::Vector) = Applied(prod, (a,))
+function isless(a1::Applied{F}, a2::Applied{F}) where {F}
+  return (isless(a1.args, a2.args) && isless(a1.kwargs, a2.kwargs))
+end
+
+#
+# Printing
+#
+
+function show(io::IO, ::MIME"text/plain", a::Sum)
+  print(io, "sum(\n")
+  for n in eachindex(a)
+    print(io, "  ", a[n])
+    if n ≠ lastindex(a)
+      print(io, "\n")
     end
   end
-  return print(io, "]")
+  print(io, "\n)")
+  return nothing
 end
+show(io::IO, a::Sum) = show(io, MIME("text/plain"), a)
+
+function show(io::IO, ::MIME"text/plain", a::Prod)
+  print(io, "prod(\n")
+  for n in eachindex(a)
+    print(io, "  ", a[n])
+    if n ≠ lastindex(a)
+      print(io, "\n")
+    end
+  end
+  print(io, "\n)")
+  return nothing
+end
+show(io::IO, a::Prod) = show(io, MIME("text/plain"), a)
+
+function show(io::IO, m::MIME"text/plain", a::Exp)
+  print(io, a.f, "(")
+  for n in 1:length(a.args)
+    print(io, a.args[n])
+    if n < length(a.args)
+      print(io, ", ")
+    end
+  end
+  print(io, ")")
+  return nothing
+end
+show(io::IO, a::Exp) = show(io, MIME("text/plain"), a)
 
 function show(io::IO, m::MIME"text/plain", a::Applied)
   print(io, a.f, "(\n")
   for n in 1:length(a.args)
-    _print(io, a.args[n])
+    print(io, a.args[n])
     if n < length(a.args)
       print(io, ", ")
     end
   end
-  return print(io, "\n)")
+  print(io, "\n)")
+  return nothing
 end
 show(io::IO, a::Applied) = show(io, MIME("text/plain"), a)
+
 end
diff --git a/src/Ops/Ops.jl b/src/Ops/Ops.jl
index 26aa1289e6..1a68d4998f 100644
--- a/src/Ops/Ops.jl
+++ b/src/Ops/Ops.jl
@@ -1,17 +1,10 @@
 module Ops
 
-using Compat
-using LinearAlgebra
-using Zeros
 using ..LazyApply
 
-using ..LazyApply: ∑, ∏, α, coefficient, Applied
+import Base: ==, +, -, *, /, convert, exp, show, adjoint, isless, hash
 
-import ..LazyApply: coefficient
-
-import Base: show, *, /, +, -, Tuple, one, exp, adjoint, promote_rule, convert
-
-export Op, sites, params
+export Op, OpSum, which_op, site, sites, params, Applied, expand
 
 #####################################################################################
 # General functionality
@@ -24,361 +17,305 @@ export Op, sites, params
 # (1, "X", 1, 2, "Y", 2, "Z", 4)
 # 
 # julia> split(x -> x isa AbstractString, t)
-# ((1,), ("X", 1, 2), ("Y", 2), ("Z", 4))
+# [(1,), ("X", 1, 2), ("Y", 2), ("Z", 4)]
 # 
 function split(f, t::Tuple)
   n = findall(f, t)
-  ti = t[1:(first(n) - 1)]
-  ts = ntuple(i -> t[n[i]:(n[i + 1] - 1)], length(n) - 1)
-  tf = t[last(n):end]
-  return ti, ts..., tf
-end
-
-#
-# General functionality
-#####################################################################################
-
-#####################################################################################
-# LazyApply extensions
-# TODO: Move to `LazyApply`
-#
-
-# Helper function for determing the cofficient type of an `Op` related type.
-coefficient_type(o::Type) = One
-coefficient_type(o::Type{<:α{<:Any,T}}) where {T} = T
-coefficient_type(o::Type{<:∑{T}}) where {T} = coefficient_type(T)
-
-coefficient_type(o::Applied) = coefficient_type(typeof(o))
-
-#
-# LazyApply extensions
-#####################################################################################
-
-const WhichOp = Union{String,AbstractMatrix,UniformScaling}
+  nsplit = length(n) + 1
+  s = Vector{Any}(undef, nsplit)
+  s[1] = t[1:(first(n) - 1)]
+  for i in 2:(nsplit - 1)
+    s[i] = t[n[i - 1]:(n[i] - 1)]
+  end
+  s[end] = t[last(n):end]
+  return s
+end
+
+## XXX: Very long compile times:
+## https://github.com/JuliaLang/julia/issues/45545
+##
+## julia> using ITensors
+## 
+## julia> @time ITensors.Ops.split(x -> x isa String, ("X", 1))
+##   7.588123 seconds (2.34 M allocations: 100.919 MiB, 1.71% gc time, 100.00% compilation time)
+## ((), ("X", 1))
+## 
+## julia> @time ITensors.Ops.split(x -> x isa String, ("X", 1))
+##   0.042590 seconds (88.59 k allocations: 4.823 MiB, 19.13% gc time, 99.84% compilation time)
+## ((), ("X", 1))
+##
+## function split(f, t::Tuple)
+##   n = findall(f, t)
+##   ti = t[1:(first(n) - 1)]
+##   ts = ntuple(i -> t[n[i]:(n[i + 1] - 1)], length(n) - 1)
+##   tf = t[last(n):end]
+##   return ti, ts..., tf
+## end
 
 struct Op
-  which_op::WhichOp
-  sites::Tuple{Vararg{Int}}
+  which_op
+  sites::Tuple
   params::NamedTuple
+  function Op(which_op, site...; kwargs...)
+    return new(which_op, site, NamedTuple(kwargs))
+  end
 end
+
 which_op(o::Op) = o.which_op
+name(o::Op) = which_op(o)
 sites(o::Op) = o.sites
+site(o::Op) = only(sites(o))
 params(o::Op) = o.params
-op(o::Op) = o
-coefficient_type(o::Op) = One
-coefficient(o::Op) = one(coefficient_type(o))
-
-params(o::Vector{Op}) = params(only(o))
 
-# exp
-exp(o::Op) = Applied(exp, o)
-
-# adjoint
-adjoint(o::Op) = Applied(adjoint, o)
+function (o1::Op == o2::Op)
+  return o1.which_op == o2.which_op && o1.sites == o2.sites && o1.params == o2.params
+end
 
-Tuple(o::Op) = (which_op(o), sites(o), params(o))
+function hash(o::Op, h::UInt)
+  return hash(which_op(o), hash(sites(o), hash(params(o), hash(:Op, h))))
+end
 
-const OpExpr = Union{Op,∑{Op},α{Op},∑{<:α{Op}},∏{Op},∑{∏{Op}},α{∏{Op}},∑{<:α{∏{Op}}}}
+# Version of `isless` defined for matrices
+_isless(a, b) = isless(a, b)
+_isless(a::AbstractMatrix, b::AbstractMatrix) = isless(hash(a), hash(b))
+_isless(a::AbstractString, b::AbstractMatrix) = true
+_isless(a::AbstractMatrix, b::AbstractString) = !_isless(b, a)
 
-# Type promotion and conversion
-convert(::Type{α{Op,T}}, o::Op) where {T} = one(T) * o
-convert(::Type{∏{Op}}, o::Op) = ∏([o])
-convert(::Type{∑{Op}}, o::Op) = ∑([o])
-convert(::Type{α{∏{Op},T}}, o::Op) where {T} = one(T) * convert(∏{Op}, o)
-function convert(::Type{∑{α{∏{Op},T}}}, o::Op) where {T}
-  return ∑([convert(α{∏{Op},T}, o)])
+function isless(o1::Op, o2::Op)
+  if sites(o1) ≠ sites(o2)
+    return sites(o1) < sites(o2)
+  end
+  if which_op(o1) ≠ which_op(o2)
+    return _isless(which_op(o1), which_op(o2))
+  end
+  return params(o1) < params(o2)
 end
 
-# if VERSION < v"1.6"
-const ∑α∏Op = ∑{α{∏{Op},T}} where {T}
-const ∑α∏{S} = ∑{α{∏{S},T}} where {T}
-
-convert(O::Type{<:Op}, o::Tuple) = O(o)
-convert(O::Type{<:α{Op}}, o::Tuple) = convert(O, Op(o))
-convert(O::Type{<:∏{Op}}, o::Tuple) = convert(O, Op(o))
-convert(O::Type{<:∑{Op}}, o::Tuple) = convert(O, Op(o))
-convert(O::Type{<:α{∏{Op}}}, o::Tuple) = convert(O, Op(o))
-convert(O::Type{<:∑{α{∏{Op},T}} where {T}}, o::Tuple) = convert(O, Op(o))
-## convert(O::Type{∑{α{∏{Op},T}} where {T}}, o::Tuple) = convert(O, Op(o))
-convert(O::Type{∑α∏Op}, o::Tuple) = convert(O, Op(o))
-
-convert(::Type{∑{<:α{∏{Op}}}}, o) = convert(∑{α{∏{Op},T}} where {T}, o)
-∑{<:α{∏{Op}}}(o) = (∑{α{∏{Op},T}} where {T})(o)
-∑{<:α{∏{Op}}}() = (∑{α{∏{Op},T}} where {T})()
-
-# if VERSION > v"1.5"
-## function (∑{α{∏{Op},T}} where {T})(o::OpExpr)
-##   return convert(∑{α{∏{Op},T}} where {T}, o)
-## end
-## function (∑{α{∏{Op},T}} where {T})(o::Tuple)
-##   return convert(∑{α{∏{Op},T}} where {T}, o)
-## end
-## function (∑{α{∏{Op},T}} where {T})(o::Vector{<:Union{OpExpr,Tuple}})
-##   return reduce(+, o; init=(∑{α{∏{Op},T}} where {T})())
-## end
-## function (∑{α{∏{Op},T}} where {T})(o::WhichOp, args...)
-##   return convert(∑{α{∏{Op},T}} where {T}, Op(o, args...))
+function isless(o1::Prod{Op}, o2::Prod{Op})
+  if length(o1) ≠ length(o2)
+    return length(o1) < length(o2)
+  end
+  for n in 1:length(o1)
+    if o1[n] ≠ o2[n]
+      return (o1[n] < o2[n])
+    end
+  end
+  return false
+end
+
+function isless(o1::Scaled{C1,Prod{Op}}, o2::Scaled{C2,Prod{Op}}) where {C1,C2}
+  if argument(o1) == argument(o2)
+    if coefficient(o1) ≈ coefficient(o2)
+      return false
+    else
+      c1 = coefficient(o1)
+      c2 = coefficient(o2)
+      #"lexicographic" ordering on  complex numbers
+      return real(c1) < real(c2) || (real(c1) ≈ real(c2) && imag(c1) < imag(c2))
+    end
+  end
+  return argument(o1) < argument(o2)
+end
+
+## function Op(t::Tuple)
+##   which_op = first(t)
+##   site_params = Base.tail(t)
+##   if last(site_params) isa NamedTuple
+##     site = Base.front(site_params)
+##     params = last(site_params)
+##   else
+##     site = site_params
+##     params = (;)
+##   end
+##   return Op(which_op, site; params...)
 ## end
-## function (∑{α{∏{Op},T}} where {T})(c::Number, o::WhichOp, args...)
-##   return convert(∑{α{∏{Op},T}} where {T}, Op(c, o, args...))
+
+## function Op(t::Tuple{WhichOp,NamedTuple,Vararg}) where {WhichOp}
+##   params = t[2]
+##   which_op = t[1]
+##   sites = t[3:end]
+##   return Op(which_op, sites...; params...)
 ## end
-# if VERSION < v"1.6"
-function ∑α∏Op(o::OpExpr)
-  return convert(∑{α{∏{Op},T}} where {T}, o)
-end
-function ∑α∏Op(o::Tuple)
-  return convert(∑{α{∏{Op},T}} where {T}, o)
-end
-function ∑α∏Op(o::Vector{<:Union{OpExpr,Tuple}})
-  return reduce(+, o; init=(∑{α{∏{Op},T}} where {T})())
-end
-function ∑α∏Op(o::WhichOp, args...)
-  return convert(∑{α{∏{Op},T}} where {T}, Op(o, args...))
-end
-function ∑α∏Op(c::Number, o::WhichOp, args...)
-  return convert(∑{α{∏{Op},T}} where {T}, Op(c, o, args...))
+
+function sites(a::Union{Sum,Prod})
+  s = []
+  for n in 1:length(a)
+    s = s ∪ sites(a[n])
+  end
+  return sort(map(identity, s))
 end
+sites(a::Scaled{C,<:Sum}) where {C} = sites(argument(a))
+sites(a::Scaled{C,<:Prod}) where {C} = sites(argument(a))
 
-# Default constructors
-# if VERSION > v"1.5"
-## (∑{α{∏{S},T}} where {T})() where {S} = ∑{α{∏{S},Zero}}()
-## (∑{α{∏{Op},T}} where {T})(o) = convert(∑{α{∏{Op},T}} where {T}, o)
-# if VERSION < v"1.6"
-∑α∏{S}() where {S} = ∑{α{∏{S},Zero}}()
-∑α∏Op(o) = convert(∑{α{∏{Op},T}} where {T}, o)
+params(a::Scaled{C,<:Prod}) where {C} = params(only(argument(a)))
 
-function convert(O::Type{α{∏{Op},T}}, o::α{Op}) where {T}
-  return convert(T, coefficient(o)) * ∏([op(o)])
-end
-function convert(O::Type{∑{T}}, o::α{Op}) where {T<:Union{α{Op},α{∏{Op}}}}
-  return ∑([convert(T, o)])
-end
+which_op(a::Scaled{C,Op}) where {C} = which_op(argument(a))
+sites(a::Scaled{C,Op}) where {C} = sites(argument(a))
+params(a::Scaled{C,Op}) where {C} = params(argument(a))
 
-convert(O::Type{∑{∏{Op}}}, o::∏{Op}) = ∑([o])
-convert(O::Type{α{∏{Op},T}}, o::∏{Op}) where {T} = one(T) * o
-function convert(O::Type{∑{α{∏{Op},T}}}, o::∏{Op}) where {T}
-  return ∑([convert(α{∏{Op},T}, o)])
-end
-convert(O::Type{∑{α{∏{Op},T}}}, o::∑{∏{Op}}) where {T} = one(T) * o
+#
+# Op algebra
+#
 
-function convert(O::Type{∑{α{∏{Op},T}}}, o::α{∏{Op}}) where {T}
-  return ∑([convert(α{∏{Op},T}, o)])
+function convert(::Type{Scaled{C1,Prod{Op}}}, o::Scaled{C2,Prod{Op}}) where {C1,C2}
+  c = convert(C1, coefficient(o))
+  return c * argument(o)
 end
 
-# Versions where the type paramater is left out.
-function convert(O::Type{∑{α{∏{Op},T}} where {T}}, o)
-  return convert(∑{α{∏{Op},coefficient_type(o)}}, o)
-end
+const OpSum{C} = Sum{Scaled{C,Prod{Op}}}
+
+# This helps with in-place operations
+OpSum() = OpSum{ComplexF64}()
+
+(o1::Op + o2::Op) = Applied(sum, ([o1, o2],))
+(o1::Op * o2::Op) = Applied(prod, ([o1, o2],))
+-(o::Op) = -one(Int) * o
+(o1::Op - o2::Op) = o1 + (-o2)
+
+(c::Number * o::Op) = Applied(*, (c, o))
+(o::Op * c::Number) = Applied(*, (c, o))
+(o::Op / c::Number) = Applied(*, (inv(c), o))
+
+(c::Number * o::Prod{Op}) = Applied(*, (c, o))
+(o::Prod{Op} * c::Number) = Applied(*, (c, o))
+(o::Prod{Op} / c::Number) = Applied(*, (inv(c), o))
+
+# 1.3 * Op("X", 1) + Op("X", 2)
+# 1.3 * Op("X", 1) * Op("X", 2) + Op("X", 3)
+(co1::Scaled{C} + o2::Op) where {C} = co1 + one(C) * o2
+
+# Op("X", 1) + 1.3 * Op("X", 2)
+(o1::Op + co2::Scaled{C}) where {C} = one(C) * o1 + co2
+
+(o1::Op * o2::Sum) = Applied(sum, (map(a -> o1 * a, only(o2.args)),))
+(o1::Sum * o2::Op) = Applied(sum, (map(a -> a * o2, only(o1.args)),))
+
+# 1.3 * Op("X", 1) + Op("X", 2) * Op("X", 3)
+# 1.3 * Op("X", 1) * Op("X", 2) + Op("X", 3) * Op("X", 4)
+(co1::Scaled{C} + o2::Prod{Op}) where {C} = co1 + one(C) * o2
+
+# 1.3 * Op("X", 1) * Op("X", 2)
+(co1::Scaled{C} * o2::Op) where {C} = co1 * (one(C) * o2)
+
+exp(o::Op) = Applied(exp, (o,))
+
+adjoint(o::Op) = Applied(adjoint, (o,))
+adjoint(o::LazyApply.Adjoint{Op}) = only(o.args)
+
+(o1::Exp{Op} * o2::Op) = Applied(prod, ([o1, o2],))
 
 #
-# Promotion rules.
-#
-# Rules for promoting Op-like objects when they are being added together.
+# Tuple interface
 #
-# Should cover promotions between these types:
+
+const OpSumLike{C} = Union{
+  Sum{Op},
+  Sum{Scaled{C,Op}},
+  Sum{Prod{Op}},
+  Sum{Scaled{C,Prod{Op}}},
+  Prod{Op},
+  Scaled{C,Prod{Op}},
+}
+
+const WhichOp = Union{AbstractString,AbstractMatrix{<:Number}}
+
+# Make a `Scaled{C,Prod{Op}}` from a `Tuple` input,
+# for example:
 #
-# Op
-# α{Op,T}
-# ∏{Op}
-# ∑{Op}
-# ∑{α{Op,T}}
-# α{∏{Op},T}}
-# ∑{∏{Op}}
-# ∑{α{∏{Op},T}}
+# (1.2, "X", 1, "Y", 2) -> 1.2 * Op("X", 1) * Op("Y", 2)
 #
-
-# Conversion of `Op`
-promote_rule(::Type{Op}, O::Type{<:α{Op}}) = O
-promote_rule(::Type{Op}, O::Type{<:∏{Op}}) = O
-promote_rule(::Type{Op}, O::Type{<:∑{Op}}) = O
-promote_rule(::Type{Op}, O::Type{<:∑{α{Op}}}) = O
-promote_rule(::Type{Op}, O::Type{<:α{∏{Op}}}) = O
-promote_rule(::Type{Op}, O::Type{<:∑{∏{Op}}}) = O
-promote_rule(::Type{Op}, O::Type{<:∑{α{∏{Op}}}}) = O
-
-# Conversion of `α{Op}`
-function promote_rule(::Type{α{Op,T}}, ::Type{α{Op,S}}) where {T,S}
-  return α{Op,promote_type(T, S)}
-end
-promote_rule(::Type{α{Op,T}}, ::Type{∏{Op}}) where {T} = α{∏{Op},T}
-promote_rule(::Type{α{Op,T}}, ::Type{∑{Op}}) where {T} = ∑{α{Op,T}}
-function promote_rule(::Type{α{Op,T}}, ::Type{∑{α{Op,S}}}) where {T,S}
-  return ∑{α{Op,promote_type(T, S)}}
-end
-function promote_rule(::Type{α{Op,T}}, ::Type{α{∏{Op},S}}) where {T,S}
-  return α{∏{Op},promote_type(T, S)}
-end
-function promote_rule(::Type{α{Op,T}}, ::Type{∑{∏{Op}}}) where {T}
-  return ∑{α{∏{Op},T}}
-end
-function promote_rule(::Type{α{Op,T}}, ::Type{∑{α{∏{Op},S}}}) where {T,S}
-  return ∑{α{∏{Op},promote_type(T, S)}}
+function op_term(a::Tuple{Number,Vararg})
+  c = first(a)
+  return c * op_term(Base.tail(a))
 end
 
-# Conversion of `∏{Op}`
-promote_rule(::Type{∏{Op}}, ::Type{∑{Op}}) = ∑{∏{Op}}
-function promote_rule(::Type{∏{Op}}, ::Type{∑{α{Op,S}}}) where {S}
-  return ∑{α{∏{Op},S}}
-end
-promote_rule(::Type{∏{Op}}, ::Type{α{∏{Op},S}}) where {S} = α{∏{Op},S}
-promote_rule(::Type{∏{Op}}, ::Type{∑{∏{Op}}}) = ∑{∏{Op}}
-function promote_rule(::Type{∏{Op}}, ::Type{∑{α{∏{Op},S}}}) where {S}
-  return ∑{α{∏{Op},S}}
+function op_site(which_op, params::NamedTuple, sites...)
+  return Op(which_op, sites...; params...)
 end
 
-# Conversion of `∑{Op}`
-promote_rule(::Type{∑{Op}}, ::Type{∑{α{Op,S}}}) where {S} = ∑{α{Op,S}}
-function promote_rule(::Type{∑{Op}}, ::Type{α{∏{Op},S}}) where {S}
-  return ∑{α{∏{Op},S}}
-end
-promote_rule(::Type{∑{Op}}, ::Type{∑{∏{Op}}}) = ∑{∏{Op}}
-function promote_rule(::Type{∑{Op}}, ::Type{∑{α{∏{Op},S}}}) where {S}
-  return ∑{α{∏{Op},S}}
+function op_site(which_op, sites_params...)
+  if last(sites_params) isa NamedTuple
+    sites = Base.front(sites_params)
+    params = last(sites_params)
+    return Op(which_op, sites...; params...)
+  end
+  return Op(which_op, sites_params...)
 end
 
-# Conversion of `∑{α{Op,T}}`
-function promote_rule(::Type{∑{α{Op,T}}}, ::Type{∑{α{Op,S}}}) where {T,S}
-  return ∑{α{Op,promote_type(T, S)}}
-end
-function promote_rule(::Type{∑{α{Op,T}}}, ::Type{α{∏{Op},S}}) where {T,S}
-  return ∑{α{∏{Op},promote_type(T, S)}}
-end
-function promote_rule(::Type{∑{α{Op,T}}}, ::Type{∑{∏{Op}}}) where {T}
-  return ∑{α{∏{Op},T}}
-end
-function promote_rule(::Type{∑{α{Op,T}}}, ::Type{∑{α{∏{Op},S}}}) where {T,S}
-  return ∑{α{∏{Op},promote_type(T, S)}}
+function op_term(a::Tuple{Vararg})
+  a_split = split(x -> x isa WhichOp, a)
+  @assert isempty(first(a_split))
+  popfirst!(a_split)
+  o = op_site(first(a_split)...)
+  popfirst!(a_split)
+  for aₙ in a_split
+    o *= op_site(aₙ...)
+  end
+  return o
 end
 
-# Conversion of `α{∏{Op},T}`
-function promote_rule(::Type{α{∏{Op},T}}, ::Type{α{∏{Op},S}}) where {T,S}
-  return α{∏{Op},promote_type(T, S)}
-end
-function promote_rule(::Type{α{∏{Op},T}}, ::Type{∑{∏{Op}}}) where {T}
-  return ∑{α{∏{Op},T}}
-end
-function promote_rule(::Type{α{∏{Op},T}}, ::Type{∑{α{∏{Op},S}}}) where {T,S}
-  return ∑{α{∏{Op},promote_type(T, S)}}
+function (o1::OpSumLike + o2::Tuple)
+  return o1 + op_term(o2)
 end
 
-# Conversion of `∑{∏{Op}}`
-function promote_rule(::Type{∑{∏{Op}}}, ::Type{∑{α{∏{Op},S}}}) where {S}
-  return ∑{α{∏{Op},S}}
+function (o1::Tuple + o2::OpSumLike)
+  return op_term(o1) + o2
 end
 
-# Conversion of `∑{α{∏{Op},T}}`
-function promote_rule(::Type{∑{α{∏{Op},T}}}, ::Type{∑{α{∏{Op},S}}}) where {T,S}
-  return ∑{α{∏{Op},promote_type(T, S)}}
+function (o1::OpSumLike - o2::Tuple)
+  return o1 - op_term(o2)
 end
 
-op(o::α) = o.args[2]
-sites(o::α) = sites(op(o))
-
-which_op(o::α{Op}) = which_op(op(o))
-params(o::α{Op}) = params(op(o))
-one(o::α{Op}) = one(coefficient(o))
-
-sites(o::Union{∑,∏}) = unique(Iterators.flatten(Iterators.map(sites, o)))
-
-# General definition for single-tensor operations like `exp` or `adjoint`.
-# F: exp, adjoint, etc.
-op(o::Applied{F}) where {F} = o.args[1]
-sites(o::Applied{F}) where {F} = sites(op(o))
-which_op(o::Applied{F}) where {F} = which_op(op(o))
-params(o::Applied{F}) where {F} = params(op(o))
-
-const OpTuple = Union{Tuple{<:WhichOp,Vararg},Tuple{<:Number,<:WhichOp,Vararg}}
-
-# Conversion from Tuple
-Op(o::Tuple) = Op(o...)
-Op(which_op::WhichOp, sites::Tuple; kwargs...) = Op(which_op, sites, values(kwargs))
-Op(which_op::WhichOp, sites::Int...; kwargs...) = Op(which_op, sites; kwargs...)
-Op(which_op::WhichOp, sites::Vector{Int}; kwargs...) = Op(which_op, Tuple(sites); kwargs...)
-function Op(which_op::WhichOp, sites_params::Union{Int,<:NamedTuple}...)
-  return Op(which_op, Base.front(sites_params), last(sites_params))
-end
-Op(α::Number, which_op::WhichOp, args...; kwargs...) = α * Op(which_op, args...; kwargs...)
-function Op(which_op::WhichOp, sites_params::Union{Int,WhichOp,NamedTuple}...)
-  ts = split(x -> x isa WhichOp, (which_op, sites_params...))
-  args = filter(x -> !(x isa Tuple{}), ts)
-  return ∏(collect(Op.(args)))
+function (o1::Tuple - o2::OpSumLike)
+  return op_term(o1) - o2
 end
 
-# Conversion to `∑{Op}` (replacement for `OpSum`)
-∑{Op}(o::Vector{<:OpExpr}) = ∑(o)
-∑{Op}(o::OpExpr) = ∑{Op}() + o
-∑{Op}(o::OpTuple) = ∑{Op}(Op(o))
-∑{Op}(which_op::WhichOp, args...; kwargs...) = ∑{Op}(Op(which_op, args...; kwargs...))
-function ∑{Op}(α::Number, which_op::WhichOp, args...; kwargs...)
-  return ∑{Op}(Op(α, which_op, args...; kwargs...))
+function (o1::OpSumLike * o2::Tuple)
+  return o1 * op_term(o2)
 end
 
-# Lazy operations with Op
-(arg1::Number * arg2::Op) = α(arg1, arg2)
-(arg1::Op / arg2::Number) = inv(arg2) * arg1
-(arg1::Op * arg2::Op) = ∏([arg1, arg2])
-(arg1::Op + arg2::Op) = ∑([arg1, arg2])
--(o::Op) = -𝟏 * o
-
-# Rules for adding, subtracting, and multiplying with Tuples
-(arg1::OpExpr + arg2::Tuple) = arg1 + Op(arg2)
-(arg1::Tuple + arg2::OpExpr) = Op(arg1) + arg2
-(arg1::OpExpr - arg2::Tuple) = arg1 - Op(arg2)
-(arg1::Tuple - arg2::OpExpr) = Op(arg1) - arg2
-(arg1::OpExpr * arg2::Tuple) = arg1 * Op(arg2)
-(arg1::Tuple * arg2::OpExpr) = Op(arg1) * arg2
-
-function print_sites(io::IO, sites)
-  nsites = length(sites)
-  for n in 1:nsites
-    print(io, sites[n])
-    if n < nsites
-      print(io, ", ")
-    end
-  end
+function (o1::Tuple * o2::OpSumLike)
+  return op_term(o1) * o2
 end
 
 function show(io::IO, ::MIME"text/plain", o::Op)
-  print(io, which_op(o), "(")
-  print_sites(io, sites(o))
+  print(io, which_op(o))
+  print(io, sites(o))
   if !isempty(params(o))
-    print(io, ", ", params(o))
+    print(io, params(o))
   end
-  return print(io, ")")
+  return nothing
 end
+show(io::IO, o::Op) = show(io, MIME("text/plain"), o)
 
-function show(io::IO, ::MIME"text/plain", o::∏{Op})
+function show(io::IO, ::MIME"text/plain", o::Prod{Op})
   for n in 1:length(o)
     print(io, o[n])
     if n < length(o)
-      print(io, " * ")
+      print(io, " ")
     end
   end
+  return nothing
 end
+show(io::IO, o::Prod{Op}) where {C} = show(io, MIME("text/plain"), o)
 
-function print_coefficient(io::IO, o)
-  return print(io, o)
-end
-
-function print_coefficient(io::IO, o::Complex)
-  return print(io, "(", o, ")")
-end
-
-function show(io::IO, ::MIME"text/plain", o::Union{α{Op},α{∏{Op}}})
-  print_coefficient(io, coefficient(o))
+function show(io::IO, m::MIME"text/plain", o::Scaled{C,O}) where {C,O<:Union{Op,Prod{Op}}}
+  c = coefficient(o)
+  if isreal(c)
+    c = real(c)
+  end
+  print(io, c)
   print(io, " ")
-  return print(io, op(o))
+  show(io, m, argument(o))
+  return nothing
 end
+show(io::IO, o::Scaled{C,Prod{Op}}) where {C} = show(io, MIME("text/plain"), o)
 
-function show(io::IO, ::MIME"text/plain", o::Union{∑{Op},∑{<:α{Op}},∑{∏{Op}},∑{<:α{∏{Op}}}})
-  for n in 1:length(o)
-    print(io, o[n])
-    if n < length(o)
-      print(io, " +\n")
-    end
-  end
+function show(io::IO, ::MIME"text/plain", o::LazyApply.Adjoint{Op})
+  print(io, o')
+  print(io, "'")
+  return nothing
 end
-
-show(io::IO, o::OpExpr) = show(io, MIME("text/plain"), o)
+show(io::IO, o::LazyApply.Adjoint{Op}) = show(io, MIME("text/plain"), o)
 
 end
diff --git a/src/Ops/ops_itensor.jl b/src/Ops/ops_itensor.jl
index f3822c5ee7..b88e1260f5 100644
--- a/src/Ops/ops_itensor.jl
+++ b/src/Ops/ops_itensor.jl
@@ -1,112 +1,71 @@
-function itensor(I::UniformScaling, is...)
-  return ITensor(I, is...)
-end
-
-function ITensor(I::UniformScaling, is...)
-  return ITensor(I(isqrt(dim(is))), is...)
-end
-
-# Using ITensors.jl definitions
-function _ITensor(
-  which_op::AbstractString, sites::Tuple, params::NamedTuple, s::Vector{<:Index}
-)
-  return op(which_op, s, sites; params...)
-end
-
-function _ITensor(
-  which_op::Union{AbstractMatrix,UniformScaling},
-  sites::Tuple,
-  params::NamedTuple,
-  s::Vector{<:Index},
-)
-  sₙ = s[collect(sites)]
-  return itensor(which_op, sₙ', dag(sₙ))
-end
-
-function hassamesites(o)
-  if length(o) ∈ (0, 1)
-    return true
-  end
-  return reduce(issetequal, Ops.sites.(o))
+function op(I::UniformScaling, s::Index...)
+  return I.λ * op("Id", s...)
 end
 
 function ITensor(o::Op, s::Vector{<:Index})
-  return _ITensor(Tuple(o)..., s)
+  return op(o.which_op, map(n -> s[n], o.sites)...; o.params...)
 end
 
-# Extend the operator `o` to the sites `n`
-# by filling the rest of the sites with `op`.
-function insert_ids(o, n)
-  insert_n = @ignore_derivatives setdiff(n, Ops.sites(o))
-  for i in insert_n
-    o *= Op(I, i)
+function ITensor(o::Scaled, s::Vector{<:Index})
+  c = coefficient(o)
+  if isreal(c)
+    c = real(c)
   end
-  return o
-end
-
-# TODO: Merge these two.
-function insert_ids(o::∏)
-  n = Ops.sites(o)
-  return ∏([insert_ids(oₙ, n) for oₙ in o])
-end
-function insert_ids(o::∑)
-  n = Ops.sites(o)
-  return ∑([insert_ids(oₙ, n) for oₙ in o])
-end
-
-# TODO: Does this work for fermions?
-function ITensor(o::∏, s::Vector{<:Index})
-  o_id = insert_ids(o)
-  ∏layers = ∏([∏{ITensor}(oₙ, s) for oₙ in o_id])
-  res = ITensor(Op(I, Ops.sites(o)), s)
-  for layer in reverse(∏layers)
-    res = layer(res)
+  return c * ITensor(argument(o), s)
+end
+
+function ITensor(o::Prod, s::Vector{<:Index})
+  T = ITensor(true)
+  for a in o.args[1]
+    Tₙ = ITensor(a, s)
+    # TODO: Implement this logic inside `apply`
+    if hascommoninds(T, Tₙ)
+      T = T(Tₙ)
+    else
+      T *= Tₙ
+    end
   end
-  return res
+  return T
 end
 
-function ITensor(o::∑{ITensor})
-  res = ITensor()
-  for oₙ in o
-    res += oₙ
+function ITensor(o::Sum, s::Vector{<:Index})
+  T = ITensor()
+  for a in o.args[1]
+    T += ITensor(a, s)
   end
-  return res
+  return T
 end
 
-function ITensor(o::∑, s::Vector{<:Index})
-  o_id = insert_ids(o)
-  ∑layers = ∑([ITensor(oₙ, s) for oₙ in o_id])
-  return ITensor(∑layers)
-  ## if hassamesites(o)
-  ##   return o.f([ITensor(arg, s) for arg in o])
-  ## end
-  ## return error("Trying to make an ITensor from operator expression $o. When making an ITensor from a sum of operators, the operators need to have the same sites.")
+function ITensor(o::Exp, s::Vector{<:Index})
+  return exp(ITensor(argument(o), s))
 end
 
-function ITensor(o::α, s::Vector{<:Index})
-  return coefficient(o) * ITensor(Ops.op(o), s)
+function ITensor(o::LazyApply.Adjoint, s::Vector{<:Index})
+  return swapprime(dag(ITensor(o', s)), 0 => 1)
 end
 
-function ITensor(o::Applied{typeof(exp)}, s::Vector{<:Index})
-  return o.f(ITensor(Ops.op(o), s))
+function Sum{ITensor}(o::Sum, s::Vector{<:Index})
+  return Applied(sum, (map(oₙ -> ITensor(oₙ, s), only(o.args)),))
 end
 
-itensor_adjoint(T::ITensor) = swapprime(dag(T), 0 => 1)
-
-function ITensor(o::Applied{typeof(adjoint)}, s::Vector{<:Index})
-  return itensor_adjoint(ITensor(Ops.op(o), s))
+function Prod{ITensor}(o::Prod, s::Vector{<:Index})
+  return Applied(prod, (map(oₙ -> ITensor(oₙ, s), only(o.args)),))
 end
 
-function ITensor(o::Applied, s::Vector{<:Index})
-  return error("Trying to make ITensor from expression $(o), not yet implemented.")
+function Prod{ITensor}(o::Scaled{C,Prod{Op}}, s::Vector{<:Index}) where {C}
+  t = Prod{ITensor}(argument(o), s)
+  t1 = coefficient(o) * only(t.args)[1]
+  return Applied(prod, (vcat([t1], only(t.args)[2:end]),))
 end
 
-∏{ITensor}(o::∏, s::Vector{<:Index}) = ∏([ITensor(oₙ, s) for oₙ in o])
-∏{ITensor}(o::Union{Op,Applied}, s::Vector{<:Index}) = ∏{ITensor}(∏([o]), s)
-∑{ITensor}(o::∑, s::Vector{<:Index}) = ∑([ITensor(oₙ, s) for oₙ in o])
-∑{ITensor}(o::Union{Op,Applied}, s::Vector{<:Index}) = ∑{ITensor}(∑([o]), s)
+function apply(o::Prod{ITensor}, v::ITensor; kwargs...)
+  ov = v
+  for oₙ in reverse(only(o.args))
+    ov = apply(oₙ, ov; kwargs...)
+  end
+  return ov
+end
 
-(o::∏{ITensor})(x; kwargs...) = apply(o, x; kwargs...)
-# Apply it in reverse to follow the linear algebra convention:
-# (O₁ * O₂)|x⟩ = O₁ * (O₂|x⟩)
-apply(o::∏{ITensor}, x; kwargs...) = apply([oₙ for oₙ in reverse(o)], x; kwargs...)
+function (o::Prod{ITensor})(v::ITensor; kwargs...)
+  return apply(o, v; kwargs...)
+end
diff --git a/src/Ops/ops_mpo.jl b/src/Ops/ops_mpo.jl
index d7dc626a48..8300472c03 100644
--- a/src/Ops/ops_mpo.jl
+++ b/src/Ops/ops_mpo.jl
@@ -1,20 +1,43 @@
-function SiteOp(o::Op)
-  return SiteOp(Ops.which_op(o), Ops.sites(o), Ops.params(o))
-end
+## function apply(o::Prod{ITensor}, v::Union{MPS,MPO}; kwargs...)
+##   ov = v
+##   for oₙ in only(o.args)
+##     ov = apply(oₙ, ov; kwargs...)
+##   end
+##   return ov
+## end
+## 
+## function (o::Prod{ITensor})(v::Union{MPS,MPO}; kwargs...)
+##   return apply(o, v; kwargs...)
+## end
 
-function MPOTerm(o::α{∏{Op}})
-  return MPOTerm(coefficient(o), [SiteOp(oₙ) for oₙ in o])
-end
+#
+# Conversion to ITensors.OpSum and MPO
+#
 
-function OpSum(o::∑{<:α{∏{Op}}})
-  return OpSum([MPOTerm(oₙ) for oₙ in o])
-end
+## function SiteOp(o::Op)
+##   return SiteOp(Ops.which_op(o), Ops.sites(o), Ops.params(o))
+## end
+## 
+## function MPOTerm(o::Scaled{C,Prod{Op}}) where {C}
+##   return MPOTerm(coefficient(o), [SiteOp(oₙ) for oₙ in argument(o)])
+## end
+## 
+## function OpSum(o::Sum{Scaled{C,Prod{Op}}}) where {C}
+##   return OpSum([MPOTerm(oₙ) for oₙ in o])
+## end
 
-function OpSum(o::Union{Op,Applied})
-  return OpSum(∑{<:α{∏{Op}}}(o))
-end
+## function OpSum(o::Union{Op,Applied})
+##   return OpSum(Sum{<:Scaled{<:Number,Prod{Op}}}(o))
+## end
 
-# Conversions from other formats
-function MPO(o::Union{Op,Applied}, s::Vector{<:Index}; kwargs...)
-  return MPO(OpSum(o), s; kwargs...)
-end
+## function OpSum(
+##   o::Union{Op,Scaled{C,Op},Prod{Op},Sum{Op},Scaled{C,Prod{Op}},Sum{Scaled{Float64,Op}}}
+## ) where {C}
+##   os = Sum{Scaled{Float64,Prod{Op}}}() + o
+##   return OpSum(os)
+## end
+## 
+## # Conversions from other formats
+## function MPO(o::Union{Op,Applied}, s::Vector{<:Index}; kwargs...)
+##   return MPO(OpSum(o), s; kwargs...)
+## end
diff --git a/src/Ops/trotter.jl b/src/Ops/trotter.jl
index 9ae398faf1..09b4433072 100644
--- a/src/Ops/trotter.jl
+++ b/src/Ops/trotter.jl
@@ -5,29 +5,29 @@ struct Exact <: ExpAlgorithm end
 struct Trotter{Order} <: ExpAlgorithm
   nsteps::Int
 end
+Trotter{Order}() where {Order} = Trotter{Order}(1)
 one(::Trotter{Order}) where {Order} = Trotter{Order}(1)
 
-function exp(o::∑; alg::ExpAlgorithm=Exact())
+function exp(o::Sum; alg::ExpAlgorithm=Exact())
   return exp(alg, o)
 end
 
-function exp(::Exact, o::∑)
-  return ∏([Applied(exp, o)])
+function exp(::Exact, o::Sum)
+  return Applied(prod, ([Applied(exp, (o,))],))
 end
 
-function exp_one_step(trotter::Trotter{1}, o::∑)
-  # TODO: Customize broadcast of `∏`.
-  exp_o = ∏([exp(oₙ) for oₙ in o])
+function exp_one_step(trotter::Trotter{1}, o::Sum)
+  exp_o = Applied(prod, (map(exp, reverse(only(o.args))),))
   return exp_o
 end
 
-function exp_one_step(trotter::Trotter{N}, o::∑) where {N}
-  exp_o_order_1 = exp_one_step(Trotter{Int(N / 2)}(1), o / 2)
-  exp_o = exp_o_order_1 * reverse(exp_o_order_1)
+function exp_one_step(trotter::Trotter{2}, o::Sum)
+  exp_o_order_1 = exp_one_step(Trotter{1}(), o / 2)
+  exp_o = reverse(exp_o_order_1) * exp_o_order_1
   return exp_o
 end
 
-function exp(trotter::Trotter, o::∑)
+function exp(trotter::Trotter, o::Sum)
   expδo = exp_one_step(one(trotter), o / trotter.nsteps)
   return expδo^trotter.nsteps
 end
diff --git a/src/algorithm.jl b/src/algorithm.jl
new file mode 100644
index 0000000000..bd655ed39f
--- /dev/null
+++ b/src/algorithm.jl
@@ -0,0 +1,29 @@
+"""
+    Algorithm
+
+A type representing an algorithm backend for a function.
+
+For example, ITensor provides multiple backend algorithms for contracting
+an MPO with an MPS, which internally are selected with an `Algorithm` type.
+
+This allows users to extend functions in ITensor with new algorithms, but
+use the same interface.
+"""
+struct Algorithm{Alg} end
+
+Algorithm(s) = Algorithm{Symbol(s)}()
+algorithm(::Algorithm{Alg}) where {Alg} = string(Alg)
+
+show(io::IO, alg::Algorithm) = print(io, "Algorithm type ", algorithm(alg))
+print(io::IO, ::Algorithm{Alg}) where {Alg} = print(io, Alg)
+
+"""
+    @Algorithm_str
+
+A convenience macro for writing [`Algorithm`](@ref) types, typically used when
+adding methods to a function in ITensor that supports multiple algorithm
+backends (like contracting an MPO with an MPS).
+"""
+macro Algorithm_str(s)
+  return :(Algorithm{$(Expr(:quote, Symbol(s)))})
+end
diff --git a/src/decomp.jl b/src/decomp.jl
index cf399e67b9..65bf2ed24e 100644
--- a/src/decomp.jl
+++ b/src/decomp.jl
@@ -37,6 +37,10 @@ The first three return arguments are `U`, `S`, and `V`, such that
 Whether or not the SVD performs a trunction depends on the keyword
 arguments provided. 
 
+If the left or right set of indices are empty, all input indices are
+put on `V` or `U` respectively. To specify an empty set of left indices,
+you must explicitly use `svd(A, ())` (`svd(A)` is currently undefined).
+
 # Examples
 
 ```julia
@@ -74,6 +78,7 @@ Utrunc2, Strunc2, Vtrunc2 = svd(A, i, k; cutoff=1e-10);
   - `"recursive"` - ITensor's custom svd. Very reliable, but may be slow if high precision is needed. To get an `svd` of a matrix `A`, an eigendecomposition of ``A^{\\dagger} A`` is used to compute `U` and then a `qr` of ``A^{\\dagger} U`` is used to compute `V`. This is performed recursively to compute small singular values.
 - `use_absolute_cutoff::Bool = false`: set if all probability weights below the `cutoff` value should be discarded, rather than the sum of discarded weights.
 - `use_relative_cutoff::Bool = true`: set if the singular values should be normalized for the sake of truncation.
+- `min_blockdim::Int = 0`: for SVD of block-sparse or QN ITensors, require that the number of singular values kept be greater than or equal to this value when possible
 
 See also: [`factorize`](@ref), [`eigen`](@ref)
 """
@@ -89,10 +94,19 @@ function svd(A::ITensor, Linds...; kwargs...)
   Lis = commoninds(A, indices(Linds))
   Ris = uniqueinds(A, Lis)
 
-  if length(Lis) == 0 || length(Ris) == 0
-    error(
-      "In `svd`, the left or right indices are empty (the indices of `A` are ($(inds(A))), but the input indices are ($Lis)). For now, this is not supported. You may have accidentally input the wrong indices.",
-    )
+  Lis_original = Lis
+  Ris_original = Ris
+  if isempty(Lis_original)
+    α = trivial_index(Ris)
+    vLα = onehot(α => 1)
+    A *= vLα
+    Lis = [α]
+  end
+  if isempty(Ris_original)
+    α = trivial_index(Lis)
+    vRα = onehot(α => 1)
+    A *= vRα
+    Ris = [α]
   end
 
   CL = combiner(Lis...)
@@ -116,27 +130,6 @@ function svd(A::ITensor, Linds...; kwargs...)
   u = commonind(S, UC)
   v = commonind(S, VC)
 
-  if hasqns(A)
-    # Fix the flux of UC,S,VC
-    # such that flux(UC) == flux(VC) == QN()
-    # and flux(S) == flux(A)
-    for b in nzblocks(UC)
-      i1 = inds(UC)[1]
-      i2 = inds(UC)[2]
-      newqn = -dir(i2) * flux(i1 => Block(b[1]))
-      setblockqn!(i2, newqn, b[2])
-      setblockqn!(u, newqn, b[2])
-    end
-
-    for b in nzblocks(VC)
-      i1 = inds(VC)[1]
-      i2 = inds(VC)[2]
-      newqn = -dir(i2) * flux(i1 => Block(b[1]))
-      setblockqn!(i2, newqn, b[2])
-      setblockqn!(v, newqn, b[2])
-    end
-  end
-
   U = UC * dag(CL)
   V = VC * dag(CR)
 
@@ -148,9 +141,18 @@ function svd(A::ITensor, Linds...; kwargs...)
   u = settags(u, utags)
   v = settags(v, vtags)
 
+  if isempty(Lis_original)
+    U *= dag(vLα)
+  end
+  if isempty(Ris_original)
+    V *= dag(vRα)
+  end
+
   return TruncSVD(U, S, V, spec, u, v)
 end
 
+svd(A::ITensor; kwargs...) = error("Must specify indices in `svd`")
+
 """
     TruncEigen
 
@@ -333,6 +335,22 @@ function qr(A::ITensor, Linds...; kwargs...)
   tags::TagSet = get(kwargs, :tags, "Link,qr")
   Lis = commoninds(A, indices(Linds))
   Ris = uniqueinds(A, Lis)
+
+  Lis_original = Lis
+  Ris_original = Ris
+  if isempty(Lis_original)
+    α = trivial_index(Ris)
+    vLα = onehot(α => 1)
+    A *= vLα
+    Lis = [α]
+  end
+  if isempty(Ris_original)
+    α = trivial_index(Lis)
+    vRα = onehot(α => 1)
+    A *= vRα
+    Ris = [α]
+  end
+
   Lpos, Rpos = NDTensors.getperms(inds(A), Lis, Ris)
   QT, RT = qr(tensor(A), Lpos, Rpos; kwargs...)
   Q, R = itensor(QT), itensor(RT)
@@ -340,6 +358,14 @@ function qr(A::ITensor, Linds...; kwargs...)
   settags!(Q, tags, q)
   settags!(R, tags, q)
   q = settags(q, tags)
+
+  if isempty(Lis_original)
+    Q *= dag(vLα)
+  end
+  if isempty(Ris_original)
+    R *= dag(vRα)
+  end
+
   return Q, R, q
 end
 
diff --git a/src/deprecated.jl b/src/deprecated.jl
index dde823810c..465b38cacb 100644
--- a/src/deprecated.jl
+++ b/src/deprecated.jl
@@ -52,7 +52,7 @@
 @deprecate mul(A::AbstractMPS, B::AbstractMPS; kwargs...) contract(A, B; kwargs...)
 
 # mps/mpo.jl
-@deprecate MPO(A::MPS; kwargs...) outer(A, A; kwargs...)
+@deprecate MPO(A::MPS; kwargs...) outer(A', A; kwargs...)
 
 # mps/mps.jl
 @deprecate randomMPS(sites::Vector{<:Index}, linkdims::Integer) randomMPS(
diff --git a/src/exports.jl b/src/exports.jl
index 5c6dbabb47..74d40ee14f 100644
--- a/src/exports.jl
+++ b/src/exports.jl
@@ -1,6 +1,7 @@
 export
   # From external modules
   # LinearAlgebra
+  nullspace,
   tr,
 
   # Modules
@@ -39,6 +40,7 @@ export
   polar,
   qr,
   svd,
+  diag,
 
   # global_variables.jl
   # Methods
@@ -69,6 +71,7 @@ export
   plev,
   prime,
   removetags,
+  removeqn,
   removeqns,
   replacetags,
   replacetags!,
@@ -114,8 +117,10 @@ export
   ITensor,
   # Methods
   ⊙,
+  ⊕,
   addtags!,
   apply,
+  Apply,
   array,
   axpy!,
   blockoffsets,
@@ -124,12 +129,15 @@ export
   commonind,
   commoninds,
   complex!,
+  convert_eltype,
+  convert_leaf_eltype,
   delta,
   dense,
   denseblocks,
   δ,
   diagitensor,
   diagITensor,
+  directsum,
   dot,
   eachnzblock,
   firstind,
@@ -204,10 +212,10 @@ export
   hastags,
 
   # LazyApply/LazyApply.jl
-  coefficient,
   Scaled,
   Sum,
   Prod,
+  coefficient,
 
   # mps/dmrg.jl
   dmrg,
@@ -217,9 +225,10 @@ export
   @preserve_ortho,
   # Methods
   add,
-  contract,
   common_siteind,
   common_siteinds,
+  contract,
+  convert_eltype,
   dag!,
   findfirstsiteind,
   findfirstsiteinds,
@@ -359,6 +368,8 @@ export
   ops,
   OpName,
   @OpName_str,
+  ValName,
+  @ValName_str,
   state,
   TagType,
   @TagType_str,
@@ -374,6 +385,7 @@ export
   val,
 
   # qn/qnindex.jl
+  blockdim,
   flux,
   hasqns,
   nblocks,
diff --git a/src/imports.jl b/src/imports.jl
index 9f3c3fd8d1..63c7e03473 100644
--- a/src/imports.jl
+++ b/src/imports.jl
@@ -20,6 +20,7 @@ import Base:
   allunique,
   axes,
   complex,
+  conj,
   convert,
   copy,
   copyto!,
@@ -34,12 +35,15 @@ import Base:
   findfirst,
   getindex,
   hash,
+  imag,
   intersect,
   intersect!,
   isapprox,
   isassigned,
   isempty,
   isless,
+  isreal,
+  iszero,
   iterate,
   keys,
   lastindex,
@@ -48,8 +52,10 @@ import Base:
   map!,
   ndims,
   permutedims,
+  print,
   promote_rule,
   push!,
+  real,
   resize!,
   setdiff,
   setdiff!,
@@ -95,6 +101,7 @@ import LinearAlgebra:
   norm,
   normalize,
   normalize!,
+  nullspace,
   qr,
   rmul!,
   svd,
@@ -119,7 +126,6 @@ import ITensors.NDTensors:
   AliasStyle,
   AllowAlias,
   NeverAlias,
-  # Methods
   array,
   blockdim,
   blockoffsets,
@@ -149,6 +155,7 @@ import ITensors.NDTensors:
   permuteblocks,
   polar,
   scale!,
+  setblock!,
   setblockdim!,
   setinds,
   setstorage,
diff --git a/src/index.jl b/src/index.jl
index 3b9705d4c5..a46694e690 100644
--- a/src/index.jl
+++ b/src/index.jl
@@ -231,6 +231,9 @@ function sim(i::Index; tags=copy(tags(i)), plev=plev(i), dir=dir(i))
   return Index(rand(index_id_rng(), IDType), copy(space(i)), dir, tags, plev)
 end
 
+trivial_space(i::Index) = 1
+trivial_index(i::Index) = Index(trivial_space(i))
+
 """
     dag(i::Index)
 
@@ -517,6 +520,21 @@ Removes the QNs from the Index, if it has any.
 """
 removeqns(i::Index) = i
 
+"""
+    removeqn(::Index, qn_name::String)
+
+Remove the specified QN from the Index, if it has any.
+"""
+removeqn(i::Index, qn_name::String) = i
+
+"""
+    mergeblocks(::Index)
+
+Merge the contiguous QN blocks if they have the same
+quantum numbers.
+"""
+mergeblocks(i::Index) = i
+
 # Keep partial backwards compatibility by defining IndexVal as follows:
 const IndexVal{IndexT} = Pair{IndexT,Int}
 
diff --git a/src/indexset.jl b/src/indexset.jl
index 99fc79bcbc..2cf128aefb 100644
--- a/src/indexset.jl
+++ b/src/indexset.jl
@@ -1,4 +1,3 @@
-
 # Represents a static order of an ITensor
 @eval struct Order{N}
   (OrderT::Type{<:Order})() = $(Expr(:new, :OrderT))
@@ -35,6 +34,9 @@ tuple_to_vector(t::Tuple) = collect(t)
 tuple_to_vector(t) = t
 
 function _narrow_eltype(v::Vector{T}) where {T}
+  if isempty(v)
+    return v
+  end
   return convert(Vector{mapreduce(typeof, promote_type, v)}, v)
 end
 narrow_eltype(v::Vector{T}) where {T} = isconcretetype(T) ? v : _narrow_eltype(v)
@@ -161,6 +163,13 @@ You can also use the broadcast version `sim.(is)`.
 """
 sim(is::Indices) = map(i -> sim(i), is)
 
+function trivial_index(is::Indices)
+  if isempty(is)
+    return Index(1)
+  end
+  return trivial_index(first(is))
+end
+
 """
     mindim(is::Indices)
 
@@ -596,7 +605,11 @@ end
 
 swapind(is::Indices, i1::Index, i2::Index) = swapinds(is, (i1,), (i2,))
 
-removeqns(is::Indices) = is
+removeqns(is::Indices) = map(removeqns, is)
+function removeqn(is::Indices, qn_name::String; mergeblocks=true)
+  return map(i -> removeqn(i, qn_name; mergeblocks), is)
+end
+mergeblocks(is::Indices) = map(mergeblocks, is)
 
 # Permute is1 to be in the order of is2
 # This is helpful when is1 and is2 have different directions, and
diff --git a/src/itensor.jl b/src/itensor.jl
index cd42f706fe..af15cad4fb 100644
--- a/src/itensor.jl
+++ b/src/itensor.jl
@@ -114,6 +114,9 @@ ITensor(as::AliasStyle, is, st::TensorStorage)::ITensor = ITensor(as, st, is)
 ITensor(st::TensorStorage, is)::ITensor = itensor(Tensor(NeverAlias(), st, Tuple(is)))
 ITensor(is, st::TensorStorage)::ITensor = ITensor(NeverAlias(), st, is)
 
+itensor(T::ITensor) = T
+ITensor(T::ITensor) = copy(T)
+
 """
     itensor(args...; kwargs...)
 
@@ -461,6 +464,13 @@ function ITensor(
   return itensor(Dense(data), inds)
 end
 
+# Convert `Adjoint` to `Matrix`
+function ITensor(
+  as::AliasStyle, eltype::Type{<:Number}, A::Adjoint, inds::Indices{Index{Int}}; kwargs...
+)
+  return ITensor(as, eltype, Matrix(A), inds; kwargs...)
+end
+
 function ITensor(
   as::AliasStyle, eltype::Type{<:Number}, A::AbstractArray{<:Number}, is...; kwargs...
 )
@@ -639,6 +649,8 @@ const δ = delta
 """
     onehot(ivs...)
     setelt(ivs...)
+    onehot(::Type, ivs...)
+    setelt(::Type, ivs...)
 
 Create an ITensor with all zeros except the specified value,
 which is set to 1.
@@ -649,16 +661,23 @@ i = Index(2,"i")
 A = onehot(i=>2)
 # A[i=>2] == 1, all other elements zero
 
+# Specify the element type
+A = onehot(Float32, i=>2)
+
 j = Index(3,"j")
 B = onehot(i=>1,j=>3)
 # B[i=>1,j=>3] == 1, all other element zero
 ```
 """
-function onehot(ivs::Pair{<:Index}...)
-  A = emptyITensor(ind.(ivs)...)
-  A[val.(ivs)...] = 1.0
+function onehot(eltype::Type{<:Number}, ivs::Pair{<:Index}...)
+  A = ITensor(eltype, ind.(ivs)...)
+  A[val.(ivs)...] = one(eltype)
   return A
 end
+onehot(eltype::Type{<:Number}, ivs::Vector{<:Pair{<:Index}}) = onehot(eltype, ivs...)
+setelt(eltype::Type{<:Number}, ivs::Pair{<:Index}...) = onehot(eltype, ivs...)
+
+onehot(ivs::Pair{<:Index}...) = onehot(Float64, ivs...)
 onehot(ivs::Vector{<:Pair{<:Index}}) = onehot(ivs...)
 setelt(ivs::Pair{<:Index}...) = onehot(ivs...)
 
@@ -674,6 +693,8 @@ function dense(A::ITensor)
   return setinds(itensor(dense(tensor(A))), removeqns(inds(A)))
 end
 
+removeqns(T::ITensor) = dense(T)
+
 denseblocks(D::ITensor) = itensor(denseblocks(tensor(D)))
 
 """
@@ -748,6 +769,28 @@ size(A::ITensor, d::Int) = size(tensor(A), d)
 
 copy(T::ITensor)::ITensor = itensor(copy(tensor(T)))
 
+function convert_eltype(ElType::Type, T::ITensor)
+  if eltype(T) == ElType
+    return T
+  end
+  return itensor(ElType.(tensor(T)))
+end
+
+function convert_leaf_eltype(ElType::Type, T::ITensor)
+  return convert_eltype(ElType, T)
+end
+
+"""
+    convert_leaf_eltype(ElType::Type, A::Array)
+
+Convert the element type of the lowest level containers
+("leaves") of a recursive data structure, such as
+an Vector of Vectors.
+"""
+function convert_leaf_eltype(ElType::Type, A::Array)
+  return map(x -> convert_leaf_eltype(ElType, x), A)
+end
+
 """
     Array{ElT, N}(T::ITensor, i:Index...)
     Array{ElT}(T::ITensor, i:Index...)
@@ -1050,6 +1093,14 @@ it may return a Cartesian range.
 """
 eachindex(A::ITensor) = eachindex(tensor(A))
 
+"""
+    eachindval(A::ITensor)
+
+Create an iterable object for visiting each element of the ITensor `A` (including structually
+zero elements for sparse tensors) in terms of pairs of indices and values.
+"""
+eachindval(T::ITensor) = eachindval(inds(T))
+
 """
     iterate(A::ITensor, args...)
 
@@ -1450,6 +1501,8 @@ function (A::ITensor == B::ITensor)
   return norm(A - B) == zero(promote_type(eltype(A), eltype(B)))
 end
 
+LinearAlgebra.promote_leaf_eltypes(A::ITensor) = eltype(A)
+
 function isapprox(A::ITensor, B::ITensor; kwargs...)
   if !hassameinds(A, B)
     error(
@@ -1491,6 +1544,16 @@ function randomITensor(::Type{S}, is...) where {S<:Number}
   return randomITensor(S, indices(is...))
 end
 
+# To fix ambiguity with QN version
+function randomITensor(::Type{ElT}, ::Tuple{}) where {ElT<:Number}
+  return randomITensor(ElT, Index{Int}[])
+end
+
+# To fix ambiguity with QN version
+function randomITensor(is::Tuple{})
+  return randomITensor(Float64, is)
+end
+
 # To fix ambiguity errors with QN version
 function randomITensor(::Type{ElT}) where {ElT<:Number}
   return randomITensor(ElT, ())
@@ -1517,6 +1580,67 @@ function combiner(; kwargs...)
   return itensor(Combiner(), ())
 end
 
+@doc """
+    combiner(inds::Indices; kwargs...)
+
+Make a combiner ITensor which combines the indices (of type Index)
+into a single, new Index whose size is the product of the indices 
+given. For example, given indices `i1,i2,i3` the combiner will have 
+these three indices plus an additional one whose dimension is the 
+product of the dimensions of `i1,i2,i3`.
+
+Internally, a combiner ITensor uses a special storage type which
+means it does not hold actual tensor elements but just information
+about how to combine the indices into a single Index. Taking a product
+of a regular ITensor with a combiner uses special fast algorithms to
+combine the indices.
+
+To obtain the new, combined Index that the combiner makes out of
+the indices it is given, use the `combinedind` function.
+
+To undo or reverse the combining process, uncombining the Index back
+into the original ones, contract the tensor having the combined Index
+with the conjugate or `dag` of the combiner. (If the combiner is an ITensor 
+`C`, multiply by `dag(C)`.)
+
+### Example
+```
+# Combine indices i and k into a new Index ci
+T = randomITensor(i,j,k)
+C = combiner(i,k)
+CT = C * T
+ci = combinedind(C)
+
+# Uncombine ci back into i and k
+TT = dag(C) * CT
+
+# TT will be the same as T
+@show norm(TT - T) ≈ 0.0
+```
+         
+              i  j  k
+              |  |  |
+     T   =    =======
+
+              ci  i  k
+              |   |  |
+     C   =    ========
+              
+              ci  j
+              |   |
+     C * T =  =====
+
+""" combiner
+
+"""
+    combinedind(C::ITensor)
+
+Given a combiner ITensor, return the Index which is
+the "combined" index that is made out of merging
+the other indices given to the combiner when it is made
+
+For more information, see the `combiner` function.
+"""
 function combinedind(T::ITensor)
   if storage(T) isa Combiner && order(T) > 0
     return inds(T)[1]
@@ -1728,11 +1852,11 @@ function (A::ITensor - B::ITensor)
   return C
 end
 
-Base.real(T::ITensor)::ITensor = itensor(real(tensor(T)))
+real(T::ITensor)::ITensor = itensor(real(tensor(T)))
 
-Base.imag(T::ITensor)::ITensor = itensor(imag(tensor(T)))
+imag(T::ITensor)::ITensor = itensor(imag(tensor(T)))
 
-Base.conj(T::ITensor)::ITensor = itensor(conj(tensor(T)))
+conj(T::ITensor)::ITensor = itensor(conj(tensor(T)))
 
 # Function barrier
 function _contract(A::Tensor, B::Tensor)
@@ -1833,7 +1957,9 @@ B = randomITensor(k,i,j)
 C = A * B # inner product of A and B, all indices contracted
 ```
 """
-(A::ITensor * B::ITensor)::ITensor = contract(A, B)
+function (A::ITensor * B::ITensor)::ITensor
+  return contract(A, B)
+end
 
 function contract(A::ITensor, B::ITensor)::ITensor
   NA::Int = ndims(A)
@@ -2019,10 +2145,8 @@ function ishermitian(T::ITensor; kwargs...)
   return isapprox(T, dag(transpose(T)); kwargs...)
 end
 
-# Trace an ITensor over pairs of indices determined by
-# the prime levels and tags. Indices that are not in pairs
-# are not traced over, corresponding to a "batched" trace.
-function tr(T::ITensor; plev::Pair{Int,Int}=0 => 1, tags::Pair=ts"" => ts"")
+# Fix for AD
+function _tr(T::ITensor; plev::Pair{Int,Int}=0 => 1, tags::Pair=ts"" => ts"")
   trpairs = indpairs(T; plev=plev, tags=tags)
   Cᴸ = combiner(first.(trpairs))
   Cᴿ = combiner(last.(trpairs))
@@ -2036,6 +2160,13 @@ function tr(T::ITensor; plev::Pair{Int,Int}=0 => 1, tags::Pair=ts"" => ts"")
   return Tᶜ
 end
 
+# Trace an ITensor over pairs of indices determined by
+# the prime levels and tags. Indices that are not in pairs
+# are not traced over, corresponding to a "batched" trace.
+function tr(T::ITensor; kwargs...)
+  return _tr(T; kwargs...)
+end
+
 """
     exp(A::ITensor, Linds=Rinds', Rinds=inds(A,plev=0); ishermitian = false)
 
@@ -2149,16 +2280,79 @@ function directsum_itensors(i::Index, j::Index, ij::Index)
   return D1, D2
 end
 
+function check_directsum_inds(A::ITensor, I, B::ITensor, J)
+  a = uniqueinds(A, I)
+  b = uniqueinds(B, J)
+  if !hassameinds(a, b)
+    error("""In directsum, attemptying to direct sum ITensors A and B with indices:
+
+          $(inds(A))
+
+          and
+
+          $(inds(B))
+
+          over the indices
+
+          $(I)
+
+          and
+
+          $(J)
+
+          The indices not being direct summed must match, however they are
+
+          $a
+
+          and
+
+          $b
+          """)
+  end
+end
+
+function _directsum(A::ITensor, I, B::ITensor, J; tags=["sum$i" for i in 1:length(I)])
+  N = length(I)
+  (N != length(J)) &&
+    error("In directsum(::ITensor, ::ITensor, ...), must sum equal number of indices")
+  check_directsum_inds(A, I, B, J)
+  IJ = Vector{Base.promote_eltype(I, J)}(undef, N)
+  for n in 1:N
+    In = I[n]
+    Jn = J[n]
+    In = dir(A, In) != dir(In) ? dag(In) : In
+    Jn = dir(B, Jn) != dir(Jn) ? dag(Jn) : Jn
+    IJn = directsum(In, Jn; tags=tags[n])
+    D1, D2 = directsum_itensors(In, Jn, IJn)
+    IJ[n] = IJn
+    A *= D1
+    B *= D2
+  end
+  C = A + B
+  return C => IJ
+end
+
+function _directsum(A::ITensor, i::Index, B::ITensor, j::Index; tags="sum")
+  C, (ij,) = _directsum(A, (i,), B, (j,); tags=[tags])
+  return C => ij
+end
+
 function directsum(A_and_I::Pair{ITensor}, B_and_J::Pair{ITensor}; kwargs...)
-  A, I = A_and_I
-  B, J = B_and_J
-  return directsum(A, B, I, J; kwargs...)
+  return _directsum(A_and_I..., B_and_J...; kwargs...)
+end
+
+function default_directsum_tags(A_and_I::Pair{ITensor})
+  return ["sum$i" for i in 1:length(last(A_and_I))]
+end
+
+function default_directsum_tags(A_and_I::Pair{ITensor,<:Index})
+  return "sum"
 end
 
 """
     directsum(A::Pair{ITensor}, B::Pair{ITensor}, ...; tags)
 
-Given a list of pairs of ITensors and collections of indices, perform a partial
+Given a list of pairs of ITensors and indices, perform a partial
 direct sum of the tensors over the specified indices. Indices that are
 not specified to be summed must match between the tensors.
 
@@ -2180,9 +2374,21 @@ j1 = Index(4, "j1")
 i2 = Index(5, "i2")
 j2 = Index(6, "j2")
 
+A1 = randomITensor(x, i1)
+A2 = randomITensor(x, i2)
+S, s = directsum(A1 => i1, A2 => i2)
+dim(s) == dim(i1) + dim(i2)
+
+A3 = randomITensor(x, j1)
+S, s = directsum(A1 => i1, A2 => i2, A3 => j1)
+dim(s) == dim(i1) + dim(i2) + dim(j1)
+
 A1 = randomITensor(i1, x, j1)
 A2 = randomITensor(x, j2, i2)
-S, s = ITensors.directsum(A1 => (i1, j1), A2 => (i2, j2); tags = ["sum_i", "sum_j"])
+S, s = directsum(A1 => (i1, j1), A2 => (i2, j2); tags = ["sum_i", "sum_j"])
+length(s) == 2
+dim(s[1]) == dim(i1) + dim(i2)
+dim(s[2]) == dim(j1) + dim(j2)
 ```
 """
 function directsum(
@@ -2190,34 +2396,16 @@ function directsum(
   B_and_J::Pair{ITensor},
   C_and_K::Pair{ITensor},
   itensor_and_inds...;
-  tags=["sum$i" for i in 1:length(last(A_and_I))],
+  tags=default_directsum_tags(A_and_I),
 )
-  return directsum(
-    Pair(directsum(A_and_I, B_and_J; kwargs...)...), C_and_K, itensor_and_inds...; tags=tags
-  )
+  return directsum(directsum(A_and_I, B_and_J; tags), C_and_K, itensor_and_inds...; tags)
 end
 
-function directsum(A::ITensor, B::ITensor, I, J; tags)
-  N = length(I)
-  (N != length(J)) &&
-    error("In directsum(::ITensor, ::ITensor, ...), must sum equal number of indices")
-  IJ = Vector{Base.promote_eltype(I, J)}(undef, N)
-  for n in 1:N
-    In = I[n]
-    Jn = J[n]
-    In = dir(A, In) != dir(In) ? dag(In) : In
-    Jn = dir(B, Jn) != dir(Jn) ? dag(Jn) : Jn
-    IJn = directsum(In, Jn; tags=tags[n])
-    D1, D2 = directsum_itensors(In, Jn, IJn)
-    IJ[n] = IJn
-    A *= D1
-    B *= D2
-  end
-  C = A + B
-  return C, IJ
-end
+const ⊕ = directsum
 
 """
+    apply(A::ITensor, B::ITensor)
+    (A::ITensor)(B::ITensor)
     product(A::ITensor, B::ITensor)
 
 Get the product of ITensor `A` and ITensor `B`, which
@@ -2367,6 +2555,10 @@ end
 # Alias apply with product
 const apply = product
 
+(A::ITensor)(B::ITensor) = apply(A, B)
+
+const Apply{Args} = Applied{typeof(apply),Args}
+
 inner(y::ITensor, A::ITensor, x::ITensor) = (dag(y) * A * x)[]
 inner(y::ITensor, x::ITensor) = (dag(y) * x)[]
 
@@ -2416,6 +2608,8 @@ function map!(f::Function, R::ITensor, T1::ITensor, T2::ITensor)
   return settensor!(R, _map!!(f, tensor(R), tensor(T1), tensor(T2)))
 end
 
+map(f, x::ITensor) = itensor(map(f, tensor(x)))
+
 """
     axpy!(a::Number, v::ITensor, w::ITensor)
 ```
@@ -2541,6 +2735,9 @@ isemptystorage(T::ITensor) = isemptystorage(tensor(T))
 isemptystorage(T::Tensor) = isempty(T)
 isempty(T::ITensor) = isemptystorage(T)
 
+isreal(T::ITensor) = eltype(T) <: Real
+iszero(T::ITensor) = all(iszero, T)
+
 #######################################################################
 #
 # Developer functions
@@ -2552,42 +2749,130 @@ isempty(T::ITensor) = isemptystorage(T)
 Given an ITensor `T`, returns
 an Array with a copy of the ITensor's elements,
 or a view in the case the the ITensor's storage is Dense.
+
 The ordering of the elements in the Array, in
 terms of which Index is treated as the row versus
 column, depends on the internal layout of the ITensor.
-*Therefore this method is intended for developer use
-only and not recommended for use in ITensor applications.*
+
+!!! warning
+    This method is intended for developer use
+    only and not recommended for use in ITensor applications
+    unless you know what you are doing (for example
+    you are certain of the memory ordering of the ITensor
+    because you permuted the indices into a certain order).
+
+See also [`matrix`](@ref), [`vector`](@ref).
 """
 array(T::ITensor) = array(tensor(T))
 
+"""
+    array(T::ITensor, inds...)
+
+Convert an ITensor `T` to an Array.
+
+The ordering of the elements in the Array are specified
+by the input indices `inds`. This tries to avoid copying
+of possible (i.e. may return a view of the original
+data), for example if the ITensor's storage is Dense
+and the indices are already in the specified ordering
+so that no permutation is required.
+
+!!! warning
+    Note that in the future we may return specialized
+    AbstractArray types for certain storage types,
+    for example a `LinearAlgebra.Diagonal` type for
+    an ITensor with `Diag` storage. The specific storage
+    type shouldn't be relied upon.
+
+See also [`matrix`](@ref), [`vector`](@ref).
+"""
+array(T::ITensor, inds...) = array(permute(T, inds...; allow_alias=true))
+
 """
     matrix(T::ITensor)
 
 Given an ITensor `T` with two indices, returns
 a Matrix with a copy of the ITensor's elements,
 or a view in the case the ITensor's storage is Dense.
+
 The ordering of the elements in the Matrix, in
 terms of which Index is treated as the row versus
 column, depends on the internal layout of the ITensor.
-*Therefore this method is intended for developer use
-only and not recommended for use in ITensor applications.*
+
+!!! warning
+    This method is intended for developer use
+    only and not recommended for use in ITensor applications
+    unless you know what you are doing (for example
+    you are certain of the memory ordering of the ITensor
+    because you permuted the indices into a certain order).
+
+See also [`array`](@ref), [`vector`](@ref).
 """
 function matrix(T::ITensor)
   ndims(T) != 2 && throw(DimensionMismatch())
   return array(tensor(T))
 end
 
+"""
+    matrix(T::ITensor, inds...)
+
+Convert an ITensor `T` to a Matrix.
+
+The ordering of the elements in the Matrix are specified
+by the input indices `inds`. This tries to avoid copying
+of possible (i.e. may return a view of the original
+data), for example if the ITensor's storage is Dense
+and the indices are already in the specified ordering
+so that no permutation is required.
+
+!!! warning
+    Note that in the future we may return specialized
+    AbstractArray types for certain storage types,
+    for example a `LinearAlgebra.Diagonal` type for
+    an ITensor with `Diag` storage. The specific storage
+    type shouldn't be relied upon.
+
+See also [`array`](@ref), [`vector`](@ref).
+"""
+matrix(T::ITensor, inds...) = matrix(permute(T, inds...; allow_alias=true))
+
 """
     vector(T::ITensor)
 
 Given an ITensor `T` with one index, returns
 a Vector with a copy of the ITensor's elements,
 or a view in the case the ITensor's storage is Dense.
+
+See also [`array`](@ref), [`matrix`](@ref).
 """
 function vector(T::ITensor)
   ndims(T) != 1 && throw(DimensionMismatch())
   return array(tensor(T))
 end
+
+"""
+    vector(T::ITensor, inds...)
+
+Convert an ITensor `T` to an Vector.
+
+The ordering of the elements in the Array are specified
+by the input indices `inds`. This tries to avoid copying
+of possible (i.e. may return a view of the original
+data), for example if the ITensor's storage is Dense
+and the indices are already in the specified ordering
+so that no permutation is required.
+
+!!! warning
+    Note that in the future we may return specialized
+    AbstractArray types for certain storage types,
+    for example a `LinearAlgebra.Diagonal` type for
+    an ITensor with `Diag` storage. The specific storage
+    type shouldn't be relied upon.
+
+See also [`array`](@ref), [`matrix`](@ref).
+"""
+vector(T::ITensor, inds...) = vector(permute(T, inds...; allow_alias=true))
+
 #######################################################################
 #
 # Printing, reading and writing ITensors
diff --git a/src/mps/abstractmps.jl b/src/mps/abstractmps.jl
index efca6e3a8a..f2785e0398 100644
--- a/src/mps/abstractmps.jl
+++ b/src/mps/abstractmps.jl
@@ -16,6 +16,23 @@ size(m::AbstractMPS) = size(data(m))
 
 ndims(m::AbstractMPS) = ndims(data(m))
 
+function promote_itensor_eltype(m::Vector{ITensor})
+  T = isassigned(m, 1) ? eltype(m[1]) : Number
+  for n in 2:length(m)
+    Tn = isassigned(m, n) ? eltype(m[n]) : Number
+    T = promote_type(T, Tn)
+  end
+  return T
+end
+
+function LinearAlgebra.promote_leaf_eltypes(m::Vector{ITensor})
+  return promote_itensor_eltype(m)
+end
+
+function LinearAlgebra.promote_leaf_eltypes(m::AbstractMPS)
+  return LinearAlgebra.promote_leaf_eltypes(data(m))
+end
+
 """
     promote_itensor_eltype(m::MPS)
     promote_itensor_eltype(m::MPO)
@@ -26,16 +43,7 @@ if all tensors have type `Float64` then
 return `Float64`. But if one or more tensors
 have type `ComplexF64`, return `ComplexF64`.
 """
-promote_itensor_eltype(m::AbstractMPS) = promote_itensor_eltype(data(m))
-
-function promote_itensor_eltype(m::Vector{ITensor})
-  T = isassigned(m, 1) ? eltype(m[1]) : Number
-  for n in 2:length(m)
-    Tn = isassigned(m, n) ? eltype(m[n]) : Number
-    T = promote_type(T, Tn)
-  end
-  return T
-end
+promote_itensor_eltype(m::AbstractMPS) = LinearAlgebra.promote_leaf_eltypes(m)
 
 """
     eltype(m::MPS)
@@ -48,6 +56,15 @@ use `promote_itensor_eltype`.
 """
 eltype(::AbstractMPS) = ITensor
 
+complex(ψ::AbstractMPS) = complex.(ψ)
+real(ψ::AbstractMPS) = real.(ψ)
+imag(ψ::AbstractMPS) = imag.(ψ)
+conj(ψ::AbstractMPS) = conj.(ψ)
+
+function convert_leaf_eltype(ElType::Type, ψ::AbstractMPS)
+  return set_data(ψ, convert_leaf_eltype(ElType, data(ψ)))
+end
+
 """
     ITensors.data(::MPS/MPO)
 
@@ -58,6 +75,8 @@ know if there is functionality not available for MPS/MPO you would like.
 """
 data(m::AbstractMPS) = m.data
 
+contract(ψ::AbstractMPS) = contract(data(ψ))
+
 leftlim(m::AbstractMPS) = m.llim
 
 rightlim(m::AbstractMPS) = m.rlim
@@ -113,6 +132,10 @@ function set_ortho_lims!(ψ::AbstractMPS, r::UnitRange{Int})
   return ψ
 end
 
+function set_ortho_lims(ψ::AbstractMPS, r::UnitRange{Int})
+  return set_ortho_lims!(copy(ψ), r)
+end
+
 reset_ortho_lims!(ψ::AbstractMPS) = set_ortho_lims!(ψ, 1:length(ψ))
 
 isortho(m::AbstractMPS) = leftlim(m) + 1 == rightlim(m) - 1
@@ -950,29 +973,70 @@ end
 
 linkdims(ψ::AbstractMPS) = [linkdim(ψ, b) for b in 1:(length(ψ) - 1)]
 
-function _log_or_not_dot(
-  M1::MPST, M2::MPST, loginner::Bool; make_inds_match::Bool=true
-)::Number where {MPST<:AbstractMPS}
-  N = length(M1)
-  if length(M2) != N
-    throw(DimensionMismatch("inner: mismatched lengths $N and $(length(M2))"))
-  end
-  M1dag = dag(M1)
-  sim!(linkinds, M1dag)
+function inner_mps_mps_deprecation_warning()
+  return """
+ Calling `inner(x::MPS, y::MPS)` where the site indices of the `MPS` `x` and `y` don't match is deprecated as of ITensor v0.3 and will result in an error in ITensor v0.4. Likely you are attempting to take the inner product of MPS that have site indices with mismatched prime levels. The most common cause of this is something like the following:
+ ```julia
+ s = siteinds("S=1/2")
+ psi = randomMPS(s)
+ H = MPO(s, "Id")
+ Hpsi = contract(H, psi; cutoff=1e-8) # or `Hpsi = *(H, psi; cutoff=1e-8)`
+ inner(psi, Hpsi)
+ ```
+ `psi` has the Index structure `-s-(psi)` and `H` has the Index structure `-s'-(H)-s-`, so the contraction follows as: `-s'-(H)-s-(psi) ≈ -s'-(Hpsi)`. Then, the prime levels of `Hpsi` and `psi` don't match in `inner(psi, Hpsi)`.
+
+ There are a few ways to fix this. You can simply change:
+ ```julia
+ inner(psi, Hpsi)
+ ```
+ to:
+ ```julia
+ inner(psi', Hpsi)
+ ```
+ in which case both `psi'` and `Hpsi` have primed site indices. Alternatively, you can use the `apply` function instead of the `contract` function, which calls `contract` and unprimes the resulting MPS:
+ ```julia
+ Hpsi = apply(H, psi; cutoff=1e-8) # or `Hpsi = H(psi; cutoff=1e-8)`
+ inner(psi, Hpsi)
+ ```
+ Finally, if you only compute `Hpsi` to pass to the `inner` function, consider using:
+ ```julia
+ inner(psi', H, psi)
+ ```
+ directly which is calculated exactly and is more efficient. Alternatively, you can use:
+ ```julia
+ inner(psi, Apply(H, psi))
+ ```
+ in which case `Apply(H, psi)` represents the "lazy" evaluation of `apply(H, psi)` and internally calls something equivalent to `inner(psi', H, psi)`.
+
+ Although the new behavior seems less convenient, it makes it easier to generalize `inner(::MPS, ::MPS)` to other types of inputs, like `MPS` with different tag and prime conventions, multiple sites per tensor, `ITensor` inputs, etc.
+ """
+end
+
+# Implement below, define here so it can be used in `deprecate_make_inds_match!`.
+function _log_or_not_dot end
+
+function deprecate_make_inds_match!(
+  ::typeof(_log_or_not_dot),
+  M1dag::MPST,
+  M2::MPST,
+  loginner::Bool;
+  make_inds_match::Bool=true,
+) where {MPST<:AbstractMPS}
   siteindsM1dag = siteinds(all, M1dag)
   siteindsM2 = siteinds(all, M2)
+  N = length(M2)
   if any(n -> length(n) > 1, siteindsM1dag) ||
     any(n -> length(n) > 1, siteindsM2) ||
-    !hassamenuminds(siteinds, M1, M2)
+    !hassamenuminds(siteinds, M1dag, M2)
     # If the MPS have more than one site Indices on any site or they don't have
     # the same number of site indices on each site, don't try to make the
     # indices match
-    if !hassameinds(siteinds, M1, M2)
-      n = findfirst(n -> !hassameinds(siteinds(M1, n), siteinds(M2, n)), 1:N)
+    if !hassameinds(siteinds, M1dag, M2)
+      n = findfirst(n -> !hassameinds(siteinds(M1dag, n), siteinds(M2, n)), 1:N)
       error(
         """Calling `dot(ϕ::MPS/MPO, ψ::MPS/MPO)` with multiple site indices per MPS/MPO tensor but the site indices don't match. Even with `make_inds_match = true`, the case of multiple site indices per MPS/MPO is not handled automatically. The sites with unmatched site indices are:
 
-            inds(ϕ[$n]) = $(inds(M1[n]))
+            inds(ϕ[$n]) = $(inds(M1dag[n]))
 
             inds(ψ[$n]) = $(inds(M2[n]))
 
@@ -981,9 +1045,26 @@ function _log_or_not_dot(
     end
     make_inds_match = false
   end
-  if make_inds_match
+  if !hassameinds(siteinds, M1dag, M2) && make_inds_match
+    warn_once(inner_mps_mpo_mps_deprecation_warning(), :inner_mps_mps)
     replace_siteinds!(M1dag, siteindsM2)
   end
+  return M1dag, M2
+end
+
+function _log_or_not_dot(
+  M1::MPST, M2::MPST, loginner::Bool; make_inds_match::Bool=true
+)::Number where {MPST<:AbstractMPS}
+  N = length(M1)
+  if length(M2) != N
+    throw(DimensionMismatch("inner: mismatched lengths $N and $(length(M2))"))
+  end
+  M1dag = dag(M1)
+  sim!(linkinds, M1dag)
+  M1dag, M2 = deprecate_make_inds_match!(
+    _log_or_not_dot, M1dag, M2, loginner; make_inds_match
+  )
+  check_hascommoninds(siteinds, M1dag, M2)
   O = M1dag[1] * M2[1]
 
   if loginner
@@ -1003,67 +1084,88 @@ function _log_or_not_dot(
   end
 
   if loginner
+    if !isreal(O[]) || real(O[]) < 0
+      log_inner_tot += log(complex(O[]))
+    end
     return log_inner_tot
   end
 
   dot_M1_M2 = O[]
 
-  T = promote_type(ITensors.promote_itensor_eltype(M1), ITensors.promote_itensor_eltype(M2))
-  _max_dot_warn = inv(eps(real(float(T))))
-
-  if isnan(dot_M1_M2) || isinf(dot_M1_M2) || abs(dot_M1_M2) > _max_dot_warn
-    @warn "The inner product (or norm²) you are computing is very large: $dot_M1_M2, which is greater than $_max_dot_warn and may lead to floating point errors when used. You should consider using `lognorm` or `loginner` instead, which will help avoid floating point errors. For example if you are trying to normalize your MPS/MPO `A`, the normalized MPS/MPO `B` would be given by `B = A ./ z` where `z = exp(lognorm(A) / length(A))`."
+  if !isfinite(dot_M1_M2)
+    @warn "The inner product (or norm²) you are computing is very large ($dot_M1_M2). You should consider using `lognorm` or `loginner` instead, which will help avoid floating point errors. For example if you are trying to normalize your MPS/MPO `A`, the normalized MPS/MPO `B` would be given by `B = A ./ z` where `z = exp(lognorm(A) / length(A))`."
   end
 
   return dot_M1_M2
 end
 
 """
-    dot(A::MPS, B::MPS; make_inds_match = true)
-    inner(A::MPS, B::MPS; make_inds_match = true)
-
+    dot(A::MPS, B::MPS)
     dot(A::MPO, B::MPO)
-    inner(A::MPO, B::MPO)
-
-Compute the inner product `<A|B>`. If `A` and `B` are MPOs, computes the Frobenius inner product.
 
-If `make_inds_match = true`, the function attempts to make
-the site indices match before contracting (so for example, the
-inputs can have different site indices, as long as they
-have the same dimensions or QN blocks).
+Same as [`inner`](@ref).
 
-For now, `make_inds_match` is only supported for MPSs.
-
-See also `logdot`/`loginner`.
+See also [`loginner`](@ref), [`logdot`](@ref).
 """
 function dot(M1::MPST, M2::MPST; kwargs...) where {MPST<:AbstractMPS}
   return _log_or_not_dot(M1, M2, false; kwargs...)
 end
 
 """
-    logdot(A::MPS, B::MPS; make_inds_match = true)
-    loginner(A::MPS, B::MPS; make_inds_match = true)
-
+    logdot(A::MPS, B::MPS)
     logdot(A::MPO, B::MPO)
-    loginner(A::MPO, B::MPO)
 
-Compute the logarithm of the inner product `<A|B>`. If `A` and `B` are MPOs, computes the logarithm of the Frobenius inner product.
+Same as [`loginner`](@ref).
 
-This is useful for larger MPS/MPO, where in the limit of large numbers of sites the inner product can diverge or approach zero.
-
-If `make_inds_match = true`, the function attempts to make
-the site indices match before contracting (so for example, the
-inputs can have different site indices, as long as they
-have the same dimensions or QN blocks).
-
-For now, `make_inds_match` is only supported for MPSs.
+See also [`inner`](@ref), [`dot`](@ref).
 """
 function logdot(M1::MPST, M2::MPST; kwargs...) where {MPST<:AbstractMPS}
   return _log_or_not_dot(M1, M2, true; kwargs...)
 end
 
+function make_inds_match_docstring_warning()
+  return """
+  !!! compat "ITensors 0.3"
+    Before ITensors 0.3, `inner` had a keyword argument `make_inds_match` that default to `true`.
+    When true, the function attempted to make the site indices match before contracting. So for example, the
+    inputs could have different site indices, as long as they have the same dimensions or QN blocks.
+    This behavior was fragile since it only worked for MPS with single site indices per tensor,
+    and as of ITensors 0.3 has been deprecated. As of ITensors 0.3 you will need to make sure
+    the MPS or MPO you input have compatible site indices to contract over, such as by making
+    sure the prime levels match properly.
+  """
+end
+
+"""
+    inner(A::MPS, B::MPS)
+    inner(A::MPO, B::MPO)
+
+Compute the inner product `⟨A|B⟩`. If `A` and `B` are MPOs, computes the Frobenius inner product.
+
+Use [`loginner`](@ref) to avoid underflow/overflow for taking overlaps of large MPS or MPO.
+
+$(make_inds_match_docstring_warning())
+
+Same as [`dot`](@ref).
+
+See also [`loginner`](@ref), [`logdot`](@ref).
+"""
 inner(M1::MPST, M2::MPST; kwargs...) where {MPST<:AbstractMPS} = dot(M1, M2; kwargs...)
 
+"""
+    loginner(A::MPS, B::MPS)
+    loginner(A::MPO, B::MPO)
+
+Compute the logarithm of the inner product `⟨A|B⟩`. If `A` and `B` are MPOs, computes the logarithm of the Frobenius inner product.
+
+This is useful for larger MPS/MPO, where in the limit of large numbers of sites the inner product can diverge or approach zero.
+
+$(make_inds_match_docstring_warning())
+
+Same as [`logdot`](@ref).
+
+See also [`inner`](@ref), [`dot`](@ref).
+"""
 function loginner(M1::MPST, M2::MPST; kwargs...) where {MPST<:AbstractMPS}
   return logdot(M1, M2; kwargs...)
 end
@@ -1111,7 +1213,23 @@ function lognorm(M::AbstractMPS)
       "log(norm²) is $lognorm2_M, which is not real up to a relative tolerance of $rtol"
     )
   end
-  return 0.5 * lognorm2_M
+  return 0.5 * real(lognorm2_M)
+end
+
+function isapprox(
+  x::AbstractMPS,
+  y::AbstractMPS;
+  atol::Real=0,
+  rtol::Real=Base.rtoldefault(
+    LinearAlgebra.promote_leaf_eltypes(x), LinearAlgebra.promote_leaf_eltypes(y), atol
+  ),
+)
+  d = norm(x - y)
+  if isfinite(d)
+    return d <= max(atol, rtol * max(norm(x), norm(y)))
+  else
+    error("In `isapprox(x::MPS, y::MPS)`, `norm(x - y)` is not finite")
+  end
 end
 
 # copy an MPS/MPO, but do a deep copy of the tensors in the
@@ -1146,12 +1264,24 @@ Change the MPS or MPO `A` in-place such that `norm(A) ≈ 1`. This modifies the
 
 In practice, this evenly spreads `lognorm(A)` over the tensors within the range of the orthogonality center to avoid numerical overflow in the case of diverging norms.
 
+If the norm of the input MPS or MPO is 0, normalizing is ill-defined. In this case, we just return the original MPS or MPO. You can check for this case as follows:
+```julia
+s = siteinds("S=1/2", 4)
+ψ = 0 * randomMPS(s)
+lognorm_ψ = []
+normalize!(ψ; (lognorm!)=lognorm_ψ)
+lognorm_ψ[1] == -Inf # There was an infinite norm
+```
+
 See also [`normalize`](@ref), [`norm`](@ref), [`lognorm`](@ref).
 """
 function normalize!(M::AbstractMPS; (lognorm!)=[])
   c = ortho_lims(M)
   lognorm_M = lognorm(M)
   push!(lognorm!, lognorm_M)
+  if lognorm_M == -Inf
+    return M
+  end
   z = exp(lognorm_M / length(c))
   # XXX: this is not modifying `M` in-place.
   # M[c] ./= z
@@ -1198,12 +1328,14 @@ end
     +(A::MPS/MPO...; kwargs...)
     add(A::MPS/MPO...; kwargs...)
 
-Add arbitrary numbers of MPS/MPO with each other, with some optional
-truncation.
+Add arbitrary numbers of MPS/MPO with each other, optionally truncating the results.
 
 A cutoff of 1e-15 is used by default, and in general users should set their own cutoff for their particular application.
 
-In the future we will give an interface for returning the truncation error.
+# Keywords
+
+- `cutoff::Real`: singular value truncation cutoff
+- `maxdim::Int`: maximum MPS/MPO bond dimension
 
 # Examples
 
@@ -1246,8 +1378,14 @@ println()
       inner(ψ₃, ψ₁) + 2 * inner(ψ₃, ψ₂) + inner(ψ₃, ψ₃)
 ```
 """
-function +(ψ⃗::MPST...; cutoff=1e-15, kwargs...) where {MPST<:AbstractMPS}
-  # TODO: Check that the inputs have the same site indices
+function +(
+  ::Algorithm"densitymatrix", ψ⃗::MPST...; cutoff=1e-15, kwargs...
+) where {MPST<:AbstractMPS}
+  if !all(ψ -> hassameinds(siteinds, first(ψ⃗), ψ), ψ⃗)
+    error(
+      "In `+(::MPS/MPO...)`, the input `MPS` or `MPO` do not have the same site indices. For example, the site indices of the first site are $(siteinds.(ψ⃗, 1))",
+    )
+  end
 
   Nₘₚₛ = length(ψ⃗)
 
@@ -1310,6 +1448,46 @@ function +(ψ⃗::MPST...; cutoff=1e-15, kwargs...) where {MPST<:AbstractMPS}
   return convert(MPST, ψ)
 end
 
+function +(::Algorithm"directsum", ψ⃗::MPST...) where {MPST<:AbstractMPS}
+  n = length(first(ψ⃗))
+  @assert all(ψᵢ -> length(first(ψ⃗)) == length(ψᵢ), ψ⃗)
+
+  # Output tensor
+  ϕ = MPS(n)
+
+  # Direct sum first tensor
+  j = 1
+  l⃗j = map(ψᵢ -> linkind(ψᵢ, j), ψ⃗)
+  ϕj, (lj,) = directsum(
+    (ψ⃗[i][j] => (l⃗j[i],) for i in 1:length(ψ⃗))...; tags=[tags(first(l⃗j))]
+  )
+  ljm_prev = lj
+  ϕ[j] = ϕj
+  for j in 2:(n - 1)
+    l⃗jm = map(ψᵢ -> linkind(ψᵢ, j - 1), ψ⃗)
+    l⃗j = map(ψᵢ -> linkind(ψᵢ, j), ψ⃗)
+    ϕj, (ljm, lj) = directsum(
+      (ψ⃗[i][j] => (l⃗jm[i], l⃗j[i]) for i in 1:length(ψ⃗))...;
+      tags=[tags(first(l⃗jm)), tags(first(l⃗j))],
+    )
+    ϕj = replaceind(ϕj, ljm => dag(ljm_prev))
+    ljm_prev = lj
+    ϕ[j] = ϕj
+  end
+  j = n
+  l⃗jm = map(ψᵢ -> linkind(ψᵢ, j - 1), ψ⃗)
+  ϕj, (ljm,) = directsum(
+    (ψ⃗[i][j] => (l⃗jm[i],) for i in 1:length(ψ⃗))...; tags=[tags(first(l⃗jm))]
+  )
+  ϕj = replaceind(ϕj, ljm => dag(ljm_prev))
+  ϕ[j] = ϕj
+  return ϕ
+end
+
+function +(ψ⃗::AbstractMPS...; alg=Algorithm"densitymatrix"(), kwargs...)
+  return +(Algorithm(alg), ψ⃗...; kwargs...)
+end
+
 +(ψ::AbstractMPS) = ψ
 
 add(ψ⃗::AbstractMPS...; kwargs...) = +(ψ⃗...; kwargs...)
@@ -1325,6 +1503,11 @@ add(A::T, B::T; kwargs...) where {T<:AbstractMPS} = +(A, B; kwargs...)
 
 Add multiple MPS/MPO with each other, with some optional
 truncation.
+
+# Keywords
+
+- `cutoff::Real`: singular value truncation cutoff
+- `maxdim::Int`: maximum MPS/MPO bond dimension
 """
 function sum(ψ⃗::Vector{T}; kwargs...) where {T<:AbstractMPS}
   length(ψ⃗) == 0 && return T()
@@ -1412,7 +1595,11 @@ Perform a truncation of all bonds of an MPS/MPO,
 using the truncation parameters (cutoff,maxdim, etc.)
 provided as keyword arguments.
 """
-function truncate!(M::AbstractMPS; kwargs...)
+function truncate!(M::AbstractMPS; alg="frobenius", kwargs...)
+  return truncate!(Algorithm(alg), M; kwargs...)
+end
+
+function truncate!(::Algorithm"frobenius", M::AbstractMPS; kwargs...)
   N = length(M)
 
   # Left-orthogonalize all tensors to make
@@ -1437,7 +1624,7 @@ function truncate(ψ0::AbstractMPS; kwargs...)
   return ψ
 end
 
-# Make `*` and alias for `contract` of two `AbstractMPS`
+# Make `*` an alias for `contract` of two `AbstractMPS`
 *(A::AbstractMPS, B::AbstractMPS; kwargs...) = contract(A, B; kwargs...)
 
 function _apply_to_orthocenter!(f, ψ::AbstractMPS, x)
@@ -1473,6 +1660,8 @@ Currently, this works by scaling one of the sites within the orthogonality limit
 
 -(ψ::AbstractMPS) = -1 * ψ
 
+LinearAlgebra.rmul!(ψ::AbstractMPS, α::Number) = _apply_to_orthocenter!(*, ψ, α)
+
 """
     setindex!(::Union{MPS, MPO}, ::Union{MPS, MPO},
               r::UnitRange{Int64})
@@ -1957,13 +2146,17 @@ expτH = ops(os, s)
 ```
 """
 function product(
-  As::Vector{<:ITensor}, ψ::AbstractMPS; move_sites_back::Bool=true, kwargs...
+  As::Vector{ITensor},
+  ψ::AbstractMPS;
+  move_sites_back_between_gates::Bool=true,
+  move_sites_back::Bool=true,
+  kwargs...,
 )
   Aψ = ψ
   for A in As
-    Aψ = product(A, Aψ; move_sites_back=false, kwargs...)
+    Aψ = product(A, Aψ; move_sites_back=move_sites_back_between_gates, kwargs...)
   end
-  if move_sites_back
+  if !move_sites_back_between_gates && move_sites_back
     s = siteinds(Aψ)
     ns = 1:length(ψ)
     ñs = [findsite(ψ, i) for i in s]
@@ -1972,6 +2165,27 @@ function product(
   return Aψ
 end
 
+# Apply in the reverse order for proper order of operations
+# For example:
+#
+# s = siteinds("Qubit", 1)
+# ψ = randomMPS(s)
+#
+# # U = Z₁X₁
+# U = Prod{Op}()
+# U = ("X", 1) * U
+# U = ("Z", 1) * U
+#
+# # U|ψ⟩ = Z₁X₁|ψ⟩
+# apply(U, 
+function product(o::Prod{ITensor}, ψ::AbstractMPS; kwargs...)
+  return product(reverse(terms(o)), ψ; kwargs...)
+end
+
+function (o::Prod{ITensor})(ψ::AbstractMPS; kwargs...)
+  return apply(o, ψ; kwargs...)
+end
+
 #
 # QN functions
 #
@@ -2048,6 +2262,11 @@ function splitblocks(::typeof(linkinds), M::AbstractMPS; tol=0)
   return splitblocks!(linkinds, copy(M); tol=0)
 end
 
+removeqns(M::AbstractMPS) = map(removeqns, M; set_limits=false)
+function removeqn(M::AbstractMPS, qn_name::String)
+  return map(m -> removeqn(m, qn_name), M; set_limits=false)
+end
+
 #
 # Broadcasting
 #
diff --git a/src/mps/abstractprojmpo.jl b/src/mps/abstractprojmpo.jl
index b1d8abbe7b..eceb91b469 100644
--- a/src/mps/abstractprojmpo.jl
+++ b/src/mps/abstractprojmpo.jl
@@ -5,8 +5,12 @@ struct OneITensor end
 (::OneITensor * A::ITensor) = A
 (A::ITensor * ::OneITensor) = A
 
+inds(::OneITensor) = ()
+
 abstract type AbstractProjMPO end
 
+copy(::AbstractProjMPO) = error("Not implemented")
+
 # This is to help with generic promote_type code
 # in eltype(::AbstractProjMPO)
 eltype(::OneITensor) = Bool
@@ -22,6 +26,8 @@ site indices of the ProjMPO object `P`
 """
 nsite(P::AbstractProjMPO) = P.nsite
 
+set_nsite!(::AbstractProjMPO, nsite) = error("Not implemented")
+
 # The range of center sites
 site_range(P::AbstractProjMPO) = (P.lpos + 1):(P.rpos - 1)
 
@@ -43,21 +49,7 @@ function rproj(P::AbstractProjMPO)::Union{ITensor,OneITensor}
   return P.LR[P.rpos]
 end
 
-"""
-    product(P::ProjMPO,v::ITensor)::ITensor
-
-    (P::ProjMPO)(v::ITensor)
-
-Efficiently multiply the ProjMPO `P`
-by an ITensor `v` in the sense that the
-ProjMPO is a generalized square matrix
-or linear operator and `v` is a generalized
-vector in the space where it acts. The
-returned ITensor will have the same indices
-as `v`. The operator overload `P(v)` is
-shorthand for `product(P,v)`.
-"""
-function product(P::AbstractProjMPO, v::ITensor)::ITensor
+function contract(P::AbstractProjMPO, v::ITensor)::ITensor
   itensor_map = Union{ITensor,OneITensor}[lproj(P)]
   append!(itensor_map, P.H[site_range(P)])
   push!(itensor_map, rproj(P))
@@ -74,21 +66,38 @@ function product(P::AbstractProjMPO, v::ITensor)::ITensor
   for it in itensor_map
     Hv *= it
   end
+  return Hv
+end
 
-  if order(Hv) != order(v)
+"""
+    product(P::ProjMPO,v::ITensor)::ITensor
+
+    (P::ProjMPO)(v::ITensor)
+
+Efficiently multiply the ProjMPO `P`
+by an ITensor `v` in the sense that the
+ProjMPO is a generalized square matrix
+or linear operator and `v` is a generalized
+vector in the space where it acts. The
+returned ITensor will have the same indices
+as `v`. The operator overload `P(v)` is
+shorthand for `product(P,v)`.
+"""
+function product(P::AbstractProjMPO, v::ITensor)::ITensor
+  Pv = contract(P, v)
+  if order(Pv) != order(v)
     error(
       string(
         "The order of the ProjMPO-ITensor product P*v is not equal to the order of the ITensor v, ",
         "this is probably due to an index mismatch.\nCommon reasons for this error: \n",
         "(1) You are trying to multiply the ProjMPO with the $(nsite(P))-site wave-function at the wrong position.\n",
-        "(2) `orthognalize!` was called, changing the MPS without updating the ProjMPO.\n\n",
-        "P*v inds: $(inds(Hv)) \n\n",
+        "(2) `orthogonalize!` was called, changing the MPS without updating the ProjMPO.\n\n",
+        "P*v inds: $(inds(Pv)) \n\n",
         "v inds: $(inds(v))",
       ),
     )
   end
-
-  return noprime(Hv)
+  return noprime(Pv)
 end
 
 (P::AbstractProjMPO)(v::ITensor) = product(P, v)
diff --git a/src/mps/diskprojmpo.jl b/src/mps/diskprojmpo.jl
index 109543b2d0..c20aeeb1fb 100644
--- a/src/mps/diskprojmpo.jl
+++ b/src/mps/diskprojmpo.jl
@@ -33,6 +33,25 @@ mutable struct DiskProjMPO <: AbstractProjMPO
   rposcache::Union{Int,Nothing}
 end
 
+function copy(P::DiskProjMPO)
+  return DiskProjMPO(
+    P.lpos,
+    P.rpos,
+    P.nsite,
+    copy(P.H),
+    copy(P.LR),
+    P.Lcache,
+    P.lposcache,
+    P.Rcache,
+    P.rposcache,
+  )
+end
+
+function set_nsite!(P::DiskProjMPO, nsite)
+  P.nsite = nsite
+  return P
+end
+
 function DiskProjMPO(H::MPO)
   return new(
     0,
diff --git a/src/mps/dmrg.jl b/src/mps/dmrg.jl
index 91ead4305a..bb1b108c67 100644
--- a/src/mps/dmrg.jl
+++ b/src/mps/dmrg.jl
@@ -29,7 +29,7 @@ and the `sweeps` object determines the parameters used to
 control the DMRG algorithm.
 
 Returns:
-* `energy::Float64` - eigenvalue of the optimized MPS
+* `energy::Complex` - eigenvalue of the optimized MPS
 * `psi::MPS` - optimized MPS
 
 Optional keyword arguments:
@@ -37,7 +37,7 @@ Optional keyword arguments:
 * `observer` - object implementing the [Observer](@ref observer) interface which can perform measurements and stop DMRG early
 * `write_when_maxdim_exceeds::Int` - when the allowed maxdim exceeds this value, begin saving tensors to disk to free memory in large calculations
 """
-function dmrg(H::MPO, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
+function dmrg(H::MPO, psi0::MPS, sweeps::Sweeps; kwargs...)
   check_hascommoninds(siteinds, H, psi0)
   check_hascommoninds(siteinds, H, psi0')
   # Permute the indices to have a better memory layout
@@ -65,10 +65,10 @@ the set of MPOs [H1,H2,H3,..] is efficiently looped over at
 each step of the DMRG algorithm when optimizing the MPS.
 
 Returns:
-* `energy::Float64` - eigenvalue of the optimized MPS
+* `energy::Complex` - eigenvalue of the optimized MPS
 * `psi::MPS` - optimized MPS
 """
-function dmrg(Hs::Vector{MPO}, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
+function dmrg(Hs::Vector{MPO}, psi0::MPS, sweeps::Sweeps; kwargs...)
   for H in Hs
     check_hascommoninds(siteinds, H, psi0)
     check_hascommoninds(siteinds, H, psi0')
@@ -95,12 +95,10 @@ and the `sweeps` object determines the parameters used to
 control the DMRG algorithm.
 
 Returns:
-* `energy::Float64` - eigenvalue of the optimized MPS
+* `energy::Complex` - eigenvalue of the optimized MPS
 * `psi::MPS` - optimized MPS
 """
-function dmrg(
-  H::MPO, Ms::Vector{MPS}, psi0::MPS, sweeps::Sweeps; kwargs...
-)::Tuple{Number,MPS}
+function dmrg(H::MPO, Ms::Vector{MPS}, psi0::MPS, sweeps::Sweeps; kwargs...)
   check_hascommoninds(siteinds, H, psi0)
   check_hascommoninds(siteinds, H, psi0')
   for M in Ms
@@ -113,7 +111,7 @@ function dmrg(
   return dmrg(PMM, psi0, sweeps; kwargs...)
 end
 
-function dmrg(PH, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
+function dmrg(PH, psi0::MPS, sweeps::Sweeps; kwargs...)
   if length(psi0) == 1
     error(
       "`dmrg` currently does not support system sizes of 1. You can diagonalize the MPO tensor directly with tools like `LinearAlgebra.eigen`, `KrylovKit.eigsolve`, etc.",
@@ -137,7 +135,7 @@ function dmrg(PH, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
   )
 
   # eigsolve kwargs
-  eigsolve_tol::Float64 = get(kwargs, :eigsolve_tol, 1e-14)
+  eigsolve_tol::Number = get(kwargs, :eigsolve_tol, 1e-14)
   eigsolve_krylovdim::Int = get(kwargs, :eigsolve_krylovdim, 3)
   eigsolve_maxiter::Int = get(kwargs, :eigsolve_maxiter, 1)
   eigsolve_verbosity::Int = get(kwargs, :eigsolve_verbosity, 0)
@@ -229,7 +227,8 @@ function dmrg(PH, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
             maxiter=eigsolve_maxiter,
           )
         end
-        energy::Number = vals[1]
+
+        energy = vals[1]
         phi::ITensor = vecs[1]
 
         ortho = ha == 1 ? "left" : "right"
@@ -269,9 +268,7 @@ function dmrg(PH, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
         end
 
         if outputlevel >= 2
-          @printf(
-            "Sweep %d, half %d, bond (%d,%d) energy=%.12f\n", sw, ha, b, b + 1, energy
-          )
+          @printf("Sweep %d, half %d, bond (%d,%d) energy=%s\n", sw, ha, b, b + 1, energy)
           @printf(
             "  Truncated using cutoff=%.1E maxdim=%d mindim=%d\n",
             cutoff(sweeps, sw),
@@ -300,7 +297,7 @@ function dmrg(PH, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
     end
     if outputlevel >= 1
       @printf(
-        "After sweep %d energy=%.12f maxlinkdim=%d maxerr=%.2E time=%.3f\n",
+        "After sweep %d energy=%s  maxlinkdim=%d maxerr=%.2E time=%.3f\n",
         sw,
         energy,
         maxlinkdim(psi),
@@ -310,7 +307,6 @@ function dmrg(PH, psi0::MPS, sweeps::Sweeps; kwargs...)::Tuple{Number,MPS}
       flush(stdout)
     end
     isdone = checkdone!(obs; energy=energy, psi=psi, sweep=sw, outputlevel=outputlevel)
-
     isdone && break
   end
   return (energy, psi)
diff --git a/src/mps/mpo.jl b/src/mps/mpo.jl
index 3e4082a076..c7cf5faaad 100644
--- a/src/mps/mpo.jl
+++ b/src/mps/mpo.jl
@@ -15,6 +15,8 @@ function MPO(A::Vector{<:ITensor}; ortho_lims::UnitRange=1:length(A))
   return MPO(A, first(ortho_lims) - 1, last(ortho_lims) + 1)
 end
 
+set_data(A::MPO, data::Vector{ITensor}) = MPO(data, A.llim, A.rlim)
+
 MPO() = MPO(ITensor[], 0, 0)
 
 function convert(::Type{MPS}, M::MPO)
@@ -64,10 +66,13 @@ MPO(N::Int) = MPO(Vector{ITensor}(undef, N))
 Make an MPO with pairs of sites `s[i]` and `s[i]'`
 and operators `ops` on each site.
 """
-function MPO(::Type{ElT}, sites::Vector{<:Index}, ops::Vector{String}) where {ElT<:Number}
+function MPO(::Type{ElT}, sites::Vector{<:Index}, ops::Vector) where {ElT<:Number}
   N = length(sites)
-  ampo = OpSum() + [ops[n] => n for n in 1:N]
-  M = MPO(ampo, sites)
+  os = Prod{Op}()
+  for n in 1:N
+    os *= Op(ops[n], n)
+  end
+  M = MPO(os, sites)
 
   # Currently, OpSum does not output the optimally truncated
   # MPO (see https://github.com/ITensor/ITensors.jl/issues/526)
@@ -99,6 +104,15 @@ end
 
 MPO(sites::Vector{<:Index}, op::String) = MPO(Float64, sites, op)
 
+function MPO(::Type{ElT}, sites::Vector{<:Index}, op::Matrix{<:Number}) where {ElT<:Number}
+  # return MPO(ElT, sites, fill(op, length(sites)))
+  return error(
+    "Not defined on purpose because of potential ambiguity with `MPO(A::Array, sites::Vector)`. Pass the on-site matrices as functions like `MPO(sites, n -> [1 0; 0 1])` instead.",
+  )
+end
+
+MPO(sites::Vector{<:Index}, op::Matrix{ElT}) where {ElT<:Number} = MPO(ElT, sites, op)
+
 function randomMPO(sites::Vector{<:Index}, m::Int=1)
   M = MPO(sites, "Id")
   for i in eachindex(sites)
@@ -113,24 +127,65 @@ function MPO(A::ITensor, sites::Vector{<:Index}; kwargs...)
   return MPO(A, IndexSet.(prime.(sites), dag.(sites)); kwargs...)
 end
 
+function outer_mps_mps_deprecation_warning()
+  return "Calling `outer(ψ::MPS, ϕ::MPS)` for MPS `ψ` and `ϕ` with shared indices is deprecated. Currently, we automatically prime `ψ` to make sure the site indices don't clash, but that will no longer be the case in ITensors v0.4. To upgrade your code, call `outer(ψ', ϕ)`. Although the new interface seems less convenient, it will allow `outer` to accept more general outer products going forward, such as outer products where some indices are shared (a batched outer product) or outer products of MPS between site indices that aren't just related by a single prime level."
+end
+
+function deprecate_make_inds_unmatch(::typeof(outer), ψ::MPS, ϕ::MPS; kw...)
+  if hassameinds(siteinds, ψ, ϕ)
+    warn_once(outer_mps_mps_deprecation_warning(), :outer_mps_mps)
+    ψ = ψ'
+  end
+  return ψ, ϕ
+end
+
 """
     outer(x::MPS, y::MPS; <keyword argument>) -> MPO
 
 Compute the outer product of `MPS` `x` and `MPS` `y`,
-returning an `MPO` approximation.
-
-Note that `y` will be conjugated, and the site indices
-of `x` will be primed.
+returning an `MPO` approximation. Note that `y` will be conjugated.
 
 In Dirac notation, this is the operation `|x⟩⟨y|`.
 
+If you want an outer product of an MPS with itself, you should
+call `outer(x', x; kwargs...)` so that the resulting MPO
+has site indices with indices coming in pairs of prime levels
+of 1 and 0. If not, the site indices won't be unique which would
+not be an outer product.
+
+For example:
+```julia
+s = siteinds("S=1/2", 5)
+x = randomMPS(s)
+y = randomMPS(s)
+outer(x, y) # Incorrect! Site indices must be unique.
+outer(x', y) # Results in an MPO with pairs of primed and unprimed indices.
+```
+This allows for more general outer products, such as more general
+MPO outputs which don't have pairs of primed and unprimed indices,
+or outer products where the input MPS are vectorizations of MPOs.
+
+For example:
+```julia
+s = siteinds("S=1/2", 5)
+X = MPO(s, "Id")
+Y = MPO(s, "Id")
+x = convert(MPS, X)
+y = convert(MPS, Y)
+outer(x, y) # Incorrect! Site indices must be unique.
+outer(x', y) # Incorrect! Site indices must be unique.
+outer(addtags(x, "Out"), addtags(y, "In")) # This performs a proper outer product.
+```
+
 The keyword arguments determine the truncation, and accept
-the same arguments as `contract(::MPO, ::MPO; kw...)`.
+the same arguments as `contract(::MPO, ::MPO; kwargs...)`.
 
-See also [`product`](@ref), [`contract`](@ref).
+See also [`apply`](@ref), [`contract`](@ref).
 """
 function outer(ψ::MPS, ϕ::MPS; kw...)
-  ψmat = convert(MPO, ψ')
+  ψ, ϕ = deprecate_make_inds_unmatch(outer, ψ, ϕ; kw...)
+
+  ψmat = convert(MPO, ψ)
   ϕmat = convert(MPO, dag(ϕ))
   return contract(ψmat, ϕmat; kw...)
 end
@@ -150,7 +205,7 @@ the same as those accepted by `contract(::MPO, ::MPO; kw...)`.
 See also [`outer`](@ref), [`contract`](@ref).
 """
 function projector(ψ::MPS; normalize::Bool=true, kw...)
-  ψψᴴ = outer(ψ, ψ; kw...)
+  ψψᴴ = outer(ψ', ψ; kw...)
   if normalize
     normalize!(ψψᴴ[orthocenter(ψψᴴ)])
   end
@@ -208,33 +263,49 @@ function hassameinds(::typeof(siteinds), ψ::MPS, Hϕ::Tuple{MPO,MPS})
   return true
 end
 
-"""
-    dot(y::MPS, A::MPO, x::MPS; make_inds_match::Bool = true)
-    inner(y::MPS, A::MPO, x::MPS; make_inds_match::Bool = true)
-
-Compute `<y|A|x> = <y|Ax>.
-
-If `make_inds_match = true`, the function attempts to make
-the site indices of `A*x` match with the site indices of `y`
-before contracting (so for example, the inputs `y` and `A*x` 
-can have different site indices, as long as they have the same 
-dimensions or QN blocks).
+function inner_mps_mpo_mps_deprecation_warning()
+  return """
+ Calling `inner(x::MPS, A::MPO, y::MPS)` where the site indices of the `MPS` `x` and the `MPS` resulting from contracting `MPO` `A` with `MPS` `y` don't match is deprecated as of ITensors v0.3 and will result in an error in ITensors v0.4. The most common cause of this is something like the following:
+ ```julia
+ s = siteinds("S=1/2")
+ psi = randomMPS(s)
+ H = MPO(s, "Id")
+ inner(psi, H, psi)
+ ```
+ `psi` has the Index structure `-s-(psi)` and `H` has the Index structure `-s'-(H)-s-`, so the Index structure of would be `(dag(psi)-s- -s'-(H)-s-(psi)` unless the prime levels were fixed. Previously we tried fixing the prime level in situations like this, but we will no longer be doing that going forward.
+
+ There are a few ways to fix this. You can simply change:
+ ```julia
+ inner(psi, H, psi)
+ ```
+ to:
+ ```julia
+ inner(psi', H, psi)
+ ```
+ in which case the Index structure will be `(dag(psi)-s'-(H)-s-(psi)`.
+
+ Alternatively, you can use the `Apply` function:
+ ```julia
+ inner(psi, Apply(H, psi))
+ ```
+ In this case, `Apply(H, psi)` represents the "lazy" evaluation of `apply(H, psi)`. The function `apply(H, psi)` performs the contraction of `H` with `psi` and then unprimes the results, so this versions ensures that the prime levels of the inner product will match.
+
+ Although the new behavior seems less convenient, it makes it easier to generalize `inner(::MPS, ::MPO, ::MPS)` to other types of inputs, like `MPS` and `MPO` with different tag and prime conventions, multiple sites per tensor, `ITensor` inputs, etc.
+ """
+end
 
-`A` and `x` must have common site indices.
-"""
-function dot(y::MPS, A::MPO, x::MPS; make_inds_match::Bool=true, kwargs...)::Number
-  N = length(A)
-  check_hascommoninds(siteinds, A, x)
-  ydag = dag(y)
-  sim!(linkinds, ydag)
-  if !hassameinds(siteinds, y, (A, x))
+function deprecate_make_inds_match!(
+  ::typeof(dot), ydag::MPS, A::MPO, x::MPS; make_inds_match::Bool=true
+)
+  N = length(x)
+  if !hassameinds(siteinds, ydag, (A, x))
     sAx = siteinds((A, x))
     if any(s -> length(s) > 1, sAx)
-      n = findfirst(n -> !hassameinds(siteinds(y, n), siteinds((A, x), n)), 1:N)
+      n = findfirst(n -> !hassameinds(siteinds(ydag, n), siteinds((A, x), n)), 1:N)
       error(
         """Calling `dot(ϕ::MPS, H::MPO, ψ::MPS)` with multiple site indices per MPO/MPS tensor but the site indices don't match. Even with `make_inds_match = true`, the case of multiple site indices per MPO/MPS is not handled automatically. The sites with unmatched site indices are:
 
-            inds(ϕ[$n]) = $(inds(y[n]))
+            inds(ϕ[$n]) = $(inds(ydag[n]))
 
             inds(H[$n]) = $(inds(A[n]))
 
@@ -243,10 +314,25 @@ function dot(y::MPS, A::MPO, x::MPS; make_inds_match::Bool=true, kwargs...)::Num
         Make sure the site indices of your MPO/MPS match. You may need to prime one of the MPS, such as `dot(ϕ', H, ψ)`.""",
       )
     end
-    if make_inds_match
+    if !hassameinds(siteinds, ydag, (A, x)) && make_inds_match
+      warn_once(inner_mps_mpo_mps_deprecation_warning(), :inner_mps_mpo_mps)
       replace_siteinds!(ydag, sAx)
     end
   end
+  return ydag, A, x
+end
+
+"""
+    dot(y::MPS, A::MPO, x::MPS)
+
+Same as [`inner`](@ref).
+"""
+function dot(y::MPS, A::MPO, x::MPS; make_inds_match::Bool=true, kwargs...)::Number
+  N = length(A)
+  check_hascommoninds(siteinds, A, x)
+  ydag = dag(y)
+  sim!(linkinds, ydag)
+  ydag, A, x = deprecate_make_inds_match!(dot, ydag, A, x; make_inds_match)
   check_hascommoninds(siteinds, A, y)
   O = ydag[1] * A[1] * x[1]
   for j in 2:N
@@ -255,22 +341,40 @@ function dot(y::MPS, A::MPO, x::MPS; make_inds_match::Bool=true, kwargs...)::Num
   return O[]
 end
 
-inner(y::MPS, A::MPO, x::MPS; kwargs...) = dot(y, A, x; kwargs...)
+"""
+    inner(y::MPS, A::MPO, x::MPS)
+
+Compute `⟨y|A|x⟩ = ⟨y|Ax⟩` efficiently and exactly without making any intermediate
+MPOs. In general it is more efficient and accurate than `inner(y, apply(A, x))`.
+
+This is helpful for computing the expectation value of an operator `A`, which would be:
+```julia
+inner(x, A, x)
+```
+assuming `x` is normalized.
+
+If you want to compute `⟨By|Ax⟩` you can use `inner(B::MPO, y::MPS, A::MPO, x::MPS)`.
 
+This is helpful for computing the variance of an operator `A`, which would be:
+```julia
+inner(A, x, A, x) - inner(x, A, x) ^ 2
+```
+assuming `x` is normalized.
+
+$(make_inds_match_docstring_warning())
+
+Same as [`dot`](@ref).
 """
-    dot(B::MPO, y::MPS, A::MPO, x::MPS; make_inds_match::Bool = true)
-    inner(B::MPO, y::MPS, A::MPO, x::MPS; make_inds_match::Bool = true)
+inner(y::MPS, A::MPO, x::MPS; kwargs...) = dot(y, A, x; kwargs...)
 
-Compute `<By|A|x> = <By|Ax>`.
+function inner(y::MPS, Ax::Apply{Tuple{MPO,MPS}})
+  return inner(y', Ax.args[1], Ax.args[2])
+end
 
-If `make_inds_match = true`, the function attempts to make
-the site indices of `A*x` match with the site indices of `B*y`
-before contracting (so for example, the inputs `B*y` and `A*x`
-can have different site indices, as long as they have the same
-dimensions or QN blocks).
+"""
+    dot(B::MPO, y::MPS, A::MPO, x::MPS)
 
-`A` and `x` must have common site indices, and `B` and `y`
-must have common site indices.
+Same as [`inner`](@ref).
 """
 function dot(B::MPO, y::MPS, A::MPO, x::MPS; make_inds_match::Bool=true, kwargs...)::Number
   !make_inds_match && error(
@@ -312,6 +416,21 @@ end
 # TODO: maybe make these into tuple inputs?
 # Also can generalize to:
 # inner((β, B, y), (α, A, x))
+"""
+    inner(B::MPO, y::MPS, A::MPO, x::MPS)
+
+Compute `⟨By|A|x⟩ = ⟨By|Ax⟩` efficiently and exactly without making any intermediate
+MPOs. In general it is more efficient and accurate than `inner(apply(B, y), apply(A, x))`.
+
+This is helpful for computing the variance of an operator `A`, which would be:
+```julia
+inner(A, x, A, x) - inner(x, A, x) ^ 2
+```
+
+$(make_inds_match_docstring_warning())
+
+Same as [`dot`](@ref).
+"""
 inner(B::MPO, y::MPS, A::MPO, x::MPS) = dot(B, y, A, x)
 
 function dot(M1::MPO, M2::MPO; make_inds_match::Bool=false, kwargs...)
@@ -321,7 +440,7 @@ function dot(M1::MPO, M2::MPO; make_inds_match::Bool=false, kwargs...)
   return _log_or_not_dot(M1, M2, false; make_inds_match=make_inds_match)
 end
 
-# TODO: implement by combing the MPO indices and converting
+# TODO: implement by combining the MPO indices and converting
 # to MPS
 function logdot(M1::MPO, M2::MPO; make_inds_match::Bool=false, kwargs...)
   if make_inds_match
@@ -370,35 +489,49 @@ function error_contract(y::MPS, A::MPO, x::MPS; kwargs...)
     )
   end
   iyy = dot(y, y; kwargs...)
-  iyax = dot(y, A, x; kwargs...)
+  iyax = dot(y', A, x; kwargs...)
   iaxax = dot(A, x, A, x; kwargs...)
   return sqrt(abs(1.0 + (iyy - 2 * real(iyax)) / iaxax))
 end
 
 error_contract(y::MPS, x::MPS, A::MPO) = error_contract(y, A, x)
 
-function contract(A::MPO, ψ::MPS; kwargs...)
-  method = get(kwargs, :method, "densitymatrix")
+"""
+    apply(A::MPO, x::MPS; kwargs...)
+
+Contract the `MPO` `A` with the `MPS` `x` and then map the prime level of the resulting
+MPS back to 0.
+
+Equivalent to `replaceprime(contract(A, x; kwargs...), 2 => 1)`.
+
+See also [`contract`](@ref) for details about the arguments available.
+"""
+function apply(A::MPO, ψ::MPS; kwargs...)
+  Aψ = contract(A, ψ; kwargs...)
+  return replaceprime(Aψ, 1 => 0)
+end
+
+(A::MPO)(ψ::MPS; kwargs...) = apply(A, ψ; kwargs...)
+
+Apply(A::MPO, ψ::MPS; kwargs...) = Applied(apply, (A, ψ), NamedTuple(kwargs))
+
+function contract(A::MPO, ψ::MPS; alg="densitymatrix", kwargs...)
+  if haskey(kwargs, :method)
+    # Backwards compatibility, use `method`.
+    alg = get(kwargs, :method, "densitymatrix")
+  end
 
   # Keyword argument deprecations
-  if method == "DensityMatrix"
+  if alg == "DensityMatrix"
     @warn "In contract, method DensityMatrix is deprecated in favor of densitymatrix"
-    method = "densitymatrix"
+    alg = "densitymatrix"
   end
-
-  if method == "Naive"
-    @warn "In contract, method Naive is deprecated in favor of naive"
-    method = "naive"
+  if alg == "Naive"
+    @warn "In contract, `alg=\"Naive\"` is deprecated in favor of `alg=\"naive\"`"
+    alg = "naive"
   end
 
-  if method == "densitymatrix"
-    Aψ = _contract_densitymatrix(A, ψ; kwargs...)
-  elseif method == "naive"
-    Aψ = _contract_naive(A, ψ; kwargs...)
-  else
-    throw(ArgumentError("Method $method not supported"))
-  end
-  return Aψ
+  return contract(Algorithm(alg), A, ψ; kwargs...)
 end
 
 contract_mpo_mps_doc = """
@@ -411,6 +544,18 @@ contract_mpo_mps_doc = """
 Contract the `MPO` `A` with the `MPS` `ψ`, returning an `MPS` with the unique
 site indices of the `MPO`.
 
+For example, for an MPO with site indices with prime levels of 1 and 0, such as
+`-s'-A-s-`, and an MPS with site indices with prime levels of 0, such as
+`-s-x`, the result is an MPS `y` with site indices with prime levels of 1,
+`-s'-y = -s'-A-s-x`.
+
+Since it is common to contract an MPO with prime levels of 1 and 0 with an MPS with
+prime level of 0 and want a resulting MPS with prime levels of 0, we provide a
+convenience function `apply`:
+```julia
+apply(A, x; kwargs...) = replaceprime(contract(A, x; kwargs...), 2 => 1)`.
+```
+
 Choose the method with the `method` keyword, for example
 `"densitymatrix"` and `"naive"`.
 
@@ -419,7 +564,9 @@ Choose the method with the `method` keyword, for example
 - `maxdim::Int=maxlinkdim(A) * maxlinkdim(ψ))`: the maximal bond dimension of the results MPS.
 - `mindim::Int=1`: the minimal bond dimension of the resulting MPS.
 - `normalize::Bool=false`: whether or not to normalize the resulting MPS.
-- `method::String="densitymatrix"`: the algorithm to use for the contraction.
+- `method::String="densitymatrix"`: the algorithm to use for the contraction. Currently the options are "densitymatrix", where the network formed by the MPO and MPS is squared and contracted down to a density matrix which is diagonalized iteratively at each site, and "naive", where the MPO and MPS tensor are contracted exactly at each site and then a truncation of the resulting MPS is performed.
+
+See also [`apply`](@ref).
 """
 
 @doc """
@@ -439,7 +586,7 @@ contract(ψ::MPS, A::MPO; kwargs...) = contract(A, ψ; kwargs...)
 
 #@doc (@doc contract(::MPO, ::MPS)) *(::MPO, ::MPS)
 
-function _contract_densitymatrix(A::MPO, ψ::MPS; kwargs...)::MPS
+function contract(::Algorithm"densitymatrix", A::MPO, ψ::MPS; kwargs...)::MPS
   n = length(A)
   n != length(ψ) &&
     throw(DimensionMismatch("lengths of MPO ($n) and MPS ($(length(ψ))) do not match"))
@@ -520,9 +667,12 @@ function _contract_densitymatrix(A::MPO, ψ::MPS; kwargs...)::MPS
   return ψ_out
 end
 
-function _contract_naive(A::MPO, ψ::MPS; kwargs...)::MPS
+function _contract(::Algorithm"naive", A, ψ; kwargs...)
   truncate = get(kwargs, :truncate, true)
 
+  A = sim(linkinds, A)
+  ψ = sim(linkinds, ψ)
+
   N = length(A)
   if N != length(ψ)
     throw(DimensionMismatch("lengths of MPO ($N) and MPS ($(length(ψ))) do not match"))
@@ -534,11 +684,14 @@ function _contract_naive(A::MPO, ψ::MPS; kwargs...)::MPS
   end
 
   for b in 1:(N - 1)
-    Al = commonind(A[b], A[b + 1])
-    pl = commonind(ψ[b], ψ[b + 1])
-    C = combiner(Al, pl)
-    ψ_out[b] *= C
-    ψ_out[b + 1] *= dag(C)
+    Al = commoninds(A[b], A[b + 1])
+    ψl = commoninds(ψ[b], ψ[b + 1])
+    l = [Al..., ψl...]
+    if !isempty(l)
+      C = combiner(l)
+      ψ_out[b] *= C
+      ψ_out[b + 1] *= dag(C)
+    end
   end
 
   if truncate
@@ -548,7 +701,24 @@ function _contract_naive(A::MPO, ψ::MPS; kwargs...)::MPS
   return ψ_out
 end
 
-function contract(A::MPO, B::MPO; kwargs...)
+function contract(alg::Algorithm"naive", A::MPO, ψ::MPS; kwargs...)
+  return _contract(alg, A, ψ; kwargs...)
+end
+
+function contract(A::MPO, B::MPO; alg="zipup", kwargs...)
+  return contract(Algorithm(alg), A, B; kwargs...)
+end
+
+function contract(alg::Algorithm"naive", A::MPO, B::MPO; kwargs...)
+  return _contract(alg, A, B; kwargs...)
+end
+
+function contract(::Algorithm"zipup", A::MPO, B::MPO; kwargs...)
+  if hassameinds(siteinds, A, B)
+    error(
+      "In `contract(A::MPO, B::MPO)`, MPOs A and B have the same site indices. The indices of the MPOs in the contraction are taken literally, and therefore they should only share one site index per site so the contraction results in an MPO. You may want to use `replaceprime(contract(A', B), 2 => 1)` or `apply(A, B)` which automatically adjusts the prime levels assuming the input MPOs have pairs of primed and unprimed indices.",
+    )
+  end
   cutoff::Float64 = get(kwargs, :cutoff, 1e-14)
   resp_degen::Bool = get(kwargs, :respect_degenerate, true)
   maxdim::Int = get(kwargs, :maxdim, maxlinkdim(A) * maxlinkdim(B))
@@ -598,6 +768,27 @@ function contract(A::MPO, B::MPO; kwargs...)
   return C
 end
 
+"""
+    apply(A::MPO, B::MPO; kwargs...)
+
+Contract the `MPO` `A'` with the `MPO` `B` and then map the prime level of the resulting
+MPO back to having pairs of indices with prime levels of 1 and 0.
+
+Equivalent to `replaceprime(contract(A', B; kwargs...), 2 => 1)`.
+
+See also [`contract`](@ref) for details about the arguments available.
+"""
+function apply(A::MPO, B::MPO; kwargs...)
+  AB = contract(A', B; kwargs...)
+  return replaceprime(AB, 2 => 1)
+end
+
+function apply(A1::MPO, A2::MPO, A3::MPO, As::MPO...; kwargs...)
+  return apply(apply(A1, A2; kwargs...), A3, As...; kwargs...)
+end
+
+(A::MPO)(B::MPO; kwargs...) = apply(A, B; kwargs...)
+
 contract_mpo_mpo_doc = """
     contract(A::MPO, B::MPO; kwargs...) -> MPO
     *(::MPO, ::MPO; kwargs...) -> MPO
@@ -605,10 +796,42 @@ contract_mpo_mpo_doc = """
 Contract the `MPO` `A` with the `MPO` `B`, returning an `MPO` with the 
 site indices that are not shared between `A` and `B`.
 
+If you are contracting two MPOs with the same sets of indices, likely you
+want to call something like:
+```julia
+C = contract(A', B; cutoff=1e-12)
+C = replaceprime(C, 2 => 1)
+```
+That is because if MPO `A` has the index structure `-s'-A-s-` and MPO `B`
+has the Index structure `-s'-B-s-`, if we only want to contract over
+on set of the indices, we would do `(-s'-A-s-)'-s'-B-s- = -s''-A-s'-s'-B-s- = -s''-C-s-`,
+and then map the prime levels back to pairs of primed and unprimed indices with:
+`replaceprime(-s''-C-s-, 2 => 1) = -s'-C-s-`.
+
+Since this is a common use case, you can use the convenience function:
+```julia
+C = apply(A, B; cutoff=1e-12)
+```
+which is the same as the code above.
+
+If you are contracting MPOs that have diverging norms, such as MPOs representing sums of local
+operators, the truncation can become numerically unstable (see https://arxiv.org/abs/1909.06341 for
+a more numerically stable alternative). For now, you can use the following options to contract
+MPOs like that:
+```julia
+C = contract(A, B; alg="naive", truncate=false)
+# Bring the indices back to pairs of primed and unprimed
+C = apply(A, B; alg="naive", truncate=false)
+```
+
 # Keywords
-- `cutoff::Float64=1e-13`: the cutoff value for truncating the density matrix eigenvalues. Note that the default is somewhat arbitrary and subject to change, in general you should set a `cutoff` value.
+- `cutoff::Float64=1e-14`: the cutoff value for truncating the density matrix eigenvalues. Note that the default is somewhat arbitrary and subject to change, in general you should set a `cutoff` value.
 - `maxdim::Int=maxlinkdim(A) * maxlinkdim(B))`: the maximal bond dimension of the results MPS.
 - `mindim::Int=1`: the minimal bond dimension of the resulting MPS.
+- `alg="zipup"`: Either `"zipup"` or `"naive"`. `"zipup"` contracts pairs of site tensors and truncates with SVDs in a sweep across the sites, while `"naive"` first contracts pairs of tensor exactly and then truncates at the end if `truncate=true`.
+- `truncate=true`: Enable or disable truncation. If `truncate=false`, ignore other truncation parameters like `cutoff` and `maxdim`. This is most relevant for the `"naive"` version, if you just want to contract the tensors pairwise exactly. This can be useful if you are contracting MPOs that have diverging norms, such as MPOs originating from sums of local operators.
+
+See also [`apply`](@ref) for details about the arguments available.
 """
 
 @doc """
@@ -668,7 +891,7 @@ function sample(M::MPO)
     pn = 0.0
     while n <= d
       projn = ITensor(s)
-      projn[s[n]] = 1.0
+      projn[s => n] = 1.0
       pnc = (ρj * projn * prime(projn))[]
       if imag(pnc) > 1e-8
         @warn "In sample, probability $pnc is complex."
diff --git a/src/mps/mps.jl b/src/mps/mps.jl
index a5fc808509..8b990293b4 100644
--- a/src/mps/mps.jl
+++ b/src/mps/mps.jl
@@ -15,6 +15,8 @@ function MPS(A::Vector{<:ITensor}; ortho_lims::UnitRange=1:length(A))
   return MPS(A, first(ortho_lims) - 1, last(ortho_lims) + 1)
 end
 
+set_data(A::MPS, data::Vector{ITensor}) = MPS(data, A.llim, A.rlim)
+
 @doc """
     MPS(v::Vector{<:ITensor})
 
@@ -52,7 +54,7 @@ function MPS(::Type{T}, sites::Vector{<:Index}; linkdims::Integer=1) where {T<:N
   N = length(sites)
   v = Vector{ITensor}(undef, N)
   if N == 1
-    v[1] = emptyITensor(T, sites[1])
+    v[1] = ITensor(T, sites[1])
     return MPS(v)
   end
 
@@ -66,11 +68,11 @@ function MPS(::Type{T}, sites::Vector{<:Index}; linkdims::Integer=1) where {T<:N
   for ii in eachindex(sites)
     s = sites[ii]
     if ii == 1
-      v[ii] = emptyITensor(T, l[ii], s)
+      v[ii] = ITensor(T, l[ii], s)
     elseif ii == N
-      v[ii] = emptyITensor(T, dag(l[ii - 1]), s)
+      v[ii] = ITensor(T, dag(l[ii - 1]), s)
     else
-      v[ii] = emptyITensor(T, dag(l[ii - 1]), s, l[ii])
+      v[ii] = ITensor(T, dag(l[ii - 1]), s, l[ii])
     end
   end
   return MPS(v)
@@ -96,6 +98,11 @@ function randomU(s1::Index, s2::Index)
 end
 
 function randomizeMPS!(M::MPS, sites::Vector{<:Index}, linkdim=1)
+  if isone(length(sites))
+    randn!(M[1])
+    normalize!(M)
+    return M
+  end
   N = length(sites)
   c = div(N, 2)
   max_pass = 100
@@ -130,14 +137,11 @@ end
 function randomCircuitMPS(
   ::Type{ElT}, sites::Vector{<:Index}, linkdim::Int; kwargs...
 ) where {ElT<:Number}
-  _rmatrix(::Type{Float64}, n, m) = NDTensors.random_orthog(n, m)
-  _rmatrix(::Type{ComplexF64}, n, m) = NDTensors.random_unitary(n, m)
-
   N = length(sites)
   M = MPS(N)
 
   if N == 1
-    M[1] = ITensor(randn(dim(sites[1])), sites[1])
+    M[1] = ITensor(randn(ElT, dim(sites[1])), sites[1])
     M[1] /= norm(M[1])
     return M
   end
@@ -161,22 +165,22 @@ function randomCircuitMPS(
   d = dim(sites[N])
   chi = maxdims[N - 1]
   l[N - 1] = Index(chi, "Link,l=$(N-1)")
-  O = _rmatrix(ElT, chi, d)
+  O = NDTensors.random_unitary(ElT, chi, d)
   M[N] = itensor(O, l[N - 1], sites[N])
 
   for j in (N - 1):-1:2
     chi = maxdims[j - 1]
     l[j - 1] = Index(chi, "Link,l=$(j-1)")
-    O = _rmatrix(ElT, chi, dim(sites[j]) * dim(l[j]))
+    O = NDTensors.random_unitary(ElT, chi, dim(sites[j]) * dim(l[j]))
     T = reshape(O, (chi, dim(sites[j]), dim(l[j])))
     M[j] = itensor(T, l[j - 1], sites[j], l[j])
   end
 
-  O = _rmatrix(ElT, 1, dim(sites[1]) * dim(l[1]))
+  O = NDTensors.random_unitary(ElT, 1, dim(sites[1]) * dim(l[1]))
   l0 = Index(1, "Link,l=0")
   T = reshape(O, (1, dim(sites[1]), dim(l[1])))
   M[1] = itensor(T, l0, sites[1], l[1])
-  M[1] *= onehot(l0 => 1)
+  M[1] *= onehot(ElT, l0 => 1)
 
   M.llim = 0
   M.rlim = 2
@@ -250,7 +254,7 @@ function MPS(::Type{T}, ivals::Vector{<:Pair{<:Index}}) where {T<:Number}
   M = MPS(N)
 
   if N == 1
-    M[1] = emptyITensor(T, ind(ivals[1]))
+    M[1] = ITensor(T, ind(ivals[1]))
     M[1][ivals[1]] = one(T)
     return M
   end
@@ -269,14 +273,14 @@ function MPS(::Type{T}, ivals::Vector{<:Pair{<:Index}}) where {T<:Number}
     links = [Index(1, "Link,l=$n") for n in 1:(N - 1)]
   end
 
-  M[1] = emptyITensor(T, ind(ivals[1]), links[1])
+  M[1] = ITensor(T, ind(ivals[1]), links[1])
   M[1][ivals[1], links[1] => 1] = one(T)
   for n in 2:(N - 1)
     s = ind(ivals[n])
-    M[n] = emptyITensor(T, dag(links[n - 1]), s, links[n])
+    M[n] = ITensor(T, dag(links[n - 1]), s, links[n])
     M[n][links[n - 1] => 1, ivals[n], links[n] => 1] = one(T)
   end
-  M[N] = emptyITensor(T, dag(links[N - 1]), ind(ivals[N]))
+  M[N] = ITensor(T, dag(links[N - 1]), ind(ivals[N]))
   M[N][links[N - 1] => 1, ivals[N]] = one(T)
 
   return M
@@ -566,12 +570,20 @@ function sample(m::MPS)
   return result
 end
 
+_op_prod(o1::AbstractString, o2::AbstractString) = "$o1 * $o2"
+_op_prod(o1::Matrix{<:Number}, o2::Matrix{<:Number}) = o1 * o2
+
 """
     correlation_matrix(psi::MPS,
                        Op1::AbstractString,
                        Op2::AbstractString;
                        kwargs...)
 
+    correlation_matrix(psi::MPS,
+                       Op1::Matrix{<:Number},
+                       Op2::Matrix{<:Number};
+                       kwargs...)
+
 Given an MPS psi and two strings denoting
 operators (as recognized by the `op` function), 
 computes the two-point correlation function matrix
@@ -593,20 +605,21 @@ m = 4
 s = siteinds("S=1/2",N)
 psi = randomMPS(s; linkdims=m)
 Czz = correlation_matrix(psi,"Sz","Sz")
+Czz = correlation_matrix(psi,[1/2 0; 0 -1/2],[1/2 0; 0 -1/2]) # same as above
 
 s = siteinds("Electron",N; conserve_qns=true)
 psi = randomMPS(s, n->isodd(n) ? "Up" : "Dn"; linkdims=m)
 Cuu = correlation_matrix(psi,"Cdagup","Cup";site_range=2:8)
 ``` 
 """
-function correlation_matrix(psi::MPS, _Op1::AbstractString, _Op2::AbstractString; kwargs...)
+function correlation_matrix(psi::MPS, _Op1, _Op2; kwargs...)
   N = length(psi)
   ElT = promote_itensor_eltype(psi)
   s = siteinds(psi)
 
   Op1 = _Op1 #make copies into which we can insert "F" string operators, and then restore.
   Op2 = _Op2
-  onsiteOp = "$Op1 * $Op2"
+  onsiteOp = _op_prod(Op1, Op2)
   fermionic1 = has_fermion_string(Op1, s[1])
   fermionic2 = has_fermion_string(Op2, s[1])
   if fermionic1 != fermionic2
@@ -640,16 +653,23 @@ function correlation_matrix(psi::MPS, _Op1::AbstractString, _Op2::AbstractString
     end
   end
 
-  site_range::UnitRange{Int} = get(kwargs, :site_range, 1:N)
-  start_site = first(site_range)
-  end_site = last(site_range)
+  if haskey(kwargs, :site_range)
+    @warn "The `site_range` keyword arg. to `correlation_matrix` is deprecated: use the keyword `sites` instead"
+    sites_ = kwargs[:site_range]
+  else
+    sites_ = get(kwargs, :sites, 1:N)
+  end
+  sites = (sites_ isa AbstractRange) ? sites_ : collect(sites_)
+
+  start_site = first(sites)
+  end_site = last(sites)
 
   psi = copy(psi)
   orthogonalize!(psi, start_site)
   norm2_psi = norm(psi[start_site])^2
 
   # Nb = size of block of correlation matrix
-  Nb = end_site - start_site + 1
+  Nb = length(sites)
 
   C = zeros(ElT, Nb, Nb)
 
@@ -659,38 +679,58 @@ function correlation_matrix(psi::MPS, _Op1::AbstractString, _Op2::AbstractString
     lind = commonind(psi[start_site], psi[start_site - 1])
     L = delta(dag(lind), lind')
   end
+  pL = start_site - 1
 
-  for i in start_site:(end_site - 1)
-    ci = i - start_site + 1
+  for (ni, i) in enumerate(sites[1:(end - 1)])
+    while pL < i - 1
+      pL += 1
+      L = (L * psi[pL]) * dag(prime(psi[pL], "Link"))
+    end
 
     Li = L * psi[i]
 
     # Get j == i diagonal correlations
     rind = commonind(psi[i], psi[i + 1])
-    C[ci, ci] =
+    C[ni, ni] =
       scalar((Li * op(onsiteOp, s, i)) * prime(dag(psi[i]), not(rind))) / norm2_psi
 
     # Get j > i correlations
     if !using_auto_fermion() && fermionic2
       Op1 = "$Op1 * F"
     end
+
     Li12 = (Li * op(Op1, s, i)) * dag(prime(psi[i]))
-    for j in (i + 1):end_site
-      cj = j - start_site + 1
+    pL12 = i
+
+    for (n, j) in enumerate(sites[(ni + 1):end])
+      nj = ni + n
+
+      while pL12 < j - 1
+        pL12 += 1
+        if !using_auto_fermion() && fermionic2
+          Li12 *= op("F", s[pL12]) * dag(prime(psi[pL12]))
+        else
+          Li12 *= dag(prime(psi[pL12], "Link"))
+        end
+        Li12 *= psi[pL12]
+      end
+
       lind = commonind(psi[j], Li12)
       Li12 *= psi[j]
 
       val = (Li12 * op(Op2, s, j)) * dag(prime(prime(psi[j], "Site"), lind))
-      C[ci, cj] = scalar(val) / norm2_psi
+      C[ni, nj] = scalar(val) / norm2_psi
       if is_cm_hermitian
-        C[cj, ci] = conj(C[ci, cj])
+        C[nj, ni] = conj(C[ni, nj])
       end
 
+      pL12 += 1
       if !using_auto_fermion() && fermionic2
-        Li12 *= op("F", s, j) * dag(prime(psi[j]))
+        Li12 *= op("F", s[pL12]) * dag(prime(psi[pL12]))
       else
-        Li12 *= dag(prime(psi[j], "Link"))
+        Li12 *= dag(prime(psi[pL12], "Link"))
       end
+      @assert pL12 == j
     end #for j
     Op1 = _Op1 #"Restore Op1 with no Fs"
 
@@ -701,31 +741,51 @@ function correlation_matrix(psi::MPS, _Op1::AbstractString, _Op2::AbstractString
         Op2 = "$Op2 * F"
       end
       Li21 = (Li * op(Op2, s, i)) * dag(prime(psi[i]))
+      pL21 = i
       if !using_auto_fermion() && fermionic1
         Li21 = -Li21 #Required because we swapped fermionic ops, instead of sweeping right to left.
       end
-      for j in (i + 1):end_site
-        cj = j - start_site + 1
+
+      for (n, j) in enumerate(sites[(ni + 1):end])
+        nj = ni + n
+
+        while pL21 < j - 1
+          pL21 += 1
+          if !using_auto_fermion() && fermionic1
+            Li21 *= op("F", s[pL21]) * dag(prime(psi[pL21]))
+          else
+            Li21 *= dag(prime(psi[pL21], "Link"))
+          end
+          Li21 *= psi[pL21]
+        end
+
         lind = commonind(psi[j], Li21)
         Li21 *= psi[j]
 
         val = (Li21 * op(Op1, s, j)) * dag(prime(prime(psi[j], "Site"), lind))
-        C[cj, ci] = scalar(val) / norm2_psi
+        C[nj, ni] = scalar(val) / norm2_psi
 
+        pL21 += 1
         if !using_auto_fermion() && fermionic1
-          Li21 *= op("F", s, j) * dag(prime(psi[j]))
+          Li21 *= op("F", s[pL21]) * dag(prime(psi[pL21]))
         else
-          Li21 *= dag(prime(psi[j], "Link"))
+          Li21 *= dag(prime(psi[pL21], "Link"))
         end
+        @assert pL21 == j
       end #for j
       Op2 = _Op2 #"Restore Op2 with no Fs"
     end #if is_cm_hermitian
 
-    L = (L * psi[i]) * dag(prime(psi[i], "Link"))
+    pL += 1
+    L = Li * dag(prime(psi[i], "Link"))
   end #for i
 
   # Get last diagonal element of C
   i = end_site
+  while pL < i - 1
+    pL += 1
+    L = (L * psi[pL]) * dag(prime(psi[pL], "Link"))
+  end
   lind = commonind(psi[i], psi[i - 1])
   C[Nb, Nb] =
     scalar(L * psi[i] * op(onsiteOp, s, i) * prime(prime(dag(psi[i]), "Site"), lind)) /
@@ -735,8 +795,9 @@ function correlation_matrix(psi::MPS, _Op1::AbstractString, _Op2::AbstractString
 end
 
 """
-    expect(psi::MPS,op::AbstractString...; kwargs...)
-    expect(psi::MPS,ops; kwargs...)
+    expect(psi::MPS, op::AbstractString...; kwargs...)
+    expect(psi::MPS, op::Matrix{<:Number}...; kwargs...)
+    expect(psi::MPS, ops; kwargs...)
 
 Given an MPS `psi` and a single operator name, returns
 a vector of the expected value of the operator on 
@@ -759,8 +820,11 @@ N = 10
 
 s = siteinds("S=1/2",N)
 psi = randomMPS(s; linkdims=8)
+Z = expect(psi,"Sz") # compute for all sites
 Z = expect(psi,"Sz";sites=2:4) # compute for sites 2,3,4
 Z3 = expect(psi,"Sz";sites=3)  # compute for site 3 only (output will be a scalar)
+XZ = expect(psi,["Sx","Sz"]) # compute Sx and Sz for all sites
+Z = expect(psi,[1/2 0; 0 -1/2]) # same as expect(psi,"Sz")
 
 s = siteinds("Electron",N)
 psi = randomMPS(s; linkdims=8)
@@ -809,10 +873,18 @@ function expect(psi::MPS, op::AbstractString; kwargs...)
   return first(expect(psi, (op,); kwargs...))
 end
 
+function expect(psi::MPS, op::Matrix{<:Number}; kwargs...)
+  return first(expect(psi, (op,); kwargs...))
+end
+
 function expect(psi::MPS, op1::AbstractString, ops::AbstractString...; kwargs...)
   return expect(psi, (op1, ops...); kwargs...)
 end
 
+function expect(psi::MPS, op1::Matrix{<:Number}, ops::Matrix{<:Number}...; kwargs...)
+  return expect(psi, (op1, ops...); kwargs...)
+end
+
 function HDF5.write(parent::Union{HDF5.File,HDF5.Group}, name::AbstractString, M::MPS)
   g = create_group(parent, name)
   attributes(g)["type"] = "MPS"
diff --git a/src/mps/observer.jl b/src/mps/observer.jl
index 31d40d8b33..ec5eec8067 100644
--- a/src/mps/observer.jl
+++ b/src/mps/observer.jl
@@ -27,11 +27,11 @@ implements custom measurements and allows
 the `dmrg` function to return early if an
 energy convergence criterion is met.
 """
-struct DMRGObserver <: AbstractObserver
+struct DMRGObserver{T} <: AbstractObserver
   ops::Vector{String}
   sites::Vector{<:Index}
   measurements::Dict{String,DMRGMeasurement}
-  energies::Vector{Float64}
+  energies::Vector{T}
   truncerrs::Vector{Float64}
   etol::Float64
   minsweeps::Int64
@@ -39,20 +39,29 @@ end
 
 """
     DMRGObserver(;energy_tol=0.0,
-                  minsweeps=2)
+                  minsweeps=2,
+                  energy_type=Float64)
 
 Construct a DMRGObserver by providing the energy
 tolerance used for early stopping, and minimum number
 of sweeps that must be done.
 
+Optional keyword arguments:
   - energy_tol: if the energy from one sweep to the
     next no longer changes by more than this amount,
     stop after the current sweep
   - minsweeps: do at least this many sweeps
+  - energy_type: type to use when storing energies at each step
 """
-function DMRGObserver(; energy_tol=0.0, minsweeps=2)
+function DMRGObserver(; energy_tol=0.0, minsweeps=2, energy_type=Float64)
   return DMRGObserver(
-    [], Index[], Dict{String,DMRGMeasurement}(), [], [], energy_tol, minsweeps
+    String[],
+    Index[],
+    Dict{String,DMRGMeasurement}(),
+    energy_type[],
+    Float64[],
+    energy_tol,
+    minsweeps,
   )
 end
 
@@ -60,7 +69,8 @@ end
     DMRGObserver(ops::Vector{String}, 
                  sites::Vector{<:Index};
                  energy_tol=0.0,
-                 minsweeps=2)
+                 minsweeps=2,
+                 energy_type=Float64)
 
 Construct a DMRGObserver, provide an array
 of `ops` of operator names which are strings 
@@ -76,16 +86,24 @@ Optionally, one can provide an energy
 tolerance used for early stopping, and minimum number
 of sweeps that must be done.
 
+Optional keyword arguments:
   - energy_tol: if the energy from one sweep to the
     next no longer changes by more than this amount,
     stop after the current sweep
   - minsweeps: do at least this many sweeps
+  - energy_type: type to use when storing energies at each step
 """
 function DMRGObserver(
-  ops::Vector{String}, sites::Vector{<:Index}; energy_tol=0.0, minsweeps=2
+  ops::Vector{String},
+  sites::Vector{<:Index};
+  energy_tol=0.0,
+  minsweeps=2,
+  energy_type=Float64,
 )
   measurements = Dict(o => DMRGMeasurement() for o in ops)
-  return DMRGObserver(ops, sites, measurements, [], [], energy_tol, minsweeps)
+  return DMRGObserver{energy_type}(
+    ops, sites, measurements, energy_type[], Float64[], energy_tol, minsweeps
+  )
 end
 
 """
@@ -157,8 +175,8 @@ end
 function checkdone!(o::DMRGObserver; kwargs...)
   outputlevel = get(kwargs, :outputlevel, false)
   if (
-    length(energies(o)) > o.minsweeps &&
-    abs(energies(o)[end] - energies(o)[end - 1]) < o.etol
+    length(real(energies(o))) > o.minsweeps &&
+    abs(real(energies(o))[end] - real(energies(o))[end - 1]) < o.etol
   )
     outputlevel > 0 && println("Energy difference less than $(o.etol), stopping DMRG")
     return true
diff --git a/src/mps/projmpo.jl b/src/mps/projmpo.jl
index ab698a6341..29348ede78 100644
--- a/src/mps/projmpo.jl
+++ b/src/mps/projmpo.jl
@@ -24,5 +24,12 @@ mutable struct ProjMPO <: AbstractProjMPO
   nsite::Int
   H::MPO
   LR::Vector{ITensor}
-  ProjMPO(H::MPO) = new(0, length(H) + 1, 2, H, Vector{ITensor}(undef, length(H)))
+end
+ProjMPO(H::MPO) = ProjMPO(0, length(H) + 1, 2, H, Vector{ITensor}(undef, length(H)))
+
+copy(P::ProjMPO) = ProjMPO(P.lpos, P.rpos, P.nsite, copy(P.H), copy(P.LR))
+
+function set_nsite!(P::ProjMPO, nsite)
+  P.nsite = nsite
+  return P
 end
diff --git a/src/mps/projmpo_mps.jl b/src/mps/projmpo_mps.jl
index 3e3df93fc9..bfecab7791 100644
--- a/src/mps/projmpo_mps.jl
+++ b/src/mps/projmpo_mps.jl
@@ -1,10 +1,11 @@
-
 mutable struct ProjMPO_MPS
   PH::ProjMPO
   pm::Vector{ProjMPS}
   weight::Float64
 end
 
+copy(P::ProjMPO_MPS) = ProjMPO_MPS(copy(P.PH), copy.(P.pm), P.weight)
+
 function ProjMPO_MPS(H::MPO, mpsv::Vector{MPS}; weight=1.0)
   return ProjMPO_MPS(ProjMPO(H), [ProjMPS(m) for m in mpsv], weight)
 end
@@ -13,6 +14,14 @@ ProjMPO_MPS(H::MPO, Ms::MPS...; weight=1.0) = ProjMPO_MPS(H, [Ms...], weight)
 
 nsite(P::ProjMPO_MPS) = nsite(P.PH)
 
+function set_nsite!(Ps::ProjMPO_MPS, nsite)
+  set_nsite!(Ps.PH, nsite)
+  for P in Ps.pm
+    set_nsite!(P, nsite)
+  end
+  return Ps
+end
+
 Base.length(P::ProjMPO_MPS) = length(P.PH)
 
 function product(P::ProjMPO_MPS, v::ITensor)::ITensor
diff --git a/src/mps/projmposum.jl b/src/mps/projmposum.jl
index ea19bd5a13..ed701002fb 100644
--- a/src/mps/projmposum.jl
+++ b/src/mps/projmposum.jl
@@ -27,12 +27,21 @@ mutable struct ProjMPOSum
   pm::Vector{ProjMPO}
 end
 
+copy(P::ProjMPOSum) = ProjMPOSum(copy.(P.pm))
+
 ProjMPOSum(mpos::Vector{MPO}) = ProjMPOSum([ProjMPO(M) for M in mpos])
 
 ProjMPOSum(Ms::MPO...) = ProjMPOSum([Ms...])
 
 nsite(P::ProjMPOSum) = nsite(P.pm[1])
 
+function set_nsite!(Ps::ProjMPOSum, nsite)
+  for P in Ps.pm
+    set_nsite!(P, nsite)
+  end
+  return Ps
+end
+
 Base.length(P::ProjMPOSum) = length(P.pm[1])
 
 """
diff --git a/src/mps/projmps.jl b/src/mps/projmps.jl
index 39b95d602b..8250c08cd7 100644
--- a/src/mps/projmps.jl
+++ b/src/mps/projmps.jl
@@ -5,11 +5,18 @@ mutable struct ProjMPS
   nsite::Int
   M::MPS
   LR::Vector{ITensor}
-  ProjMPS(M::MPS) = new(0, length(M) + 1, 2, M, Vector{ITensor}(undef, length(M)))
 end
+ProjMPS(M::MPS) = ProjMPS(0, length(M) + 1, 2, M, Vector{ITensor}(undef, length(M)))
+
+copy(P::ProjMPS) = ProjMPS(P.lpos, P.rpos, P.nsite, copy(P.M), copy(P.LR))
 
 nsite(P::ProjMPS) = P.nsite
 
+function set_nsite!(P::ProjMPS, nsite)
+  P.nsite = nsite
+  return P
+end
+
 Base.length(P::ProjMPS) = length(P.M)
 
 function lproj(P::ProjMPS)
diff --git a/src/nullspace.jl b/src/nullspace.jl
new file mode 100644
index 0000000000..041a9a936d
--- /dev/null
+++ b/src/nullspace.jl
@@ -0,0 +1,157 @@
+#
+# NDTensors functionality
+#
+
+# XXX: generalize this function
+function _getindex(T::DenseTensor{ElT,N}, I1::Colon, I2::UnitRange{Int64}) where {ElT,N}
+  A = array(T)[I1, I2]
+  return tensor(Dense(vec(A)), setdims(inds(T), size(A)))
+end
+
+function getblock_preserve_qns(T::Tensor, b::Block)
+  # TODO: make `T[b]` preserve QNs
+  Tb = T[b]
+  indsTb = getblock.(inds(T), Tuple(b)) .* dir.(inds(T))
+  return ITensors.setinds(Tb, indsTb)
+end
+
+function blocksparsetensor(blocks::Dict{B,TB}) where {B,TB}
+  b1, Tb1 = first(pairs(blocks))
+  N = length(b1)
+  indstypes = typeof.(inds(Tb1))
+  blocktype = eltype(Tb1)
+  indsT = getindex.(indstypes)
+  # Determine the indices from the blocks
+  for (b, Tb) in pairs(blocks)
+    indsTb = inds(Tb)
+    for n in 1:N
+      bn = b[n]
+      indsTn = indsT[n]
+      if bn > length(indsTn)
+        resize!(indsTn, bn)
+      end
+      indsTn[bn] = indsTb[n]
+    end
+  end
+  T = BlockSparseTensor(blocktype, indsT)
+  for (b, Tb) in pairs(blocks)
+    if !isempty(Tb)
+      T[b] = Tb
+    end
+  end
+  return T
+end
+
+default_atol(A::AbstractArray) = 0.0
+function default_rtol(A::AbstractArray, atol::Real)
+  return (min(size(A, 1), size(A, 2)) * eps(real(float(one(eltype(A)))))) * iszero(atol)
+end
+
+function _nullspace_hermitian(
+  M::DenseTensor; atol::Real=default_atol(M), rtol::Real=default_rtol(M, atol)
+)
+  # TODO: try this version
+  #D, U = eigen(Hermitian(M))
+  Dᵢₜ, Uᵢₜ = eigen(itensor(M); ishermitian=true)
+  D = tensor(Dᵢₜ)
+  U = tensor(Uᵢₜ)
+  tol = max(atol, abs(D[1, 1]) * rtol)
+  indstart = sum(d -> abs(d) .> tol, storage(D)) + 1
+  indstop = lastindex(U, 2)
+  Nb = _getindex(U, :, indstart:indstop)
+  return Nb
+end
+
+function _nullspace_hermitian(
+  M::BlockSparseTensor; atol::Real=default_atol(M), rtol::Real=default_rtol(M, atol)
+)
+  tol = atol
+  # TODO: try this version
+  # Insert any missing diagonal blocks
+  insert_diag_blocks!(M)
+  #D, U = eigen(Hermitian(M))
+  Dᵢₜ, Uᵢₜ = eigen(itensor(M); ishermitian=true)
+  D = tensor(Dᵢₜ)
+  U = tensor(Uᵢₜ)
+  nullspace_blocks = Dict()
+  for bU in nzblocks(U)
+    bM = Block(bU[1], bU[1])
+    bD = Block(bU[2], bU[2])
+    # Assume sorted from largest to smallest
+    tol = max(atol, abs(D[bD][1, 1]) * rtol)
+    indstart = sum(d -> abs(d) .> tol, storage(D[bD])) + 1
+    Ub = getblock_preserve_qns(U, bU)
+    indstop = lastindex(Ub, 2)
+    # Drop zero dimensional blocks
+    Nb = _getindex(Ub, :, indstart:indstop)
+    nullspace_blocks[bU] = Nb
+  end
+  return blocksparsetensor(nullspace_blocks)
+end
+
+function LinearAlgebra.nullspace(M::Hermitian{<:Number,<:Tensor}; kwargs...)
+  return _nullspace_hermitian(parent(M); kwargs...)
+end
+
+#
+# QN functionality
+#
+
+function setdims(t::NTuple{N,Pair{QN,Int}}, dims::NTuple{N,Int}) where {N}
+  return first.(t) .=> dims
+end
+
+function setdims(t::NTuple{N,Index{Int}}, dims::NTuple{N,Int}) where {N}
+  return dims
+end
+
+function getblock(i::Index, n::Integer)
+  return ITensors.space(i)[n]
+end
+
+# Make `Pair{QN,Int}` act like a regular `dim`
+NDTensors.dim(qnv::Pair{QN,Int}) = last(qnv)
+
+Base.:*(qnv::Pair{QN,Int}, d::ITensors.Arrow) = qn(qnv) * d => dim(qnv)
+
+#
+# ITensors functionality
+#
+
+# Reshape into an order-2 ITensor
+matricize(T::ITensor, inds::Index...) = matricize(T, inds)
+
+function matricize(T::ITensor, inds)
+  left_inds = commoninds(T, inds)
+  right_inds = uniqueinds(T, inds)
+  return matricize(T, left_inds, right_inds)
+end
+
+function matricize(T::ITensor, left_inds, right_inds)
+  CL = combiner(left_inds; dir=ITensors.Out, tags="CL")
+  CR = combiner(right_inds; dir=ITensors.In, tags="CR")
+  M = (T * CL) * CR
+  return M, CL, CR
+end
+
+function nullspace(::Order{2}, M::ITensor, left_inds, right_inds; tags="n", kwargs...)
+  @assert order(M) == 2
+  M² = prime(dag(M), right_inds) * M
+  M² = permute(M², right_inds'..., right_inds...)
+  M²ₜ = tensor(M²)
+  Nₜ = nullspace(Hermitian(M²ₜ); kwargs...)
+  indsN = (Index(ind(Nₜ, 1); dir=ITensors.Out), Index(ind(Nₜ, 2); dir=ITensors.Out, tags))
+  N = itensor(ITensors.setinds(Nₜ, indsN))
+  # Make the index match the input index
+  Ñ = replaceinds(N, (ind(N, 1),) => right_inds)
+  return Ñ
+end
+
+function nullspace(T::ITensor, is...; tags="n", kwargs...)
+  M, CL, CR = matricize(T, is...)
+  @assert order(M) == 2
+  cL = commoninds(M, CL)
+  cR = commoninds(M, CR)
+  N₂ = nullspace(Order(2), M, cL, cR; tags, kwargs...)
+  return N₂ * CR
+end
diff --git a/src/physics/autompo/matelem.jl b/src/physics/autompo/matelem.jl
new file mode 100644
index 0000000000..5baa776a1d
--- /dev/null
+++ b/src/physics/autompo/matelem.jl
@@ -0,0 +1,40 @@
+##################################
+# MatElem (simple sparse matrix) #
+##################################
+
+struct MatElem{T}
+  row::Int
+  col::Int
+  val::T
+end
+
+#function Base.show(io::IO,m::MatElem)
+#  print(io,"($(m.row),$(m.col),$(m.val))")
+#end
+
+function toMatrix(els::Vector{MatElem{T}})::Matrix{T} where {T}
+  nr = 0
+  nc = 0
+  for el in els
+    nr = max(nr, el.row)
+    nc = max(nc, el.col)
+  end
+  M = zeros(T, nr, nc)
+  for el in els
+    M[el.row, el.col] = el.val
+  end
+  return M
+end
+
+function Base.:(==)(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  return (m1.row == m2.row && m1.col == m2.col && m1.val == m2.val)
+end
+
+function Base.isless(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  if m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
diff --git a/src/physics/autompo/opsum_to_mpo.jl b/src/physics/autompo/opsum_to_mpo.jl
new file mode 100644
index 0000000000..3585bec818
--- /dev/null
+++ b/src/physics/autompo/opsum_to_mpo.jl
@@ -0,0 +1,143 @@
+function svdMPO(os::OpSum{C}, sites; kwargs...)::MPO where {C}
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, 10000)
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(terms(os))
+
+  Vs = [Matrix{ValType}(undef, 1, 1) for n in 1:N]
+  tempMPO = [MatElem{Scaled{C,Prod{Op}}}[] for n in 1:N]
+
+  function crosses_bond(t::Scaled{C,Prod{Op}}, n::Int) where {C}
+    return (only(site(t[1])) <= n <= only(site(t[end])))
+  end
+
+  rightmap = Dict{Vector{Op},Int}()
+  next_rightmap = Dict{Vector{Op},Int}()
+
+  for n in 1:N
+    leftbond_coefs = MatElem{ValType}[]
+
+    leftmap = Dict{Vector{Op},Int}()
+    for term in os
+      crosses_bond(term, n) || continue
+
+      left = filter(t -> (only(site(t)) < n), terms(term))
+      onsite = filter(t -> (only(site(t)) == n), terms(term))
+      right = filter(t -> (only(site(t)) > n), terms(term))
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left)
+        bond_col = posInLink!(rightmap, vcat(onsite, right))
+        bond_coef = convert(ValType, coefficient(term))
+        push!(leftbond_coefs, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right)
+      site_coef = one(C)
+      if A_row == -1
+        site_coef = coefficient(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, Op("F", n))
+        else
+          push!(onsite, Op("Id", n))
+        end
+      end
+      el = MatElem(A_row, A_col, site_coef * Prod(onsite))
+      push!(tempMPO[n], el)
+    end
+    rightmap = next_rightmap
+    next_rightmap = Dict{Vector{Op},Int}()
+    remove_dups!(tempMPO[n])
+    if n > 1 && !isempty(leftbond_coefs)
+      M = toMatrix(leftbond_coefs)
+      U, S, V = svd(M)
+      P = S .^ 2
+      truncate!(P; maxdim=maxdim, cutoff=cutoff, mindim=mindim)
+      tdim = length(P)
+      nc = size(M, 2)
+      Vs[n - 1] = Matrix{ValType}(V[1:nc, 1:tdim])
+    end
+  end
+
+  llinks = Vector{Index{Int}}(undef, N + 1)
+  llinks[1] = Index(2, "Link,l=0")
+
+  H = MPO(sites)
+
+  for n in 1:N
+    VL = Matrix{ValType}(undef, 1, 1)
+    if n > 1
+      VL = Vs[n - 1]
+    end
+    VR = Vs[n]
+    tdim = size(VR, 2)
+
+    llinks[n + 1] = Index(2 + tdim, "Link,l=$n")
+
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    H[n] = ITensor()
+
+    for el in tempMPO[n]
+      A_row = el.row
+      A_col = el.col
+      t = el.val
+      (abs(coefficient(t)) > eps()) || continue
+
+      M = zeros(ValType, dim(ll), dim(rl))
+
+      ct = convert(ValType, coefficient(t))
+      if A_row == -1 && A_col == -1 #onsite term
+        M[end, 1] += ct
+      elseif A_row == -1 #term starting on site n
+        for c in 1:size(VR, 2)
+          z = ct * VR[A_col, c]
+          M[end, 1 + c] += z
+        end
+      elseif A_col == -1 #term ending on site n
+        for r in 1:size(VL, 2)
+          z = ct * conj(VL[A_row, r])
+          M[1 + r, 1] += z
+        end
+      else
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          z = ct * conj(VL[A_row, r]) * VR[A_col, c]
+          M[1 + r, 1 + c] += z
+        end
+      end
+
+      T = itensor(M, ll, rl)
+      H[n] += T * computeSiteProd(sites, argument(t))
+    end
+
+    #
+    # Special handling of starting and 
+    # ending identity operators:
+    #
+    idM = zeros(ValType, dim(ll), dim(rl))
+    idM[1, 1] = 1.0
+    idM[end, end] = 1.0
+    T = itensor(idM, ll, rl)
+    H[n] += T * computeSiteProd(sites, Prod([Op("Id", n)]))
+  end
+
+  L = ITensor(llinks[1])
+  L[end] = 1.0
+
+  R = ITensor(llinks[N + 1])
+  R[1] = 1.0
+
+  H[1] *= L
+  H[N] *= R
+
+  return H
+end #svdMPO
diff --git a/src/physics/autompo/opsum_to_mpo.jl.backup b/src/physics/autompo/opsum_to_mpo.jl.backup
new file mode 100644
index 0000000000..5e56a489c5
--- /dev/null
+++ b/src/physics/autompo/opsum_to_mpo.jl.backup
@@ -0,0 +1,701 @@
+#
+# Optimizations:
+#
+#  - replace leftmap, rightmap with sorted vectors
+# 
+
+## """
+##     prune!(os::OpSum; cutoff = 1e-15)
+## 
+## Remove any MPOTerm with norm(coef) < cutoff
+## """
+## function prune!(os::OpSum; atol=1e-15)
+##   OS = OpSum()
+##   for o in os
+##     norm(ITensors.coefficient(o)) > atol && push!(OS, o)
+##   end
+##   os = OS
+##   return os
+## end
+## 
+## #
+## # os .+= ("Sz",1) syntax using broadcasting
+## #
+## 
+## struct OpSumStyle <: Broadcast.BroadcastStyle end
+## Base.BroadcastStyle(::Type{<:OpSum}) = OpSumStyle()
+## 
+## struct OpSumAddTermStyle <: Broadcast.BroadcastStyle end
+## 
+## Base.broadcastable(os::OpSum) = os
+## 
+## Base.BroadcastStyle(::OpSumStyle, ::Broadcast.Style{Tuple}) = OpSumAddTermStyle()
+## 
+## Broadcast.instantiate(bc::Broadcast.Broadcasted{OpSumAddTermStyle}) = bc
+## 
+## function Base.copyto!(os, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(+)})
+##   add!(os, bc.args[2]...)
+##   return os
+## end
+## 
+## #
+## # os .-= ("Sz",1) syntax using broadcasting
+## #
+## 
+## function Base.copyto!(os, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(-)})
+##   subtract!(os, bc.args[2]...)
+##   return os
+## end
+## 
+## (α::Number * os::OpSum) = OpSum([α * o for o in os])
+## (os::OpSum * α::Number) = α * os
+## (os::OpSum / α::Number) = OpSum([o / α for o in os])
+## 
+## (o1::OpSum - o2::OpSum) = o1 + (-1) * o2
+## 
+## function Base.show(io::IO, os::OpSum)
+##   println(io, "OpSum:")
+##   for term in data(os)
+##     println(io, "  $term")
+##   end
+## end
+
+# TODO: Redefine this? Maybe call `arguments`?
+data(a::Prod{Op}) = only(a.args)
+data(a::Sum{Scaled{C,Prod{Op}}}) where {C} = only(a.args)
+data(a::Scaled{C,Prod{Op}}) where {C} = data(argument(a))
+copy(a::Applied) = Applied(deepcopy(a.f), deepcopy(a.args), deepcopy(a.kwargs))
+Sum(a::Vector) = Applied(sum, (a,))
+Prod(a::Vector) = Applied(prod, (a,))
+isless(a1::Applied{F}, a2::Applied{F}) where {F} = (isless(a1.args, a2.args) && isless(a1.kwargs, a2.kwargs))
+isless(o1::Op, o2::Op) = (isless(which_op(o1), which_op(o2)) && isless(site(o1), site(o2)) && isless(params(o1), params(o2)))
+
+##################################
+# MatElem (simple sparse matrix) #
+##################################
+
+struct MatElem{T}
+  row::Int
+  col::Int
+  val::T
+end
+
+#function Base.show(io::IO,m::MatElem)
+#  print(io,"($(m.row),$(m.col),$(m.val))")
+#end
+
+function toMatrix(els::Vector{MatElem{T}})::Matrix{T} where {T}
+  nr = 0
+  nc = 0
+  for el in els
+    nr = max(nr, el.row)
+    nc = max(nc, el.col)
+  end
+  M = zeros(T, nr, nc)
+  for el in els
+    M[el.row, el.col] = el.val
+  end
+  return M
+end
+
+function Base.:(==)(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  return (m1.row == m2.row && m1.col == m2.col && m1.val == m2.val)
+end
+
+function Base.isless(m1::MatElem{T}, m2::MatElem{T})::Bool where {T}
+  if m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
+
+struct QNMatElem{T}
+  rowqn::QN
+  colqn::QN
+  row::Int
+  col::Int
+  val::T
+end
+
+function Base.:(==)(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  return (
+    m1.row == m2.row &&
+    m1.col == m2.col &&
+    m1.val == m2.val &&
+    m1.rowqn == m2.rowqn &&
+    m1.colqn == m2.colqn
+  )
+end
+
+function Base.isless(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  if m1.rowqn != m2.rowqn
+    return m1.rowqn < m2.rowqn
+  elseif m1.colqn != m2.colqn
+    return m1.colqn < m2.colqn
+  elseif m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
+
+isempty(op_qn::Pair{Prod{Op},QN}) = isempty(op_qn.first)
+
+# the key type is Prod{Op} for the dense case
+# and is Pair{Prod{Op},QN} for the QN conserving case
+function posInLink!(linkmap::Dict{K,Int}, k::K)::Int where {K}
+  isempty(k) && return -1
+  pos = get(linkmap, k, -1)
+  if pos == -1
+    pos = length(linkmap) + 1
+    linkmap[k] = pos
+  end
+  return pos
+end
+
+# TODO: Define as `C`. Rename `coefficient_type`.
+function determineValType(terms::Vector{Scaled{C,Prod{Op}}}) where {C}
+  for t in terms
+    (!isreal(coefficient(t))) && return ComplexF64
+  end
+  return Float64
+end
+
+function computeSiteProd(sites, ops::Prod{Op})::ITensor
+  i = only(site(ops[1]))
+  T = op(sites[i], which_op(ops[1]); params(ops[1])...)
+  for j in 2:length(ops)
+    (only(site(ops[j])) != i) && error("Mismatch of site number in computeSiteProd")
+    opj = op(sites[i], which_op(ops[j]); params(ops[j])...)
+    T = product(T, opj)
+  end
+  return T
+end
+
+function remove_dups!(v::Vector{T}) where {T}
+  N = length(v)
+  (N == 0) && return nothing
+  sort!(v)
+  n = 1
+  u = 2
+  while u <= N
+    while u < N && v[u] == v[n]
+      u += 1
+    end
+    if v[u] != v[n]
+      v[n + 1] = v[u]
+      n += 1
+    end
+    u += 1
+  end
+  resize!(v, n)
+  return nothing
+end #remove_dups!
+
+function svdMPO(os::OpSum{C}, sites; kwargs...)::MPO where {C}
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, 10000)
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(data(os))
+
+  Vs = [Matrix{ValType}(undef, 1, 1) for n in 1:N]
+  tempMPO = [MatElem{Scaled{C,Prod{Op}}}[] for n in 1:N]
+
+  crosses_bond(t::Scaled{C,Prod{Op}}, n::Int) where {C} = (only(site(t[1])) <= n <= only(site(t[end])))
+
+  rightmap = Dict{Prod{Op},Int}()
+  next_rightmap = Dict{Prod{Op},Int}()
+
+  for n in 1:N
+    leftbond_coefs = MatElem{ValType}[]
+
+    leftmap = Dict{Prod{Op},Int}()
+    for term in os
+      crosses_bond(term, n) || continue
+
+      left = Prod(filter(t -> (only(site(t)) < n), data(term)))
+      onsite = Prod(filter(t -> (only(site(t)) == n), data(term)))
+      right = Prod(filter(t -> (only(site(t)) > n), data(term)))
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left)
+        bond_col = posInLink!(rightmap, onsite * right)
+        bond_coef = convert(ValType, coefficient(term))
+        push!(leftbond_coefs, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right)
+      site_coef = one(C)
+      if A_row == -1
+        site_coef = coefficient(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, Op("F", n))
+        else
+          push!(onsite, Op("Id", n))
+        end
+      end
+      el = MatElem(A_row, A_col, site_coef * onsite)
+      push!(tempMPO[n], el)
+    end
+    rightmap = next_rightmap
+    next_rightmap = Dict{Prod{Op},Int}()
+    remove_dups!(tempMPO[n])
+    if n > 1 && !isempty(leftbond_coefs)
+      M = toMatrix(leftbond_coefs)
+      U, S, V = svd(M)
+      P = S .^ 2
+      truncate!(P; maxdim=maxdim, cutoff=cutoff, mindim=mindim)
+      tdim = length(P)
+      nc = size(M, 2)
+      Vs[n - 1] = Matrix{ValType}(V[1:nc, 1:tdim])
+    end
+  end
+
+  llinks = Vector{Index{Int}}(undef, N + 1)
+  llinks[1] = Index(2, "Link,l=0")
+
+  H = MPO(sites)
+
+  for n in 1:N
+    VL = Matrix{ValType}(undef, 1, 1)
+    if n > 1
+      VL = Vs[n - 1]
+    end
+    VR = Vs[n]
+    tdim = size(VR, 2)
+
+    llinks[n + 1] = Index(2 + tdim, "Link,l=$n")
+
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    H[n] = ITensor()
+
+    for el in tempMPO[n]
+      A_row = el.row
+      A_col = el.col
+      t = el.val
+      (abs(coefficient(t)) > eps()) || continue
+
+      M = zeros(ValType, dim(ll), dim(rl))
+
+      ct = convert(ValType, coefficient(t))
+      if A_row == -1 && A_col == -1 #onsite term
+        M[end, 1] += ct
+      elseif A_row == -1 #term starting on site n
+        for c in 1:size(VR, 2)
+          z = ct * VR[A_col, c]
+          M[end, 1 + c] += z
+        end
+      elseif A_col == -1 #term ending on site n
+        for r in 1:size(VL, 2)
+          z = ct * conj(VL[A_row, r])
+          M[1 + r, 1] += z
+        end
+      else
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          z = ct * conj(VL[A_row, r]) * VR[A_col, c]
+          M[1 + r, 1 + c] += z
+        end
+      end
+
+      T = itensor(M, ll, rl)
+      H[n] += T * computeSiteProd(sites, argument(t))
+    end
+
+    #
+    # Special handling of starting and 
+    # ending identity operators:
+    #
+    idM = zeros(ValType, dim(ll), dim(rl))
+    idM[1, 1] = 1.0
+    idM[end, end] = 1.0
+    T = itensor(idM, ll, rl)
+    H[n] += T * computeSiteProd(sites, Prod([Op("Id", n)]))
+  end
+
+  L = ITensor(llinks[1])
+  L[end] = 1.0
+
+  R = ITensor(llinks[N + 1])
+  R[1] = 1.0
+
+  H[1] *= L
+  H[N] *= R
+
+  return H
+end #svdMPO
+
+function qn_svdMPO(os::OpSum{C}, sites; kwargs...)::MPO where {C}
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, 10000)
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(data(os))
+
+  Vs = [Dict{QN,Matrix{ValType}}() for n in 1:(N + 1)]
+  tempMPO = [QNMatElem{Scaled{C,Prod{Op}}}[] for n in 1:N]
+
+  crosses_bond(t::Scaled{C,Prod{Op}}, n::Int) where {C} = (site(t[1]) <= n <= site(t[end]))
+
+  rightmap = Dict{Pair{Prod{Op},QN},Int}()
+  next_rightmap = Dict{Pair{Prod{Op},QN},Int}()
+
+  # A cache of the ITensor operators on a certain site
+  # of a certain type
+  op_cache = Dict{Pair{String,Int},ITensor}()
+
+  for n in 1:N
+    leftbond_coefs = Dict{QN,Vector{MatElem{ValType}}}()
+
+    leftmap = Dict{Pair{Prod{Op},QN},Int}()
+    for term in data(os)
+      crosses_bond(term, n) || continue
+
+      left::Prod{Op} = filter(t -> (site(t) < n), data(term))
+      onsite::Prod{Op} = filter(t -> (site(t) == n), data(term))
+      right::Prod{Op} = filter(t -> (site(t) > n), data(term))
+
+      function calcQN(term::Prod{Op})
+        q = QN()
+        for st in term
+          op_tensor = get(op_cache, name(st) => site(st), nothing)
+          if op_tensor === nothing
+            op_tensor = op(sites[site(st)], name(st); params(st)...)
+            op_cache[name(st) => site(st)] = op_tensor
+          end
+          q -= flux(op_tensor)
+        end
+        return q
+      end
+      lqn = calcQN(left)
+      sqn = calcQN(onsite)
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left => lqn)
+        bond_col = posInLink!(rightmap, onsite * right => lqn)
+        bond_coef = convert(ValType, coefficient(term))
+        q_leftbond_coefs = get!(leftbond_coefs, lqn, MatElem{ValType}[])
+        push!(q_leftbond_coefs, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      rqn = sqn + lqn
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right => rqn)
+      site_coef = 1.0 + 0.0im
+      if A_row == -1
+        site_coef = coefficient(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, Op("F", n))
+        else
+          push!(onsite, Op("Id", n))
+        end
+      end
+      el = QNMatElem(lqn, rqn, A_row, A_col, MPOTerm(site_coef, onsite))
+      push!(tempMPO[n], el)
+    end
+    rightmap = next_rightmap
+    next_rightmap = Dict{Pair{Prod{Op},QN},Int}()
+
+    remove_dups!(tempMPO[n])
+
+    if n > 1 && !isempty(leftbond_coefs)
+      for (q, mat) in leftbond_coefs
+        M = toMatrix(mat)
+        U, S, V = svd(M)
+        P = S .^ 2
+        truncate!(P; maxdim=maxdim, cutoff=cutoff, mindim=mindim)
+        tdim = length(P)
+        nc = size(M, 2)
+        Vs[n][q] = Matrix{ValType}(V[1:nc, 1:tdim])
+      end
+    end
+  end
+
+  #
+  # Make MPO link indices
+  #
+  d0 = 2
+  llinks = Vector{QNIndex}(undef, N + 1)
+  # Set dir=In for fermionic ordering, avoid arrow sign
+  # <fermions>:
+  linkdir = using_auto_fermion() ? In : Out
+  llinks[1] = Index(QN() => d0; tags="Link,l=0", dir=linkdir)
+  for n in 1:N
+    qi = Vector{Pair{QN,Int}}()
+    if !haskey(Vs[n + 1], QN())
+      # Make sure QN=zero is first in list of sectors
+      push!(qi, QN() => d0)
+    end
+    for (q, Vq) in Vs[n + 1]
+      cols = size(Vq, 2)
+      if q == QN()
+        # Make sure QN=zero is first in list of sectors
+        insert!(qi, 1, q => d0 + cols)
+      else
+        if using_auto_fermion() # <fermions>
+          push!(qi, (-q) => cols)
+        else
+          push!(qi, q => cols)
+        end
+      end
+    end
+    # Set dir=In for fermionic ordering, avoid arrow sign
+    # <fermions>:
+    llinks[n + 1] = Index(qi...; tags="Link,l=$n", dir=linkdir)
+  end
+
+  H = MPO(N)
+
+  # Constants which define MPO start/end scheme
+  startState = 2
+  endState = 1
+
+  for n in 1:N
+    finalMPO = Dict{Tuple{QN,Prod{Op}},Matrix{ValType}}()
+
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    function defaultMat(ll, rl, lqn, rqn)
+      #ldim = qnblockdim(ll,lqn)
+      #rdim = qnblockdim(rl,rqn)
+      ldim = blockdim(ll, lqn)
+      rdim = blockdim(rl, rqn)
+      return zeros(ValType, ldim, rdim)
+    end
+
+    idTerm = [Op("Id", n)]
+    finalMPO[(QN(), idTerm)] = defaultMat(ll, rl, QN(), QN())
+    idM = finalMPO[(QN(), idTerm)]
+    idM[1, 1] = 1.0
+    idM[2, 2] = 1.0
+
+    for el in tempMPO[n]
+      t = el.val
+      (abs(coefficient(t)) > eps()) || continue
+      A_row = el.row
+      A_col = el.col
+
+      M = get!(finalMPO, (el.rowqn, data(t)), defaultMat(ll, rl, el.rowqn, el.colqn))
+
+      # rowShift and colShift account for
+      # special entries in the zero-QN sector
+      # of the MPO
+      rowShift = (el.rowqn == QN()) ? 2 : 0
+      colShift = (el.colqn == QN()) ? 2 : 0
+
+      ct = convert(ValType, coefficient(t))
+      if A_row == -1 && A_col == -1 #onsite term
+        M[startState, endState] += ct
+      elseif A_row == -1 #term starting on site n
+        VR = Vs[n + 1][el.colqn]
+        for c in 1:size(VR, 2)
+          z = ct * VR[A_col, c]
+          M[startState, colShift + c] += z
+        end
+      elseif A_col == -1 #term ending on site n
+        VL = Vs[n][el.rowqn]
+        for r in 1:size(VL, 2)
+          z = ct * conj(VL[A_row, r])
+          M[rowShift + r, endState] += z
+        end
+      else
+        VL = Vs[n][el.rowqn]
+        VR = Vs[n + 1][el.colqn]
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          z = ct * conj(VL[A_row, r]) * VR[A_col, c]
+          M[rowShift + r, colShift + c] += z
+        end
+      end
+    end
+
+    s = sites[n]
+    H[n] = ITensor()
+    for (q_op, M) in finalMPO
+      op_prod = q_op[2]
+      Op = computeSiteProd(sites, op_prod)
+
+      rq = q_op[1]
+      sq = flux(Op)
+      cq = rq - sq
+
+      if using_auto_fermion()
+        # <fermions>:
+        # MPO is defined with Index order
+        # of (rl,s[n]',s[n],cl) where rl = row link, cl = col link
+        # so compute sign that would result by permuting cl from
+        # second position to last position:
+        if fparity(sq) == 1 && fparity(cq) == 1
+          Op .*= -1
+        end
+      end
+
+      rn = qnblocknum(ll, rq)
+      cn = qnblocknum(rl, cq)
+
+      #TODO: wrap following 3 lines into a function
+      _block = Block(rn, cn)
+      T = BlockSparseTensor(ValType, [_block], (dag(ll), rl))
+      #blockview(T, _block) .= M
+      T[_block] .= M
+
+      IT = itensor(T)
+      H[n] += IT * Op
+    end
+  end
+
+  L = ITensor(llinks[1])
+  L[startState] = 1.0
+
+  R = ITensor(dag(llinks[N + 1]))
+  R[endState] = 1.0
+
+  H[1] *= L
+  H[N] *= R
+
+  return H
+end #qn_svdMPO
+
+function sorteachterm(os::OpSum, sites)
+  os = copy(os)
+  isless_site(o1::Op, o2::Op) = site(o1) < site(o2)
+  N = length(sites)
+  for t in os
+
+    @show t
+
+    Nt = length(t)
+    prevsite = N + 1 #keep track of whether we are switching
+    #to a new site to make sure F string
+    #is only placed at most once for each site
+
+    # Sort operators in t by site order,
+    # and keep the permutation used, perm, for analysis below
+    perm = Vector{Int}(undef, Nt)
+    sortperm!(perm, data(t); alg=InsertionSort, lt=isless_site)
+
+    t = coefficient(t) * Prod(data(t)[perm])
+
+    # Identify fermionic operators,
+    # zeroing perm for bosonic operators,
+    # and inserting string "F" operators
+    parity = +1
+    for n in Nt:-1:1
+      currsite = site(t[n])
+      fermionic = has_fermion_string(which_op(t[n]), sites[only(site(t[n]))])
+      if !using_auto_fermion() && (parity == -1) && (currsite < prevsite)
+        # Put local piece of Jordan-Wigner string emanating
+        # from fermionic operators to the right
+        # (Remaining F operators will be put in by svdMPO)
+        t.ops[n] = Op("$(which_op(t[n])) * F", site(t[n]))
+      end
+      prevsite = currsite
+
+      if fermionic
+        parity = -parity
+      else
+        # Ignore bosonic operators in perm
+        # by zeroing corresponding entries
+        perm[n] = 0
+      end
+    end
+    if parity == -1
+      error("Parity-odd fermionic terms not yet supported by AutoMPO")
+    end
+
+    # Keep only fermionic op positions (non-zero entries)
+    filter!(!iszero, perm)
+    # and account for anti-commuting, fermionic operators 
+    # during above sort; put resulting sign into coef
+    t *= parity_sign(perm)
+  end
+  return os
+end
+
+function check_numerical_opsum(os::OpSum)
+  for mpoterm in os
+    operators = data(mpoterm)
+    for operator in which_op.(operators)
+      operator isa Array{<:Number} && return true
+    end
+  end
+  return false
+end
+
+function sortmergeterms(os::OpSum{C}) where {C}
+  check_numerical_opsum(os) && return os
+  os_data = sort(data(os))
+  # Merge (add) terms with same operators
+  ## da = data(os)
+  merge_os_data = Scaled{C,Prod{Op}}[]
+  last_term = copy(os[1])
+  last_term_coef = coefficient(last_term)
+  for n in 2:length(os)
+    if argument(os[n]) == argument(last_term)
+      last_term_coef += coefficient(os[n])
+    else
+      last_term = last_term_coef * argument(last_term)
+      push!(merge_os_data, last_term)
+      last_term = os[n]
+      last_term_coef = coefficient(last_term)
+    end
+  end
+  push!(merge_os_data, last_term)
+  # setdata!(os, ndata)
+  os = Sum(merge_os_data)
+  return os
+end
+
+"""
+    MPO(os::OpSum,sites::Vector{<:Index};kwargs...)
+       
+Convert an OpSum object `os` to an
+MPO, with indices given by `sites`. The
+resulting MPO will have the indices
+`sites[1], sites[1]', sites[2], sites[2]'`
+etc. The conversion is done by an algorithm
+that compresses the MPO resulting from adding
+the OpSum terms together, often achieving
+the minimum possible bond dimension.
+
+# Examples
+```julia
+os = OpSum()
+os += ("Sz",1,"Sz",2)
+os += ("Sz",2,"Sz",3)
+os += ("Sz",3,"Sz",4)
+
+sites = siteinds("S=1/2",4)
+H = MPO(os,sites)
+```
+"""
+function MPO(os::OpSum, sites::Vector{<:Index}; kwargs...)::MPO
+  length(data(os)) == 0 && error("OpSum has no terms")
+
+  os = deepcopy(os)
+  sorteachterm(os, sites)
+  os = sortmergeterms(os)
+
+  if hasqns(sites[1])
+    return qn_svdMPO(os, sites; kwargs...)
+  end
+  return svdMPO(os, sites; kwargs...)
+end
diff --git a/src/physics/autompo/opsum_to_mpo_generic.jl b/src/physics/autompo/opsum_to_mpo_generic.jl
new file mode 100644
index 0000000000..4792913e5b
--- /dev/null
+++ b/src/physics/autompo/opsum_to_mpo_generic.jl
@@ -0,0 +1,252 @@
+const AutoMPO = OpSum
+
+function add!(os::OpSum, o::Scaled{C,Prod{Op}}) where {C}
+  push!(terms(os), o)
+  return os
+end
+add!(os::OpSum, o::Op) = add!(os, Prod{Op}() * o)
+add!(os::OpSum, o::Scaled{C,Op}) where {C} = add!(os, Prod{Op}() * o)
+add!(os::OpSum, o::Prod{Op}) = add!(os, one(Float64) * o)
+add!(os::OpSum, o::Tuple) = add!(os, Ops.op_term(o))
+add!(os::OpSum, a1::String, args...) = add!(os, (a1, args...))
+add!(os::OpSum, a1::Number, args...) = add!(os, (a1, args...))
+subtract!(os::OpSum, o::Tuple) = add!(os, -Ops.op_term(o))
+
+function isfermionic(t::Vector{Op}, sites)
+  p = +1
+  for op in t
+    if has_fermion_string(name(op), sites[site(op)])
+      p *= -1
+    end
+  end
+  return (p == -1)
+end
+
+#
+# Abuse broadcasting syntax for in-place addition:
+#
+# os .+= ("Sz",1)
+# os .-= ("Sz",1)
+#
+# TODO: Deprecate this syntax?
+#
+
+struct OpSumStyle <: Broadcast.BroadcastStyle end
+Base.BroadcastStyle(::Type{<:OpSum}) = OpSumStyle()
+
+struct OpSumAddTermStyle <: Broadcast.BroadcastStyle end
+
+Base.broadcastable(os::OpSum) = os
+
+Base.BroadcastStyle(::OpSumStyle, ::Broadcast.Style{Tuple}) = OpSumAddTermStyle()
+
+Broadcast.instantiate(bc::Broadcast.Broadcasted{OpSumAddTermStyle}) = bc
+
+function Base.copyto!(os, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(+)})
+  add!(os, bc.args[2])
+  return os
+end
+
+function Base.copyto!(os, bc::Broadcast.Broadcasted{OpSumAddTermStyle,<:Any,typeof(-)})
+  subtract!(os, bc.args[2])
+  return os
+end
+
+# XXX: Create a new function name for this.
+isempty(op_qn::Pair{Vector{Op},QN}) = isempty(op_qn.first)
+
+# the key type is Prod{Op} for the dense case
+# and is Pair{Prod{Op},QN} for the QN conserving case
+function posInLink!(linkmap::Dict{K,Int}, k::K)::Int where {K}
+  isempty(k) && return -1
+  pos = get(linkmap, k, -1)
+  if pos == -1
+    pos = length(linkmap) + 1
+    linkmap[k] = pos
+  end
+  return pos
+end
+
+# TODO: Define as `C`. Rename `coefficient_type`.
+function determineValType(terms::Vector{Scaled{C,Prod{Op}}}) where {C}
+  for t in terms
+    (!isreal(coefficient(t))) && return ComplexF64
+  end
+  return Float64
+end
+
+function computeSiteProd(sites, ops::Prod{Op})::ITensor
+  i = only(site(ops[1]))
+  T = op(sites[i], which_op(ops[1]); params(ops[1])...)
+  for j in 2:length(ops)
+    (only(site(ops[j])) != i) && error("Mismatch of site number in computeSiteProd")
+    opj = op(sites[i], which_op(ops[j]); params(ops[j])...)
+    T = product(T, opj)
+  end
+  return T
+end
+
+function remove_dups!(v::Vector{T}) where {T}
+  N = length(v)
+  (N == 0) && return nothing
+  sort!(v)
+  n = 1
+  u = 2
+  while u <= N
+    while u < N && v[u] == v[n]
+      u += 1
+    end
+    if v[u] != v[n]
+      v[n + 1] = v[u]
+      n += 1
+    end
+    u += 1
+  end
+  resize!(v, n)
+  return nothing
+end #remove_dups!
+
+function sorteachterm(os::OpSum, sites)
+  os = copy(os)
+  isless_site(o1::Op, o2::Op) = site(o1) < site(o2)
+  N = length(sites)
+  for n in eachindex(os)
+    t = os[n]
+    Nt = length(t)
+
+    if maximum(ITensors.sites(t)) > length(sites)
+      error(
+        "The OpSum contains a term $t that extends beyond the number of sites $(length(sites)).",
+      )
+    end
+
+    prevsite = N + 1 #keep track of whether we are switching
+    #to a new site to make sure F string
+    #is only placed at most once for each site
+
+    # Sort operators in t by site order,
+    # and keep the permutation used, perm, for analysis below
+    perm = Vector{Int}(undef, Nt)
+    sortperm!(perm, terms(t); alg=InsertionSort, lt=isless_site)
+
+    t = coefficient(t) * Prod(terms(t)[perm])
+
+    # Identify fermionic operators,
+    # zeroing perm for bosonic operators,
+    # and inserting string "F" operators
+    parity = +1
+    for n in Nt:-1:1
+      currsite = site(t[n])
+      fermionic = has_fermion_string(which_op(t[n]), sites[only(site(t[n]))])
+      if !using_auto_fermion() && (parity == -1) && (currsite < prevsite)
+        # Put local piece of Jordan-Wigner string emanating
+        # from fermionic operators to the right
+        # (Remaining F operators will be put in by svdMPO)
+        terms(t)[n] = Op("$(which_op(t[n])) * F", only(site(t[n])))
+      end
+      prevsite = currsite
+
+      if fermionic
+        parity = -parity
+      else
+        # Ignore bosonic operators in perm
+        # by zeroing corresponding entries
+        perm[n] = 0
+      end
+    end
+    if parity == -1
+      error("Parity-odd fermionic terms not yet supported by AutoMPO")
+    end
+
+    # Keep only fermionic op positions (non-zero entries)
+    filter!(!iszero, perm)
+    # and account for anti-commuting, fermionic operators 
+    # during above sort; put resulting sign into coef
+    t *= parity_sign(perm)
+    terms(os)[n] = t
+  end
+  return os
+end
+
+function sortmergeterms(os::OpSum{C}) where {C}
+  os_sorted_terms = sort(terms(os))
+  os = Sum(os_sorted_terms)
+  # Merge (add) terms with same operators
+  merge_os_data = Scaled{C,Prod{Op}}[]
+  last_term = copy(os[1])
+  last_term_coef = coefficient(last_term)
+  for n in 2:length(os)
+    if argument(os[n]) == argument(last_term)
+      last_term_coef += coefficient(os[n])
+      last_term = last_term_coef * argument(last_term)
+    else
+      push!(merge_os_data, last_term)
+      last_term = os[n]
+      last_term_coef = coefficient(last_term)
+    end
+  end
+  push!(merge_os_data, last_term)
+  os = Sum(merge_os_data)
+  return os
+end
+
+"""
+    MPO(os::OpSum,sites::Vector{<:Index};kwargs...)
+       
+Convert an OpSum object `os` to an
+MPO, with indices given by `sites`. The
+resulting MPO will have the indices
+`sites[1], sites[1]', sites[2], sites[2]'`
+etc. The conversion is done by an algorithm
+that compresses the MPO resulting from adding
+the OpSum terms together, often achieving
+the minimum possible bond dimension.
+
+# Examples
+```julia
+os = OpSum()
+os += ("Sz",1,"Sz",2)
+os += ("Sz",2,"Sz",3)
+os += ("Sz",3,"Sz",4)
+
+sites = siteinds("S=1/2",4)
+H = MPO(os,sites)
+```
+"""
+function MPO(os::OpSum, sites::Vector{<:Index}; kwargs...)::MPO
+  length(terms(os)) == 0 && error("OpSum has no terms")
+
+  os = deepcopy(os)
+  os = sorteachterm(os, sites)
+  os = sortmergeterms(os)
+
+  if hasqns(sites[1])
+    return qn_svdMPO(os, sites; kwargs...)
+  end
+  return svdMPO(os, sites; kwargs...)
+end
+
+# Conversion from other formats
+function MPO(o::Op, s::Vector{<:Index}; kwargs...)
+  return MPO(OpSum{Float64}() + o, s; kwargs...)
+end
+
+function MPO(o::Scaled{C,Op}, s::Vector{<:Index}; kwargs...) where {C}
+  return MPO(OpSum{C}() + o, s; kwargs...)
+end
+
+function MPO(o::Sum{Op}, s::Vector{<:Index}; kwargs...) where {C}
+  return MPO(OpSum{Float64}() + o, s; kwargs...)
+end
+
+function MPO(o::Prod{Op}, s::Vector{<:Index}; kwargs...) where {C}
+  return MPO(OpSum{Float64}() + o, s; kwargs...)
+end
+
+function MPO(o::Scaled{C,Prod{Op}}, s::Vector{<:Index}; kwargs...) where {C}
+  return MPO(OpSum{C}() + o, s; kwargs...)
+end
+
+function MPO(o::Sum{Scaled{C,Op}}, s::Vector{<:Index}; kwargs...) where {C}
+  return MPO(OpSum{C}() + o, s; kwargs...)
+end
diff --git a/src/physics/autompo/opsum_to_mpo_qn.jl b/src/physics/autompo/opsum_to_mpo_qn.jl
new file mode 100644
index 0000000000..667bd2fec1
--- /dev/null
+++ b/src/physics/autompo/opsum_to_mpo_qn.jl
@@ -0,0 +1,247 @@
+function qn_svdMPO(os::OpSum{C}, sites; kwargs...)::MPO where {C}
+  mindim::Int = get(kwargs, :mindim, 1)
+  maxdim::Int = get(kwargs, :maxdim, typemax(Int))
+  cutoff::Float64 = get(kwargs, :cutoff, 1E-15)
+
+  N = length(sites)
+
+  ValType = determineValType(terms(os))
+
+  Vs = [Dict{QN,Matrix{ValType}}() for n in 1:(N + 1)]
+  sparse_MPO = [QNMatElem{Scaled{C,Prod{Op}}}[] for n in 1:N]
+
+  function crosses_bond(t::Scaled{C,Prod{Op}}, n::Int)
+    return (only(site(t[1])) <= n <= only(site(t[end])))
+  end
+
+  # A cache of the ITensor operators on a certain site
+  # of a certain type
+  op_cache = Dict{Pair{String,Int},ITensor}()
+  function calcQN(term::Vector{Op})
+    q = QN()
+    for st in term
+      op_tensor = get(op_cache, which_op(st) => only(site(st)), nothing)
+      if op_tensor === nothing
+        op_tensor = op(sites[only(site(st))], which_op(st); params(st)...)
+        op_cache[which_op(st) => only(site(st))] = op_tensor
+      end
+      q -= flux(op_tensor)
+    end
+    return q
+  end
+
+  Hflux = -calcQN(terms(first(terms(os))))
+
+  rightmap = Dict{Pair{Vector{Op},QN},Int}()
+  next_rightmap = Dict{Pair{Vector{Op},QN},Int}()
+
+  for n in 1:N
+    h_sparse = Dict{QN,Vector{MatElem{ValType}}}()
+
+    leftmap = Dict{Pair{Vector{Op},QN},Int}()
+    for term in os
+      crosses_bond(term, n) || continue
+
+      left = filter(t -> (only(site(t)) < n), terms(term))
+      onsite = filter(t -> (only(site(t)) == n), terms(term))
+      right = filter(t -> (only(site(t)) > n), terms(term))
+
+      lqn = calcQN(left)
+      sqn = calcQN(onsite)
+
+      bond_row = -1
+      bond_col = -1
+      if !isempty(left)
+        bond_row = posInLink!(leftmap, left => lqn)
+        bond_col = posInLink!(rightmap, vcat(onsite, right) => lqn)
+        bond_coef = convert(ValType, coefficient(term))
+        q_h_sparse = get!(h_sparse, lqn, MatElem{ValType}[])
+        push!(q_h_sparse, MatElem(bond_row, bond_col, bond_coef))
+      end
+
+      rqn = sqn + lqn
+      A_row = bond_col
+      A_col = posInLink!(next_rightmap, right => rqn)
+      site_coef = one(C)
+      if A_row == -1
+        site_coef = coefficient(term)
+      end
+      if isempty(onsite)
+        if !using_auto_fermion() && isfermionic(right, sites)
+          push!(onsite, Op("F", n))
+        else
+          push!(onsite, Op("Id", n))
+        end
+      end
+      el = QNMatElem(lqn, rqn, A_row, A_col, site_coef * Prod(onsite))
+      push!(sparse_MPO[n], el)
+    end
+    remove_dups!(sparse_MPO[n])
+
+    if n > 1 && !isempty(h_sparse)
+      for (q, mat) in h_sparse
+        h = toMatrix(mat)
+        U, S, V = svd(h)
+        P = S .^ 2
+        truncate!(P; maxdim, cutoff, mindim)
+        tdim = length(P)
+        Vs[n][q] = Matrix{ValType}(V[:, 1:tdim])
+      end
+    end
+
+    rightmap = next_rightmap
+    next_rightmap = Dict{Pair{Vector{Op},QN},Int}()
+  end
+
+  #
+  # Make MPO link indices
+  #
+  llinks = Vector{QNIndex}(undef, N + 1)
+  # Set dir=In for fermionic ordering, avoid arrow sign
+  # <fermions>:
+  linkdir = using_auto_fermion() ? In : Out
+  llinks[1] = Index([QN() => 1, Hflux => 1]; tags="Link,l=0", dir=linkdir)
+  for n in 1:N
+    qi = Vector{Pair{QN,Int}}()
+    push!(qi, QN() => 1)
+    for (q, Vq) in Vs[n + 1]
+      cols = size(Vq, 2)
+      if using_auto_fermion() # <fermions>
+        push!(qi, (-q) => cols)
+      else
+        push!(qi, q => cols)
+      end
+    end
+    push!(qi, Hflux => 1)
+    llinks[n + 1] = Index(qi...; tags="Link,l=$n", dir=linkdir)
+  end
+
+  H = MPO(N)
+
+  # Find location where block of Index i
+  # matches QN q, but *not* 1 or dim(i)
+  # which are special ending/starting states
+  function qnblock(i::Index, q::QN)
+    for b in 2:(nblocks(i) - 1)
+      flux(i, Block(b)) == q && return b
+    end
+    return error("Could not find block of QNIndex with matching QN")
+  end
+  qnblockdim(i::Index, q::QN) = blockdim(i, qnblock(i, q))
+
+  for n in 1:N
+    ll = llinks[n]
+    rl = llinks[n + 1]
+
+    begin_block = Dict{Tuple{QN,Vector{Op}},Matrix{ValType}}()
+    cont_block = Dict{Tuple{QN,Vector{Op}},Matrix{ValType}}()
+    end_block = Dict{Tuple{QN,Vector{Op}},Matrix{ValType}}()
+    onsite_block = Dict{Tuple{QN,Vector{Op}},Matrix{ValType}}()
+
+    for el in sparse_MPO[n]
+      t = el.val
+      (abs(coefficient(t)) > eps()) || continue
+      A_row = el.row
+      A_col = el.col
+      ct = convert(ValType, coefficient(t))
+
+      ldim = (A_row == -1) ? 1 : qnblockdim(ll, el.rowqn)
+      rdim = (A_col == -1) ? 1 : qnblockdim(rl, el.colqn)
+      zero_mat() = zeros(ValType, ldim, rdim)
+
+      if A_row == -1 && A_col == -1
+        # Onsite term
+        M = get!(onsite_block, (el.rowqn, terms(t)), zeros(ValType, 1, 1))
+        M[1, 1] += ct
+      elseif A_row == -1
+        # Operator beginning a term on site n
+        M = get!(begin_block, (el.rowqn, terms(t)), zero_mat())
+        VR = Vs[n + 1][el.colqn]
+        for c in 1:size(VR, 2)
+          M[1, c] += ct * VR[A_col, c]
+        end
+      elseif A_col == -1
+        # Operator ending a term on site n
+        M = get!(end_block, (el.rowqn, terms(t)), zero_mat())
+        VL = Vs[n][el.rowqn]
+        for r in 1:size(VL, 2)
+          M[r, 1] += ct * conj(VL[A_row, r])
+        end
+      else
+        # Operator continuing a term on site n
+        M = get!(cont_block, (el.rowqn, terms(t)), zero_mat())
+        VL = Vs[n][el.rowqn]
+        VR = Vs[n + 1][el.colqn]
+        for r in 1:size(VL, 2), c in 1:size(VR, 2)
+          M[r, c] += ct * conj(VL[A_row, r]) * VR[A_col, c]
+        end
+      end
+    end
+
+    H[n] = ITensor()
+
+    # Helper functions to compute block locations
+    # of various blocks within the onsite blocks,
+    # begin blocks, etc.
+    loc_onsite(rq, cq) = Block(nblocks(ll), 1)
+    loc_begin(rq, cq) = Block(nblocks(ll), qnblock(rl, cq))
+    loc_cont(rq, cq) = Block(qnblock(ll, rq), qnblock(rl, cq))
+    loc_end(rq, cq) = Block(qnblock(ll, rq), 1)
+
+    for (loc, block) in (
+      (loc_onsite, onsite_block),
+      (loc_begin, begin_block),
+      (loc_end, end_block),
+      (loc_cont, cont_block),
+    )
+      for (q_op, M) in block
+        op_prod = q_op[2]
+        Op = computeSiteProd(sites, Prod(op_prod))
+
+        rq = q_op[1]
+        sq = flux(Op)
+        cq = rq - sq
+
+        if using_auto_fermion()
+          # <fermions>:
+          # MPO is defined with Index order
+          # of (rl,s[n]',s[n],cl) where rl = row link, cl = col link
+          # so compute sign that would result by permuting cl from
+          # second position to last position:
+          if fparity(sq) == 1 && fparity(cq) == 1
+            Op .*= -1
+          end
+        end
+
+        b = loc(rq, cq)
+        T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+        T[b] .= M
+
+        H[n] += (itensor(T) * Op)
+      end
+    end
+
+    # Put in ending identity operator
+    Id = op("Id", sites[n])
+    b = Block(1, 1)
+    T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+    T[b] = 1
+    H[n] += (itensor(T) * Id)
+
+    # Put in starting identity operator
+    b = Block(nblocks(ll), nblocks(rl))
+    T = BlockSparseTensor(ValType, [b], (dag(ll), rl))
+    T[b] = 1
+    H[n] += (itensor(T) * Id)
+  end # for n in 1:N
+
+  L = ITensor(llinks[1])
+  L[llinks[1] => end] = 1.0
+  H[1] *= L
+
+  R = ITensor(dag(llinks[N + 1]))
+  R[dag(llinks[N + 1]) => 1] = 1.0
+  H[N] *= R
+
+  return H
+end #qn_svdMPO
diff --git a/src/physics/autompo/qnmatelem.jl b/src/physics/autompo/qnmatelem.jl
new file mode 100644
index 0000000000..7ec55c4aae
--- /dev/null
+++ b/src/physics/autompo/qnmatelem.jl
@@ -0,0 +1,30 @@
+struct QNMatElem{T}
+  rowqn::QN
+  colqn::QN
+  row::Int
+  col::Int
+  val::T
+end
+
+function Base.:(==)(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  return (
+    m1.row == m2.row &&
+    m1.col == m2.col &&
+    m1.val == m2.val &&
+    m1.rowqn == m2.rowqn &&
+    m1.colqn == m2.colqn
+  )
+end
+
+function Base.isless(m1::QNMatElem{T}, m2::QNMatElem{T})::Bool where {T}
+  if m1.rowqn != m2.rowqn
+    return m1.rowqn < m2.rowqn
+  elseif m1.colqn != m2.colqn
+    return m1.colqn < m2.colqn
+  elseif m1.row != m2.row
+    return m1.row < m2.row
+  elseif m1.col != m2.col
+    return m1.col < m2.col
+  end
+  return m1.val < m2.val
+end
diff --git a/src/physics/fermions.jl b/src/physics/fermions.jl
index ef7e0d749b..574b830200 100644
--- a/src/physics/fermions.jl
+++ b/src/physics/fermions.jl
@@ -79,7 +79,9 @@ according to p, then return -1. Otherwise return +1.
 function compute_permfactor(p, iv_or_qn...; range=1:length(iv_or_qn))::Int
   using_auto_fermion() || return 1
   N = length(iv_or_qn)
-  oddp = @MVector zeros(Int, N)
+  # XXX: Bug https://github.com/ITensor/ITensors.jl/issues/931
+  # oddp = @MVector zeros(Int, N)
+  oddp = MVector((ntuple(Returns(0), Val(N))))
   n = 0
   @inbounds for j in range
     if fparity(iv_or_qn[p[j]]) == 1
diff --git a/src/physics/site_types/generic_sites.jl b/src/physics/site_types/generic_sites.jl
index 9e03ce1704..a72b3345d7 100644
--- a/src/physics/site_types/generic_sites.jl
+++ b/src/physics/site_types/generic_sites.jl
@@ -1,11 +1,45 @@
-function op!(Op::ITensor, ::OpName"Id", ::SiteType"Generic", s::Index)
-  for n in 1:dim(s)
-    Op[n, n] = 1.0
-  end
+function op!(
+  o::ITensor, ::OpName"Id", ::SiteType"Generic", s1::Index, sn::Index...; eltype=Float64
+)
+  s = (s1, sn...)
+  n = prod(dim.(s))
+  t = itensor(Matrix(one(eltype) * I, n, n), prime.(s)..., dag.(s)...)
+  return settensor!(o, tensor(t))
 end
 
-op(::OpName"I", t::SiteType"Generic", s::Index) = op("Id", s)
+function op!(o::ITensor, ::OpName"I", st::SiteType"Generic", s::Index...; kwargs...)
+  return op!(o, OpName("Id"), st, s...; kwargs...)
+end
+
+function op!(o::ITensor, ::OpName"F", st::SiteType"Generic", s::Index; kwargs...)
+  return op!(o, OpName("Id"), st, s; kwargs...)
+end
+
+function default_random_matrix(eltype::Type, s::Index...)
+  n = prod(dim.(s))
+  return randn(eltype, n, n)
+end
+
+# Haar-random unitary
+#
+# Reference:
+# Section 4.6
+# http://math.mit.edu/~edelman/publications/random_matrix_theory.pdf
+function op!(
+  o::ITensor,
+  ::OpName"RandomUnitary",
+  ::SiteType"Generic",
+  s1::Index,
+  sn::Index...;
+  eltype=ComplexF64,
+  random_matrix=default_random_matrix(eltype, s1, sn...),
+)
+  s = (s1, sn...)
+  Q, _ = NDTensors.qr_positive(random_matrix)
+  t = itensor(Q, prime.(s)..., dag.(s)...)
+  return settensor!(o, tensor(t))
+end
 
-function op!(Op::ITensor, ::OpName"F", st::SiteType"Generic", s::Index)
-  return op!(Op, OpName("Id"), st, s)
+function op!(o::ITensor, ::OpName"randU", st::SiteType"Generic", s::Index...; kwargs...)
+  return op!(o, OpName("RandomUnitary"), st, s...; kwargs...)
 end
diff --git a/src/physics/site_types/qubit.jl b/src/physics/site_types/qubit.jl
index 89422a717c..fd15b0a77d 100644
--- a/src/physics/site_types/qubit.jl
+++ b/src/physics/site_types/qubit.jl
@@ -59,13 +59,19 @@ ITensors.state(::StateName"↓", t::SiteType"Qubit") = state(StateName("1"), t)
 
 # Pauli eingenstates
 ITensors.state(::StateName"X+", t::SiteType"Qubit") = state(StateName("+"), t)
+ITensors.state(::StateName"Xp", t::SiteType"Qubit") = state(StateName("+"), t)
 ITensors.state(::StateName"X-", t::SiteType"Qubit") = state(StateName("-"), t)
+ITensors.state(::StateName"Xm", t::SiteType"Qubit") = state(StateName("-"), t)
 
 ITensors.state(::StateName"Y+", t::SiteType"Qubit") = state(StateName("i"), t)
+ITensors.state(::StateName"Yp", t::SiteType"Qubit") = state(StateName("i"), t)
 ITensors.state(::StateName"Y-", t::SiteType"Qubit") = state(StateName("-i"), t)
+ITensors.state(::StateName"Ym", t::SiteType"Qubit") = state(StateName("-i"), t)
 
 ITensors.state(::StateName"Z+", t::SiteType"Qubit") = state(StateName("0"), t)
+ITensors.state(::StateName"Zp", t::SiteType"Qubit") = state(StateName("0"), t)
 ITensors.state(::StateName"Z-", t::SiteType"Qubit") = state(StateName("1"), t)
+ITensors.state(::StateName"Zm", t::SiteType"Qubit") = state(StateName("1"), t)
 
 # SIC-POVMs
 state(::StateName"Tetra1", t::SiteType"Qubit") = state(StateName("Z+"), t)
diff --git a/src/physics/site_types/qudit.jl b/src/physics/site_types/qudit.jl
index b8d06b266d..d9f336016e 100644
--- a/src/physics/site_types/qudit.jl
+++ b/src/physics/site_types/qudit.jl
@@ -1,4 +1,3 @@
-
 """
     space(::SiteType"Qudit";
           dim = 2,
@@ -34,17 +33,24 @@ function ITensors.state(::StateName{N}, ::SiteType"Qudit", s::Index) where {N}
   return itensor(st, s)
 end
 
-function _op(::OpName"Id", ::SiteType"Qudit"; dim=2)
-  mat = zeros(dim, dim)
-  for k in 1:dim
+# one-body operators
+function _op(::OpName"Id", ::SiteType"Qudit"; dim::Tuple=(2,))
+  d = dim[1]
+  mat = zeros(d, d)
+  for k in 1:d
     mat[k, k] = 1.0
   end
   return mat
 end
 
-function _op(::OpName"Adag", ::SiteType"Qudit"; dim=2)
-  mat = zeros(dim, dim)
-  for k in 1:(dim - 1)
+function _op(::OpName"I", st::SiteType"Qudit"; kwargs...)
+  return _op(OpName"Id"(), st; kwargs...)
+end
+
+function _op(::OpName"Adag", ::SiteType"Qudit"; dim::Tuple=(2,))
+  d = dim[1]
+  mat = zeros(d, d)
+  for k in 1:(d - 1)
     mat[k + 1, k] = √k
   end
   return mat
@@ -52,28 +58,56 @@ end
 _op(::OpName"adag", st::SiteType"Qudit"; kwargs...) = _op(OpName"Adag"(), st; kwargs...)
 _op(::OpName"a†", st::SiteType"Qudit"; kwargs...) = _op(OpName"Adag"(), st; kwargs...)
 
-function _op(::OpName"A", ::SiteType"Qudit"; dim=2)
-  mat = zeros(dim, dim)
-  for k in 1:(dim - 1)
+function _op(::OpName"A", ::SiteType"Qudit"; dim::Tuple=(2,))
+  d = dim[1]
+  mat = zeros(d, d)
+  for k in 1:(d - 1)
     mat[k, k + 1] = √k
   end
   return mat
 end
 _op(::OpName"a", st::SiteType"Qudit"; kwargs...) = _op(OpName"A"(), st; kwargs...)
 
-function _op(::OpName"N", ::SiteType"Qudit"; dim=2)
-  mat = zeros(dim, dim)
-  for k in 1:dim
+function _op(::OpName"N", ::SiteType"Qudit"; dim::Tuple=(2,))
+  d = dim[1]
+  mat = zeros(d, d)
+  for k in 1:d
     mat[k, k] = k - 1
   end
   return mat
 end
 _op(::OpName"n", st::SiteType"Qudit"; kwargs...) = _op(OpName"N"(), st; kwargs...)
 
-function ITensors.op(on::OpName, st::SiteType"Qudit", s::Index)
-  return itensor(_op(on, st; dim=dim(s)), s', dag(s))
+# two-body operators 
+function _op(::OpName"ab", st::SiteType"Qudit"; dim::Tuple=(2, 2))
+  return kron(_op(OpName("a"), st; dim=(dim[1],)), _op(OpName("a"), st; dim=(dim[2],)))
+end
+
+function _op(::OpName"a†b", st::SiteType"Qudit"; dim::Tuple=(2, 2))
+  return kron(_op(OpName("a†"), st; dim=(dim[1],)), _op(OpName("a"), st; dim=(dim[2],)))
+end
+
+function _op(::OpName"ab†", st::SiteType"Qudit"; dim::Tuple=(2, 2))
+  return kron(_op(OpName("a"), st; dim=(dim[1],)), _op(OpName("a†"), st; dim=(dim[2],)))
+end
+
+function _op(::OpName"a†b†", st::SiteType"Qudit"; dim::Tuple=(2, 2))
+  return kron(_op(OpName("a†"), st; dim=(dim[1],)), _op(OpName("a†"), st; dim=(dim[2],)))
+end
+
+# interface
+function op(on::OpName, st::SiteType"Qudit", s::Index...)
+  rs = reverse([s...])
+  d⃗ = dim.(Tuple(rs))
+  opmat = _op(on, st; dim=d⃗)
+  return ITensors.itensor(opmat, prime.(rs)..., dag.(rs)...)
 end
 
-@non_differentiable _op(::OpName"A", ::SiteType"Qudit")
-@non_differentiable _op(::OpName"Adag", ::SiteType"Qudit")
+# Zygote
+@non_differentiable _op(::OpName"ab", ::SiteType"Qudit")
+@non_differentiable _op(::OpName"a†b", ::SiteType"Qudit")
+@non_differentiable _op(::OpName"ab†", ::SiteType"Qudit")
+@non_differentiable _op(::OpName"a†b†", ::SiteType"Qudit")
+@non_differentiable _op(::OpName"a", ::SiteType"Qudit")
+@non_differentiable _op(::OpName"a†", ::SiteType"Qudit")
 @non_differentiable _op(::OpName"N", ::SiteType"Qudit")
diff --git a/src/physics/sitetype.jl b/src/physics/sitetype.jl
index bfff831e3e..36034fd9ce 100644
--- a/src/physics/sitetype.jl
+++ b/src/physics/sitetype.jl
@@ -28,15 +28,16 @@ the notation: `SiteType("MyTag")`
 There are currently a few built-in site types
 recognized by `ITensors.jl`. The system is easily extensible
 by users. To add new operators to an existing site type,
-you can follow the instructions [here](http://itensor.org/docs.cgi?vers=julia&page=formulas/sitetype_extending).
-To create new site types, you can follow the instructions
-[here](https://itensor.org/docs.cgi?vers=julia&page=formulas/sitetype_basic) and 
-[here](https://itensor.org/docs.cgi?vers=julia&page=formulas/sitetype_qns).
+or to create new site types, you can follow the instructions
+[here](https://itensor.github.io/ITensors.jl/stable/examples/Physics.html).
 
 The current built-in site types are:
 
 - `SiteType"S=1/2"` (or `SiteType"S=½"`)
 - `SiteType"S=1"`
+- `SiteType"Qubit"`
+- `SiteType"Qudit"`
+- `SiteType"Boson"`
 - `SiteType"Fermion"`
 - `SiteType"tJ"`
 - `SiteType"Electron"`
@@ -217,6 +218,9 @@ operators to MPS.
 s = Index(2, "Site,S=1/2")
 Sz = op("Sz", s)
 ```
+
+To see all of the operator names defined for the site types included with
+ITensor, please [view the source code for each site type](https://github.com/ITensor/ITensors.jl/tree/main/src/physics/site_types). Note that some site types such as "S=1/2" and "Qubit" are aliases for each other and share operator definitions.
 """
 function op(name::AbstractString, s::Index...; adjoint::Bool=false, kwargs...)
   name = strip(name)
@@ -267,7 +271,7 @@ function op(name::AbstractString, s::Index...; adjoint::Bool=false, kwargs...)
       op1 = name[1:prevind(name, oploc.start)]
       op2 = name[nextind(name, oploc.start):end]
       if !(op1[end] == ' ' && op2[1] == ' ')
-        @warn "composite op definition `A*B` deprecated: please use `A * B` instead (with spaces)"
+        @warn "($op1*$op2) composite op definition `A*B` deprecated: please use `A * B` instead (with spaces)"
       end
     end
     return product(op(op1, s...; kwargs...), op(op2, s...; kwargs...))
@@ -361,8 +365,10 @@ function op(name::AbstractString, s::Index...; adjoint::Bool=false, kwargs...)
       end
     end
 
-    error(
-      "Older op interface does not support multiple indices with mixed site types. You may want to overload `op(::OpName, ::SiteType..., ::Index...)` or `op!(::ITensor, ::OpName, ::SiteType..., ::Index...) for the operator \"$name\" and Index tags $(tags.(s)).",
+    throw(
+      ArgumentError(
+        "Overload of \"op\" or \"op!\" functions not found for operator name \"$name\" and Index tags: $(tags.(s)).",
+      ),
     )
   end
 
@@ -384,20 +390,22 @@ function op(name::AbstractString, s::Index...; adjoint::Bool=false, kwargs...)
 
   return throw(
     ArgumentError(
-      "Overload of \"op\" or \"op!\" functions not found for operator name \"$name\" and Index tags: $(commontags_s))",
+      "Overload of \"op\" or \"op!\" functions not found for operator name \"$name\" and Index tags: $(tags.(s)).",
     ),
   )
 end
 
-op(X::AbstractArray, s::Vector{<:Index}) = op(X, s...)
-
+# If a Matrix is passed instead of a String, turn the Matrix into
+# an ITensor with the given indices.
 op(X::AbstractArray, s::Index...) = itensor(X, prime.([s...]), dag.([s...]))
 
-op(s::Index, X::AbstractArray; kwargs...) = op(X, s; kwargs...)
+op(opname, s::Vector{<:Index}; kwargs...) = op(opname, s...; kwargs...)
+
+op(s::Vector{<:Index}, opname; kwargs...) = op(opname, s...; kwargs...)
 
 # For backwards compatibility, version of `op`
 # taking the arguments in the other order:
-op(s::Index, opname::AbstractString; kwargs...) = op(opname, s; kwargs...)
+op(s::Index, opname; kwargs...) = op(opname, s; kwargs...)
 
 # To ease calling of other op overloads,
 # allow passing a string as the op name
@@ -417,40 +425,51 @@ s = siteinds("S=1/2", 4)
 Sz2 = op("Sz", s, 2)
 ```
 """
-function op(
-  opname::AbstractString, s::Vector{<:Index}, ns::NTuple{N,Integer}; kwargs...
-) where {N}
+function op(opname, s::Vector{<:Index}, ns::NTuple{N,Integer}; kwargs...) where {N}
   return op(opname, ntuple(n -> s[ns[n]], Val(N))...; kwargs...)
 end
 
-function op(opname::AbstractString, s::Vector{<:Index}, ns::Vararg{Integer}; kwargs...)
+function op(opname, s::Vector{<:Index}, ns::Vararg{Integer}; kwargs...)
   return op(opname, s, ns; kwargs...)
 end
 
-function op(
-  s::Vector{<:Index}, opname::AbstractString, ns::Tuple{Vararg{Integer}}; kwargs...
-)
+function op(s::Vector{<:Index}, opname, ns::Tuple{Vararg{Integer}}; kwargs...)
   return op(opname, s, ns...; kwargs...)
 end
 
-function op(s::Vector{<:Index}, opname::AbstractString, ns::Integer...; kwargs...)
+function op(s::Vector{<:Index}, opname, ns::Integer...; kwargs...)
   return op(opname, s, ns; kwargs...)
 end
 
-function op(
-  s::Vector{<:Index}, opname::AbstractString, ns::Tuple{Vararg{Integer}}, kwargs::NamedTuple
-)
+function op(s::Vector{<:Index}, opname, ns::Tuple{Vararg{Integer}}, kwargs::NamedTuple)
   return op(opname, s, ns; kwargs...)
 end
 
-function op(s::Vector{<:Index}, opname::AbstractString, ns::Integer, kwargs::NamedTuple)
+function op(s::Vector{<:Index}, opname, ns::Integer, kwargs::NamedTuple)
   return op(opname, s, (ns,); kwargs...)
 end
 
-# This version helps with call like `op.(Ref(s), os)` where `os`
-# is a vector of tuples.
-op(s::Vector{<:Index}, os::Tuple{AbstractString,Vararg}) = op(s, os...)
-op(os::Tuple{AbstractString,Vararg}, s::Vector{<:Index}) = op(s, os...)
+op(s::Vector{<:Index}, o::Tuple) = op(s, o...)
+
+op(o::Tuple, s::Vector{<:Index}) = op(s, o...)
+
+op(f::Function, args...; kwargs...) = f(op(args...; kwargs...))
+
+function op(
+  s::Vector{<:Index},
+  f::Function,
+  opname::AbstractString,
+  ns::Tuple{Vararg{Integer}};
+  kwargs...,
+)
+  return f(op(opname, s, ns...; kwargs...))
+end
+
+function op(
+  s::Vector{<:Index}, f::Function, opname::AbstractString, ns::Integer...; kwargs...
+)
+  return f(op(opname, s, ns; kwargs...))
+end
 
 # Here, Ref is used to not broadcast over the vector of indices
 # TODO: consider overloading broadcast for `op` with the example
@@ -673,7 +692,10 @@ siteind(tag::String, n; kwargs...) = siteind(SiteType(tag), n; kwargs...)
 
 # Special case of `siteind` where integer (dim) provided
 # instead of a tag string
-siteind(d::Integer, n::Integer; kwargs...) = Index(d, "Site,n=$n")
+#siteind(d::Integer, n::Integer; kwargs...) = Index(d, "Site,n=$n")
+function siteind(d::Integer, n::Integer; addtags="", kwargs...)
+  return Index(d, "Site,n=$n, $addtags")
+end
 
 #---------------------------------------
 #
@@ -684,12 +706,19 @@ siteind(d::Integer, n::Integer; kwargs...) = Index(d, "Site,n=$n")
 siteinds(::SiteType, N; kwargs...) = nothing
 
 """
-  siteinds(tag::String, N::Integer; kwargs...)
+    siteinds(tag::String, N::Integer; kwargs...)
 
 Create an array of `N` physical site indices of type `tag`.
 Keyword arguments can be used to specify quantum number conservation,
 see the `space` function corresponding to the site type `tag` for
 supported keyword arguments.
+
+# Example
+
+```julia
+N = 10
+s = siteinds("S=1/2", N; conserve_qns=true)
+```
 """
 function siteinds(tag::String, N::Integer; kwargs...)
   st = SiteType(tag)
@@ -703,7 +732,7 @@ function siteinds(tag::String, N::Integer; kwargs...)
 end
 
 """
-  siteinds(f::Function, N::Integer; kwargs...)
+    siteinds(f::Function, N::Integer; kwargs...)
 
 Create an array of `N` physical site indices where the site type at site `n` is given
 by `f(n)` (`f` should return a string).
@@ -714,6 +743,14 @@ end
 
 # Special case of `siteinds` where integer (dim)
 # provided instead of a tag string
+"""
+    siteinds(d::Integer, N::Integer; kwargs...)
+
+Create an array of `N` site indices, each of dimension `d`.
+
+# Keywords
+- `addtags::String`: additional tags to be added to all indices
+"""
 function siteinds(d::Integer, N::Integer; kwargs...)
   return [siteind(d, n; kwargs...) for n in 1:N]
 end
diff --git a/src/qn/qn.jl b/src/qn/qn.jl
index 8c2d1e04ec..85d03447b8 100644
--- a/src/qn/qn.jl
+++ b/src/qn/qn.jl
@@ -1,4 +1,3 @@
-
 struct QNVal
   name::SmallString
   val::Int
@@ -357,6 +356,29 @@ function have_same_mods(qn1::QN, qn2::QN)
   return true
 end
 
+function removeqn(qn::QN, qn_name::String)
+  ss_qn_name = SmallString(qn_name)
+
+  # Find the location of the QNVal to remove
+  n_qn = nothing
+  for n in 1:length(qn)
+    qnval = qn[n]
+    if name(qnval) == ss_qn_name
+      n_qn = n
+    end
+  end
+  if isnothing(n_qn)
+    return qn
+  end
+
+  qn_data = data(qn)
+  for j in n_qn:(length(qn) - 1)
+    qn_data = setindex(qn_data, qn_data[j + 1], j)
+  end
+  qn_data = setindex(qn_data, QNVal(), length(qn))
+  return QN(qn_data)
+end
+
 function show(io::IO, q::QN)
   print(io, "QN(")
   Na = nactive(q)
diff --git a/src/qn/qnindex.jl b/src/qn/qnindex.jl
index 4974a9711f..1385176dfe 100644
--- a/src/qn/qnindex.jl
+++ b/src/qn/qnindex.jl
@@ -8,6 +8,8 @@ qn(qnblock::QNBlock) = qnblock.first
 # Get the dimension of the specified block
 blockdim(qnblock::QNBlock) = qnblock.second
 
+NDTensors.resize(qnblock::QNBlock, newdim::Int64) = QNBlock(qnblock.first, newdim)
+
 # Get the dimension of the specified block
 blockdim(qnblocks::QNBlocks, b::Integer) = blockdim(qnblocks[b])
 blockdim(qnblocks::QNBlocks, b::Block{1}) = blockdim(qnblocks[only(b)])
@@ -35,6 +37,10 @@ function (qn1::QNBlock + qn2::QNBlock)
   return QNBlock(qn(qn1), blockdim(qn1) + blockdim(qn2))
 end
 
+function removeqn(qn_block::QNBlock, qn_name::String)
+  return removeqn(qn(qn_block), qn_name) => blockdim(qn_block)
+end
+
 function -(qns::QNBlocks)
   qns_new = copy(qns)
   for i in 1:length(qns_new)
@@ -43,6 +49,30 @@ function -(qns::QNBlocks)
   return qns_new
 end
 
+function mergeblocks(qns::QNBlocks)
+  qnsC = [qns[1]]
+
+  # Which block this is, after combining
+  block_count = 1
+  for i in 2:nblocks(qns)
+    if qn(qns[i]) == qn(qns[i - 1])
+      qnsC[block_count] += qns[i]
+    else
+      push!(qnsC, qns[i])
+      block_count += 1
+    end
+  end
+  return qnsC
+end
+
+function removeqn(space::QNBlocks, qn_name::String; mergeblocks=true)
+  space = QNBlocks([removeqn(qn_block, qn_name) for qn_block in space])
+  if mergeblocks
+    space = ITensors.mergeblocks(space)
+  end
+  return space
+end
+
 """
 A QN Index is an Index with QN block storage instead of
 just an integer dimension. The QN block storage is a 
@@ -138,6 +168,21 @@ end
 
 dim(i::QNIndex) = dim(space(i))
 
+"""
+    nblocks(i::QNIndex)
+
+Returns the number of QN blocks, or subspaces, of the QNIndex `i`.
+
+To obtain the dimension of block number `b`, use `blockdim(i,b)`.
+To obtain the QN associated with block `b`, use `qn(i,b)`.
+
+### Example
+```
+julia> i = Index([QN("Sz",-1)=>2, QN("Sz",0)=>4, QN("Sz",1)=>2], "i")
+julia> nblocks(i)
+3
+```
+"""
 nblocks(i::QNIndex) = nblocks(space(i))
 # Define to be 1 for non-QN Index
 nblocks(i::Index) = 1
@@ -171,6 +216,22 @@ qn(i::QNIndex, b::Block{1}) = qn(space(i), b)
 qn(ib::Pair{<:Index,Block{1}}) = qn(first(ib), last(ib))
 
 # XXX: deprecate the Integer version
+# Miles asks: isn't it pretty convenient to have it?
+"""
+    qn(i::QNIndex, b::Integer)
+
+Returns the QN associated with block number `b` of 
+a QNIndex `i`.
+
+### Example
+```
+julia> i = Index([QN("Sz",-1)=>2, QN("Sz",0)=>4, QN("Sz",1)=>2], "i")
+julia> qn(i,1)
+QN("Sz",-1)
+julia> qn(i,2)
+QN("Sz",0)
+```
+"""
 qn(i::QNIndex, b::Integer) = qn(i, Block(b))
 
 # Get the QN of the block the IndexVal lies in
@@ -191,7 +252,24 @@ end
 qnblocks(i::QNIndex) = space(i)
 
 # XXX: deprecate the Integer version
+# Miles asks: isn't the integer version very convenient?
 blockdim(i::QNIndex, b::Block) = blockdim(space(i), b)
+
+"""
+    blockdim(i::QNIndex, b::Integer)
+
+Returns the dimension of block number `b` of
+a QNIndex `i`.
+
+### Example
+```
+julia> i = Index([QN("Sz",-1)=>2, QN("Sz",0)=>4, QN("Sz",1)=>2], "i")
+julia> blockdim(i,1)
+2
+julia> blockdim(i,2)
+4
+```
+"""
 blockdim(i::QNIndex, b::Integer) = blockdim(i, Block(b))
 function blockdim(i::Index, b::Union{Block,Integer})
   return error(
@@ -357,6 +435,8 @@ end
 # Make a new Index with the specified qn blocks
 replaceqns(i::QNIndex, qns::QNBlocks) = setspace(i, qns)
 
+NDTensors.block(i::QNIndex, n::Integer) = space(i)[n]
+
 function setblockdim!(i::QNIndex, newdim::Integer, n::Integer)
   qns = space(i)
   qns[n] = qn(qns[n]) => newdim
@@ -369,6 +449,12 @@ function setblockqn!(i::QNIndex, newqn::QN, n::Integer)
   return i
 end
 
+function setblock!(i::QNIndex, b::QNBlock, n::Integer)
+  qns = space(i)
+  qns[n] = b
+  return i
+end
+
 function deleteat!(i::QNIndex, pos)
   deleteat!(space(i), pos)
   return i
@@ -386,6 +472,10 @@ function combineblocks(i::QNIndex)
 end
 
 removeqns(i::QNIndex) = setdir(setspace(i, dim(i)), Neither)
+function removeqn(i::QNIndex, qn_name::String; mergeblocks=true)
+  return setspace(i, removeqn(space(i), qn_name; mergeblocks))
+end
+mergeblocks(i::QNIndex) = setspace(i, mergeblocks(space(i)))
 
 function addqns(i::Index, qns::QNBlocks; dir::Arrow=Out)
   @assert dim(i) == dim(qns)
@@ -428,6 +518,8 @@ hassameflux(::Index, ::QNIndex) = false
 # Split the blocks into blocks of size 1 with the same QNs
 splitblocks(i::Index) = setspace(i, splitblocks(space(i)))
 
+trivial_space(i::QNIndex) = [QN() => 1]
+
 function mutable_storage(::Type{Order{N}}, ::Type{IndexT}) where {N,IndexT<:QNIndex}
   return SizedVector{N,IndexT}(undef)
 end
diff --git a/src/qn/qnindexset.jl b/src/qn/qnindexset.jl
index 4a7ebed730..22bd8dfdff 100644
--- a/src/qn/qnindexset.jl
+++ b/src/qn/qnindexset.jl
@@ -29,8 +29,6 @@ function nzdiagblocks(qn::QN, inds::Indices)
   return blocks
 end
 
-removeqns(is::QNIndices) = map(i -> removeqns(i), is)
-
 anyfermionic(is::Indices) = any(isfermionic, is)
 
 allfermionic(is::Indices) = all(isfermionic, is)
diff --git a/src/qn/qnitensor.jl b/src/qn/qnitensor.jl
index 7302147bb7..18a729a657 100644
--- a/src/qn/qnitensor.jl
+++ b/src/qn/qnitensor.jl
@@ -467,6 +467,9 @@ function δ_split(i1::Index, i2::Index)
 end
 
 function splitblocks(A::ITensor, is=inds(A); tol=0)
+  if !hasqns(A)
+    return A
+  end
   isA = filterinds(A; inds=is)
   for i in isA
     i_split = splitblocks(i)
@@ -481,3 +484,17 @@ function splitblocks(A::ITensor, is=inds(A); tol=0)
   A = dropzeros(A; tol=tol)
   return A
 end
+
+function removeqn(T::ITensor, qn_name::String; mergeblocks=true)
+  if !hasqns(T)
+    return T
+  end
+  inds_R = removeqn(inds(T), qn_name; mergeblocks)
+  R = ITensor(inds_R)
+  for iv in eachindex(T)
+    if !iszero(T[iv])
+      R[iv] = T[iv]
+    end
+  end
+  return R
+end
diff --git a/src/smallstring.jl b/src/smallstring.jl
index 83676e6848..a98f3efe4b 100644
--- a/src/smallstring.jl
+++ b/src/smallstring.jl
@@ -1,9 +1,8 @@
-
 const IntChar = UInt16
-const IntSmallString = UInt128
+const IntSmallString = UInt256
 
 # XXX: remove smallLength as a global constant, bad for type inference
-const smallLength = 8
+const smallLength = 16
 const SmallStringStorage = SVector{smallLength,IntChar}
 const MSmallStringStorage = MVector{smallLength,IntChar}
 
diff --git a/src/tagset.jl b/src/tagset.jl
index fbd629721e..0bf8fecbe4 100644
--- a/src/tagset.jl
+++ b/src/tagset.jl
@@ -1,15 +1,16 @@
+using BitIntegers
 
-const IntTag = UInt128  # An integer that can be cast to a Tag
-const MTagStorage = MVector{8,IntTag} # A mutable tag storage, holding 8 characters
+const IntTag = UInt256  # An integer that can be cast to a Tag
+const MTagStorage = MVector{16,IntTag} # A mutable tag storage, holding 16 characters
 const TagSetStorage{T,N} = SVector{N,T}
 const MTagSetStorage{T,N} = MVector{N,T}  # A mutable tag storage
 
 emptytag(::Type{IntTag}) = IntTag(0)
 function empty_storage(::Type{TagSetStorage{T,N}}) where {T,N}
-  return TagSetStorage(ntuple(_ -> emptytag(T), N))
+  return TagSetStorage(ntuple(_ -> emptytag(T), Val(N)))
 end
 function empty_storage(::Type{MTagSetStorage{T,N}}) where {T,N}
-  return MTagSetStorage(ntuple(_ -> emptytag(T), N))
+  return MTagSetStorage(ntuple(_ -> emptytag(T), Val(N)))
 end
 
 #TODO: decide which functions on TagSet should be made generic.
diff --git a/src/utils.jl b/src/utils.jl
new file mode 100644
index 0000000000..8fff71a060
--- /dev/null
+++ b/src/utils.jl
@@ -0,0 +1,28 @@
+
+# Warn only once, using the message `msg`.
+# `funcsym` is a symbol that determines if the warning has been
+# called before (so there is only one warning per `funcsym`).
+function warn_once(msg, funcsym; force=true, stacktrace=true)
+  if stacktrace
+    io = IOBuffer()
+    Base.show_backtrace(io, backtrace())
+    backtrace_string = String(take!(io))
+    backtrace_string *= "\n"
+    msg *= backtrace_string
+  end
+  Base.depwarn(msg, funcsym; force)
+  return nothing
+end
+
+# Directory helper functions (useful for
+# running examples)
+src_dir() = dirname(pathof(@__MODULE__))
+pkg_dir() = joinpath(src_dir(), "..")
+examples_dir() = joinpath(pkg_dir(), "examples")
+
+# Determine version and uuid of the package
+function _parse_project_toml(field::String)
+  return Pkg.TOML.parsefile(joinpath(pkg_dir(), "Project.toml"))[field]
+end
+version() = VersionNumber(_parse_project_toml("version"))
+uuid() = Base.UUID(_parse_project_toml("uuid"))
diff --git a/test/ITensorChainRules/runtests.jl b/test/ITensorChainRules/runtests.jl
index cbbefca761..8196276555 100644
--- a/test/ITensorChainRules/runtests.jl
+++ b/test/ITensorChainRules/runtests.jl
@@ -1,4 +1,5 @@
 using Test
+using ITensors
 
 starts_and_ends_with(file, st, en) = startswith(file, st) && endswith(file, en)
 starts_and_ends_with(st, en) = file -> starts_and_ends_with(file, st, en)
diff --git a/test/ITensorChainRules/test_chainrules.jl b/test/ITensorChainRules/test_chainrules.jl
index 8763c0fe3b..d7899d9224 100644
--- a/test/ITensorChainRules/test_chainrules.jl
+++ b/test/ITensorChainRules/test_chainrules.jl
@@ -18,10 +18,11 @@ Random.seed!(1234)
   Ac = randomITensor(ComplexF64, i', dag(i))
   B = randomITensor(i', dag(i))
   C = ITensor(3.4)
+  D = randomITensor(i', j)
 
   test_rrule(getindex, ITensor(3.4); check_inferred=false)
   test_rrule(getindex, A, 1, 2; check_inferred=false)
-  test_rrule(*, A', A; check_inferred=false)
+  test_rrule(contract, A', A; check_inferred=false)
   test_rrule(*, 3.2, A; check_inferred=false)
   test_rrule(*, A, 4.3; check_inferred=false)
   test_rrule(+, A, B; check_inferred=false)
@@ -29,17 +30,29 @@ Random.seed!(1234)
   test_rrule(prime, A, 2; check_inferred=false)
   test_rrule(prime, A; fkwargs=(; tags="i"), check_inferred=false)
   test_rrule(prime, A; fkwargs=(; tags="x"), check_inferred=false)
+  test_rrule(setprime, D, 2; check_inferred=false)
+  test_rrule(noprime, D; check_inferred=false)
   test_rrule(replaceprime, A, 1 => 2; check_inferred=false)
+  test_rrule(replaceprime, A, 1, 2; check_inferred=false)
   test_rrule(swapprime, A, 0 => 1; check_inferred=false)
+  test_rrule(swapprime, A, 0, 1; check_inferred=false)
   test_rrule(addtags, A, "x"; check_inferred=false)
   test_rrule(addtags, A, "x"; fkwargs=(; plev=1), check_inferred=false)
   test_rrule(removetags, A, "i"; check_inferred=false)
   test_rrule(replacetags, A, "i" => "j"; check_inferred=false)
+  test_rrule(replacetags, A, "i", "j"; check_inferred=false)
+  test_rrule(settags, A, "x"; check_inferred=false)
+  test_rrule(settags, A, "x"; fkwargs=(; plev=1), check_inferred=false)
   test_rrule(
     swaptags, randomITensor(Index(2, "i"), Index(2, "j")), "i" => "j"; check_inferred=false
   )
+  test_rrule(
+    swaptags, randomITensor(Index(2, "i"), Index(2, "j")), "i", "j"; check_inferred=false
+  )
   test_rrule(replaceind, A, i' => sim(i); check_inferred=false)
+  test_rrule(replaceind, A, i', sim(i); check_inferred=false)
   test_rrule(replaceinds, A, (i, i') => (sim(i), sim(i)); check_inferred=false)
+  test_rrule(replaceinds, A, (i, i'), (sim(i), sim(i)); check_inferred=false)
   test_rrule(swapind, A, i', i; check_inferred=false)
   test_rrule(swapinds, A, (i',), (i,); check_inferred=false)
   test_rrule(itensor, randn(2, 2), i', i; check_inferred=false)
@@ -53,7 +66,7 @@ Random.seed!(1234)
   test_rrule(permute, A, reverse(inds(A)); check_inferred=false)
 
   test_rrule(ZygoteRuleConfig(), apply, A, V; rrule_f=rrule_via_ad, check_inferred=false)
-  function f(A, B)
+  f = function (A, B)
     AT = ITensor(A, i, j)
     BT = ITensor(B, j, i)
     return (BT * AT)[1]
@@ -65,24 +78,39 @@ Random.seed!(1234)
   args = (rand(4), rand(2, 2))
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
 
-  f = function (x)
-    b = itensor([0, 0, 1, 1], i, j)
-    k = itensor([0, 1, 0, 0], i, j)
-    T = itensor([0 x x^2 1; 0 0 sin(x) 0; 0 cos(x) 0 exp(x); x 0 0 0], i', j', i, j)
-    return x * real((b' * T * k)[])
-  end
-  args = (0.3,)
+  a, b, k, l, m, n, u, v = Index.([10, 50, 5, 2, 10, 12, 7, 50])
+  args = (
+    randomITensor(a, b, k),
+    randomITensor(a, l, m),
+    randomITensor(b, u, n),
+    randomITensor(u, v),
+    randomITensor(k, v),
+    randomITensor(l, m, n),
+  )
+  f = (args...) -> contract([args...])[] # Left associative
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+  seq = ITensors.optimal_contraction_sequence([args...])
+  f = (args...) -> contract([args...]; sequence=seq)[] # sequence
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
 
   f = function (x)
     b = itensor([0, 0, 1, 1], i, j)
     k = itensor([0, 1, 0, 0], i, j)
-    T = itensor([0 x x^2 1; 0 0 sin(x) 0; 0 cos(x) 0 exp(x); x 0 0 0], i, j, i', j')
+    T = itensor([0 x x^2 1; 0 0 sin(x) 0; 0 cos(x) 0 exp(x); x 0 0 0], i', j', i, j)
     return x * real((b' * T * k)[])
   end
   args = (0.3,)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
 
+  #f = function (x)
+  #  b = itensor([0, 0, 1, 1], i, j)
+  #  k = itensor([0, 1, 0, 0], i, j)
+  #  T = itensor([0 x x^2 1; 0 0 sin(x) 0; 0 cos(x) 0 exp(x); x 0 0 0], i, j, i', j')
+  #  return x * real((b' * T * k)[])
+  #end
+  #args = (0.3,)
+  #test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
   f = x -> sin(scalar(x)^3)
   args = (C,)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
@@ -189,15 +217,15 @@ Random.seed!(1234)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
   args = (2.8 + 3.1im,)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
-  f = function f(x)
+  f = function (x)
     v = itensor([exp(-3.2x), cos(2x^2)], j)
     T = itensor([x^2 sin(x); x^2 exp(-2x)], j', dag(j))
     return real((dag(v') * T * v)[])
   end
   args = (2.8,)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
-  args = (2.8 + 3.1im,)
-  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+  #args = (2.8 + 3.1im,)
+  #test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
   f = function (x)
     return real((x^3 * ITensor([sin(x) exp(-2x); 3x^3 x+x^2], j', dag(j)))[1, 1])
   end
@@ -208,7 +236,7 @@ Random.seed!(1234)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
   f = x -> prime(x; plev=1)[1, 1]
   args = (A,)
-  @test_throws ErrorException f'(args...)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
 
   W = itensor([1 1] / √2, i)
   f = x -> inner(W', exp(x), W)
@@ -222,25 +250,42 @@ Random.seed!(1234)
     rtol=1e-3,
     atol=1e-3,
   )
-end
 
-@testset "MPS rrules" begin
-  s = siteinds("S=1/2", 2)
-  ψ = randomMPS(s)
-
-  args = (ψ,)
-  f = x -> inner(x', x')
-  # TODO: Need to make MPS type compatible with FiniteDifferences.
-  #test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
-  d_args = gradient(f, args...)
-  @test norm(d_args[1] - 2 * args[1]) ≈ 0 atol = 1e-13
+  f = x -> inner(V', exp(x), V)
+  args = (A,)
+  test_rrule(
+    ZygoteRuleConfig(),
+    f,
+    args...;
+    rrule_f=rrule_via_ad,
+    check_inferred=false,
+    rtol=1e-4,
+    atol=1e-4,
+  )
 
-  args = (ψ,)
-  f = x -> inner(prime(x), prime(x))
-  # TODO: Need to make MPS type compatible with FiniteDifferences.
-  #test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
-  d_args = gradient(f, args...)
-  @test norm(d_args[1] - 2 * args[1]) ≈ 0 atol = 1e-13
+  # https://github.com/ITensor/ITensors.jl/issues/933
+  f2 = function (x, a)
+    y = a + im * x
+    return real(dag(y) * y)[]
+  end
+  a = randomITensor()
+  f_itensor = x -> f2(x, a)
+  f_number = x -> f2(x, a[])
+  x = randomITensor()
+  @test f_number(x[]) ≈ f_itensor(x)
+  @test f_number'(x[]) ≈ f_itensor'(x)[]
+  @test isreal(f_itensor'(x))
+
+  # https://github.com/ITensor/ITensors.jl/issues/936
+  n = 2
+  s = siteinds("S=1/2", n)
+  x = (x -> outer(x', x))(randomMPS(s))
+  f1 = x -> tr(x)
+  f2 = x -> 2tr(x)
+  f3 = x -> -tr(x)
+  @test f1'(x) ≈ MPO(s, "I")
+  @test f2'(x) ≈ 2MPO(s, "I")
+  @test f3'(x) ≈ -MPO(s, "I")
 end
 
 @testset "ChainRules rrules: op" begin
@@ -371,6 +416,26 @@ end
   #  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
   #end
 
+  # functions
+  f = x -> exp(ITensor(Op("Ry", 1; θ=x), q))[1, 1]
+
+  # RX
+  args = (0.2,)
+  for σ in [1, 2], σ′ in [1, 2]
+    f = x -> exp(ITensor(Op("Rx", 1; θ=x), s))[σ, σ′]
+    test_rrule(
+      ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false, atol=1e-6
+    )
+  end
+
+  # RY
+  args = (0.2,)
+  for σ in [1, 2], σ′ in [1, 2]
+    f = x -> exp(ITensor(Op("Ry", 1; θ=x), s))[σ, σ′]
+    test_rrule(
+      ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false, atol=1e-6
+    )
+  end
 end
 
 @testset "MPS ($ElType)" for ElType in (Float64, ComplexF64)
@@ -415,7 +480,7 @@ end
   f = function (x)
     U = [op("Ry", s[2]; θ=x), op("CX", s[1], s[2]), op("Rx", s[3]; θ=x)]
     ψθ = apply(U, ψ)
-    return real(inner(ϕ, ψθ))
+    return abs2(inner(ϕ, ψθ))
   end
   θ = 0.5
   ∇f = f'(θ)
@@ -423,7 +488,78 @@ end
   @test ∇f ≈ ∇num atol = 1e-5
 end
 
-@testset "MPO" begin
+@testset "MPS rrules" begin
+  Random.seed!(1234)
+  s = siteinds("S=1/2", 4)
+  ψ = randomMPS(s)
+  args = (ψ,)
+  f = x -> inner(x, x)
+  # TODO: Need to make MPS type compatible with FiniteDifferences.
+  #test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+  d_args = gradient(f, args...)
+  @test norm(d_args[1] - 2 * args[1]) ≈ 0 atol = 1e-13
+
+  args = (ψ,)
+  f = x -> inner(prime(x), prime(x))
+  # TODO: Need to make MPS type compatible with FiniteDifferences.
+  #test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+  d_args = gradient(f, args...)
+  @test norm(d_args[1] - 2 * args[1]) ≈ 0 atol = 1e-13
+
+  ψ = randomMPS(ComplexF64, s)
+  ψtensors = ITensors.data(ψ)
+  ϕ = randomMPS(ComplexF64, s)
+  f = function (x)
+    ψ̃tensors = [x^j * ψtensors[j] for j in 1:length(ψtensors)]
+    ψ̃ = MPS(ψ̃tensors)
+    return abs2(inner(ϕ, ψ̃))
+  end
+  x = 0.5
+  ϵ = 1e-10
+  @test f'(x) ≈ (f(x + ϵ) - f(x)) / ϵ atol = 1e-6
+
+  ρ = randomMPO(s)
+  f = function (x)
+    ψ̃tensors = [x^j * ψtensors[j] for j in 1:length(ψtensors)]
+    ψ̃ = MPS(ψ̃tensors)
+    return real(inner(ψ̃', ρ, ψ̃))
+  end
+  @test f'(x) ≈ (f(x + ϵ) - f(x)) / ϵ atol = 1e-6
+end
+
+#@testset "MPO rules" begin
+#  Random.seed!(1234)
+#  s = siteinds("S=1/2", 2)
+#  
+#  #ρ = randomMPO(s)
+#  #ρtensors = ITensors.data(ρ)
+#  #ϕ = randomMPS(ComplexF64, s)
+#  #f = function (x)
+#  #  ρ̃tensors  = [2 * x * ρtensors[1],  log(x) * ρtensors[2]] 
+#  #  ρ̃ = MPO(ρ̃tensors)
+#  #  #@show typeof(ρ̃)
+#  #  return real(inner(ϕ', ρ̃, ϕ))
+#  #end
+#  #x = 3.0
+#  #ϵ = 1e-8
+#  #@show (f(x+ϵ) - f(x)) / ϵ
+#  #@show f'(x)
+#  ##@test f'(x) ≈ (f(x+ϵ) - f(x)) / ϵ atol = 1e-6 
+#  #
+#
+#  #ϕ = randomMPO(s)
+#  #f = function (x)
+#  #  ψ̃tensors  = [2 * x * ψtensors[1],  log(x) * ψtensors[2]] 
+#  #  ψ̃ = MPS(ψ̃tensors)
+#  #  return abs2(inner(ϕ, ψ̃))
+#  #end
+#  #x = 3.0
+#  #ϵ = 1e-8
+#  #@test f'(x) ≈ (f(x+ϵ) - f(x)) / ϵ atol = 1e-6 
+#
+#  #ρ = randomMPO(s)
+#end
+@testset "MPO: apply" begin
   Random.seed!(1234)
   ϵ = 1e-8
   n = 3
@@ -440,7 +576,7 @@ end
   H = MPO(ising(n, 1.0), s)
 
   # apply on MPO with apply_dag=true
-  ϕ = randomMPS(ComplexF64, s, 10)
+  ϕ = randomMPS(ComplexF64, s; linkdims=10)
   f = function (x)
     U = [op("Ry", s[2]; θ=x), op("CX", s[1], s[2]), op("Rx", s[3]; θ=x)]
     Hθ = apply(U, H; apply_dag=true)
@@ -491,3 +627,22 @@ end
   ∇num = (f(θ + ϵ) - f(θ)) / ϵ
   @test ∇f ≈ ∇num atol = 1e-5
 end
+
+@testset "contract/apply MPOs" begin
+  n = 2
+  s = siteinds("S=1/2", n)
+  x = (x -> outer(x', x))(randomMPS(s; linkdims=4))
+  x_itensor = contract(x)
+
+  f = x -> tr(apply(x, x))
+  @test f(x) ≈ f(x_itensor)
+  @test contract(f'(x)) ≈ f'(x_itensor)
+
+  f = x -> tr(replaceprime(contract(x', x), 2 => 1))
+  @test f(x) ≈ f(x_itensor)
+  @test contract(f'(x)) ≈ f'(x_itensor)
+
+  f = x -> tr(replaceprime(*(x', x), 2 => 1))
+  @test f(x) ≈ f(x_itensor)
+  @test contract(f'(x)) ≈ f'(x_itensor)
+end
diff --git a/test/ITensorChainRules/test_chainrules_ops.jl b/test/ITensorChainRules/test_chainrules_ops.jl
index 34e1c5db87..7cf5b31fb0 100644
--- a/test/ITensorChainRules/test_chainrules_ops.jl
+++ b/test/ITensorChainRules/test_chainrules_ops.jl
@@ -155,6 +155,98 @@ using Zygote: ZygoteRuleConfig, gradient
   args = (x,)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
 
+  f = function (x)
+    y = exp(-x * Op("X", 1) * Op("X", 2))
+    y *= exp(-x * Op("X", 1) * Op("X", 2))
+    U = ITensor(y, s)
+    return norm(U)
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  U1(θ) = Op("Ry", 1; θ)
+  U2(θ) = Op("Ry", 2; θ)
+
+  f = function (x)
+    return ITensor(U1(x), s)[1, 1]
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  f = function (x)
+    return ITensor(U1(x) * U2(x), s)[1, 1]
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  f = function (x)
+    return ITensor(1.2 * U1(x), s)[1, 1]
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  f = function (x)
+    return ITensor(exp(1.2 * U1(x)), s)[1, 1]
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  f = function (x)
+    return ITensor(exp(x * U1(1.2)), s)[1, 1]
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  function H(x1, x2)
+    os = Ops.OpSum()
+    os += x1 * Op("X", 1)
+    os += x2 * Op("X", 2)
+    return os
+  end
+
+  if VERSION ≥ v"1.7"
+    f = function (x)
+      return ITensor(exp(1.5 * H(x, x); alg=Trotter{1}(1)), s)[1, 1]
+    end
+    args = (x,)
+    test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+    f = function (x)
+      return ITensor(exp(1.5 * H(x, x); alg=Trotter{2}(1)), s)[1, 1]
+    end
+    args = (x,)
+    test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+    f = function (x)
+      return ITensor(exp(1.5 * H(x, x); alg=Trotter{2}(2)), s)[1, 1]
+    end
+    args = (x,)
+    test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+    f = function (x)
+      return ITensor(exp(x * H(x, x); alg=Trotter{2}(2)), s)[1, 1]
+    end
+    args = (x,)
+    test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+  end
+
+  f = function (x)
+    y = -x * (Op("X", 1) * Op("X", 2) + Op("Z", 1) * Op("Z", 2))
+    U = ITensor(y, s)
+    return norm(U * V)
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  f = function (x)
+    y = exp(-x * (Op("X", 1) * Op("X", 2) + Op("Z", 1) * Op("Z", 2)); alg=Trotter{1}(1))
+    U = ITensor(y, s)
+    return norm(U * V)
+  end
+  args = (x,)
+  test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
+
+  ## XXX: Fix
   f = function (x)
     y = exp(-x * Op("X", 1) * Op("X", 2))
     y *= exp(-x * Op("X", 1) * Op("X", 2))
@@ -164,6 +256,7 @@ using Zygote: ZygoteRuleConfig, gradient
   args = (x,)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
 
+  ## XXX: Fix
   f = function (x)
     y = exp(-x * (Op("X", 1) + Op("Z", 1) + Op("Z", 1)); alg=Trotter{1}(1))
     U = Prod{ITensor}(y, s)
@@ -171,18 +264,4 @@ using Zygote: ZygoteRuleConfig, gradient
   end
   args = (x,)
   test_rrule(ZygoteRuleConfig(), f, args...; rrule_f=rrule_via_ad, check_inferred=false)
-
-  ## ## XXX: Error in vcat!
-  ## f = function (x)
-  ##   y = -x * (Op("X", 1) * Op("X", 2) + Op("Z", 1) * Op("Z", 2))
-  ##   U = ITensor(y, s)
-  ##   return norm(U * V)
-  ## end
-  ## 
-  ## ## XXX: Error in vcat!
-  ## f = function (x)
-  ##   y = exp(-x * (Op("X", 1) * Op("X", 2) + Op("Z", 1) * Op("Z", 2)); alg=Trotter{1}(1))
-  ##   U = ITensor(y, s)
-  ##   return norm(U * V)
-  ## end
 end
diff --git a/test/ITensorChainRules/test_optimization.jl b/test/ITensorChainRules/test_optimization.jl
index 81681c41b8..a990e45531 100644
--- a/test/ITensorChainRules/test_optimization.jl
+++ b/test/ITensorChainRules/test_optimization.jl
@@ -124,7 +124,7 @@ include("utils/circuit.jl")
   end
 
   @testset "State preparation (MPS)" begin
-    for gate in ["Ry"]#="Rx", =#
+    for gate in ["Ry"] #="Rx", =#
       nsites = 4 # Number of sites
       nlayers = 2 # Layers of gates in the ansatz
       gradtol = 1e-3 # Tolerance for stopping gradient descent
diff --git a/test/LazyApply/runtests.jl b/test/LazyApply/runtests.jl
index cbbefca761..0ec5d0ac85 100644
--- a/test/LazyApply/runtests.jl
+++ b/test/LazyApply/runtests.jl
@@ -8,5 +8,5 @@ test_files = filter(starts_and_ends_with("test_", ".jl"), readdir(test_path))
 @testset "$(last(splitpath(test_path)))" for file in test_files
   file_path = joinpath(test_path, file)
   println("Running test $(file_path)")
-  include(file_path)
+  #include(file_path)
 end
diff --git a/test/Ops/test_ops.jl b/test/Ops/test_ops.jl
index a7f0667ca5..19668a18b4 100644
--- a/test/Ops/test_ops.jl
+++ b/test/Ops/test_ops.jl
@@ -2,10 +2,10 @@ using Test
 using ITensors
 using LinearAlgebra
 
-using ITensors.Ops: α, ∏, ∑, expand
+using ITensors.Ops #: Scaled, Prod, Sum, expand
 
 function heisenberg(N)
-  os = ∑{Op}()
+  os = Sum{Op}()
   for j in 1:(N - 1)
     os += "Sz", j, "Sz", j + 1
     os += 0.5, "S+", j, "S-", j + 1
@@ -14,7 +14,7 @@ function heisenberg(N)
   return os
 end
 
-@testset "Ops" begin
+@testset "Basic Ops" begin
   x1 = Op("X", 1)
   x2 = Op("X", 2)
   I1 = Op(I, 1)
@@ -24,29 +24,75 @@ end
   CX12 = Op("CX", 1, 2)
   Ry4 = Op("Ry", 4; θ=π / 3)
 
-  @test 2y2 isa α{Op}
+  @test 2y2 isa Scaled{<:Number,Op}
   @test coefficient(2y2) == 2
-  @test y2 / 2 isa α{Op}
+  @test y2 / 2 isa Scaled{<:Number,Op}
   @test coefficient(y2 / 2) ≈ 0.5
-  @test -y2 isa α{Op}
-  @test 1y2 + x1 isa ∑{<:α{Op}}
-  @test 1y2 + x1 isa ∑{α{Op,Int}}
-  @test x1 * y2 isa ∏{Op}
-  @test 2x1 * y2 isa α{∏{Op}}
-  @test x1 * y2 + CX12 isa ∑{∏{Op}}
-  @test x1 * y2 + x1 * CX12 isa ∑{∏{Op}}
-  @test x1 * y2 + 2CX12 isa ∑{<:α{∏{Op}}}
-  @test x1 * y2 - CX12 isa ∑{<:α{∏{Op}}}
-  @test 2x1 * y2 + 2CX12 isa ∑{<:α{∏{Op}}}
-  @test 2x1 * y2 - 2CX12 isa ∑{<:α{∏{Op}}}
-  @test (2x1 * y2 - 2CX12) / 3 isa ∑{<:α{∏{Op}}}
+  @test -y2 isa Scaled{<:Number,Op}
+  @test 1y2 + x1 isa Sum{<:Scaled{<:Number,Op}}
+  @test 1y2 + x1 isa Sum{Scaled{Int,Op}}
+  @test x1 * y2 isa Prod{Op}
+  @test 2x1 * y2 isa Scaled{<:Number,Prod{Op}}
+  @test x1 * y2 + CX12 isa Sum{Prod{Op}}
+  @test x1 * y2 + x1 * CX12 isa Sum{Prod{Op}}
+  @test x1 * y2 + 2CX12 isa Sum{<:Scaled{<:Number,Prod{Op}}}
+  @test x1 * y2 - CX12 isa Sum{<:Scaled{<:Number,Prod{Op}}}
+  @test 2x1 * y2 + 2CX12 isa Sum{<:Scaled{<:Number,Prod{Op}}}
+  @test 2x1 * y2 - 2CX12 isa Sum{<:Scaled{<:Number,Prod{Op}}}
+  @test (2x1 * y2 - 2CX12) / 3 isa Sum{<:Scaled{<:Number,Prod{Op}}}
+
+  o1 = Op("X", 1)
+  o2 = Op("Y", 2)
+
+  @test o1 + o2 isa Sum{Op}
+  @test o1 - o2 isa Sum{Scaled{Int,Op}}
+  @test 1.3 * o1 isa Scaled{Float64,Op}
+  @test o1 * 1.4 isa Scaled{Float64,Op}
+  @test o1 + o2 + o2 isa Sum{Op}
+  @test 1.3o1 + 1.3o2 isa Sum{Scaled{Float64,Op}}
+  @test 1.3o1 + o2 isa Sum{Scaled{Float64,Op}}
+  @test (o1 + o2) + (o1 + o2) isa Sum{Op}
+  @test 1.3o1 + 1o2 isa Sum{Scaled{Float64,Op}}
+  @test 1.3 * (o1 + o2) isa Sum{Scaled{Float64,Op}}
+  @test o1 + o2 + 1.3o2 isa Sum{Scaled{Float64,Op}}
+  @test o1 * o2 isa Prod{Op}
+  @test o1 * o2 * o2 isa Prod{Op}
+  @test o1 * (o2 * o2) isa Prod{Op}
+  @test 1.3 * o1 * o2 isa Scaled{Float64,Prod{Op}}
+  @test 1.3 * (o1 * o2) isa Scaled{Float64,Prod{Op}}
+  @test 1.3 * o1 * o2 + o1 isa Sum{Scaled{Float64,Prod{Op}}}
+  @test 1.3 * o1 * o2 + o1 * o2 isa Sum{Scaled{Float64,Prod{Op}}}
+  @test 1.3 * o1 * o2 + 1.3 * o1 * o2 isa Sum{Scaled{Float64,Prod{Op}}}
+  @test 1.3 * o1 * o2 + 1.3 * o1 * o2 + o1 isa Sum{Scaled{Float64,Prod{Op}}}
+  @test 1.3 * o1 * o2 + 1.3 * o1 * o2 + 1.2 * o1 isa Sum{Scaled{Float64,Prod{Op}}}
+  @test Ops.OpSum() + o1 isa Sum{Scaled{ComplexF64,Prod{Op}}}
+  @test Ops.OpSum() + 1.2 * o1 isa Sum{Scaled{ComplexF64,Prod{Op}}}
+  @test Ops.OpSum() + (1.2 + 2.3im) * o1 isa Sum{Scaled{ComplexF64,Prod{Op}}}
+  @test Ops.OpSum() + 1.2 * o1 * o2 isa Sum{Scaled{ComplexF64,Prod{Op}}}
+  @test Ops.OpSum() - 1.2 * o1 * o2 isa Sum{Scaled{ComplexF64,Prod{Op}}}
+  @test Ops.OpSum() + o1 * o2 isa Sum{Scaled{ComplexF64,Prod{Op}}}
+  @test o1 + o2 + 2.3 * o1 * o2 isa Sum{Scaled{Float64,Prod{Op}}}
+  @test Sum{Op}() + ("X", 1, "Y", 2) + ("Y", 2) isa Sum{Prod{Op}}
+  @test Sum{Op}() + ("X", 1, "Y", 2) + (1.2, "Y", 2) isa Sum{Scaled{Float64,Prod{Op}}}
+  @test OpSum() - (0.5, "Z", 1, "Z", 2) isa Sum{Scaled{ComplexF64,Prod{Op}}}
+
+  N = 4
+  s = siteinds("Qubit", N)
+
+  @test ITensor(o1, s) ≈ op("X", s, 1)
+  @test ITensor(2 * o1, s) ≈ 2 * ITensor(o1, s)
+  @test ITensor(o1 * o2, s) ≈ ITensor(o1, s) * ITensor(o2, s)
+  @test ITensor(2 * o1 * o2, s) ≈ 2 * ITensor(o1, s) * ITensor(o2, s)
+  @test ITensor(2 * o1 * o2 + o1 * o2, s) ≈
+    2 * ITensor(o1, s) * ITensor(o2, s) + ITensor(o1, s) * ITensor(o2, s)
+  @test ITensor(exp(o1), s) ≈ exp(ITensor(o1, s))
+  @test ITensor(exp(1.2 * o1), s) ≈ exp(1.2 * ITensor(o1, s))
+  @test ITensor(1.3 * exp(1.2 * o1), s) ≈ 1.3 * exp(1.2 * ITensor(o1, s))
 
   o = (2x1 * y2 - 2CX12) / 3
   @test coefficient(o[1]) ≈ 2 / 3
   @test coefficient(o[2]) ≈ -2 / 3
 
-  N = 4
-  s = siteinds("Qubit", N)
   t1 = ITensor(x1, s)
   @test hassameinds(t1, (s[1]', dag(s[1])))
   @test t1[1, 1] == 0
@@ -57,6 +103,7 @@ end
   @test ITensor(x1 + 2.3x1, s) ≈ 3.3t1
 
   @test ITensor(Op(I, 2), s) ≈ ITensor([1 0; 0 1], s[2]', dag(s[2]))
+  @test ITensor(Op(2I, 2), s) ≈ 2 * ITensor([1 0; 0 1], s[2]', dag(s[2]))
 
   c = x1 * y2 * CX12
   cdag = c'
@@ -75,7 +122,9 @@ end
   @test ITensor(y1 * x1, s) ≈ ITensor(Op([-im 0; 0 im], 1), s)
   @test ITensor(2x1 * x1 + y1, s) ≈
     ITensor(2 * [1 0; 0 1] + [0 -im; im 0], s[1]', dag(s[1]))
-  @test ITensor(2y1 * x2 + x1, s) ≈
+
+  # TODO: Need to add support for filling out with "Id" or "F"
+  @test_broken ITensor(2y1 * x2 + x1, s) ≈
     2 * ITensor(y1, s) * ITensor(x2, s) + ITensor(x1, s) * ITensor(I2, s)
 
   @test y1'' == y1
@@ -89,36 +138,38 @@ end
 
   @test ITensor(I1, s) ≈ ITensor([1 0; 0 1], s[1]', dag(s[1]))
 
-  @test exp(Op("X", 1)) * Op("Y", 2) isa ∏{Any}
+  @test exp(Op("X", 1)) * Op("Y", 2) isa Prod{Any}
   @test ITensor(exp(Op("X", 1)) * Op("Y", 1), s) ≈
     product(exp(ITensor(Op("X", 1), s)), ITensor(Op("Y", 1), s))
-  @test 2exp(Op("X", 1)) * Op("Y", 2) isa α{∏{Any}}
-
-  H = ∑{<:α{∏{Op}}}() - Op("X", 1)
-  @test H isa ∑
-  @test H isa ∑{<:α}
-  @test H isa ∑{<:α{<:∏}}
-  @test H isa ∑{<:α{∏{Op}}}
-  @test H isa ∑{α{∏{Op},T}} where {T}
-  @test H isa ∑{α{∏{Op},Int}}
+
+  # TODO: Need to define `(::Scaled * ::Op)::Scaled`
+  @test_broken 2exp(Op("X", 1)) * Op("Y", 2) isa Scaled{<:Number,Prod{Any}}
+
+  H = Sum{Scaled{Bool,Prod{Op}}}() - Op("X", 1)
+  @test H isa Sum
+  @test H isa Sum{<:Scaled}
+  @test H isa Sum{<:Scaled{<:Number,<:Prod}}
+  @test H isa Sum{<:Scaled{<:Number,Prod{Op}}}
+  @test H isa Sum{Scaled{T,Prod{Op}}} where {T}
+  @test H isa Sum{Scaled{Int,Prod{Op}}}
   @test length(H) == 1
   @test coefficient(H[1]) == -1
 
-  H = ∑{Op}() - Op("X", 1)
-  @test H isa ∑
-  @test H isa ∑{<:α}
-  @test H isa ∑{<:α{Op}}
-  @test H isa ∑{α{Op,T}} where {T}
-  @test H isa ∑{α{Op,Int}}
+  H = Sum{Op}() - Op("X", 1)
+  @test H isa Sum
+  @test H isa Sum{<:Scaled}
+  @test H isa Sum{<:Scaled{<:Number,Op}}
+  @test H isa Sum{Scaled{T,Op}} where {T}
+  @test H isa Sum{Scaled{Int,Op}}
   @test length(H) == 1
   @test coefficient(H[1]) == -1
 
   # MPO conversion
-  H = ∑{Op}()
+  H = Sum{Op}()
   H -= 2.3, "X", 1, "X", 2
   H += 1.2, "Z", 1
   H += 1.3, "Z", 2, (θ=π / 3,)
-  @test H isa ∑{α{∏{Op},Float64}}
+  @test H isa Sum{Scaled{Float64,Prod{Op}}}
   @test length(H) == 3
   @test coefficient(H[1]) == -2.3
   @test length(H[1]) == 2
@@ -131,14 +182,14 @@ end
   @test Ops.sites(H[3]) == [2]
   @test Ops.params(H[3]) == (θ=π / 3,)
 
-  @test ∑{Op}(("X", 1)) isa ∑{Op}
-  @test ∑{Op}((2.3, "X", 1)) isa ∑{α{Op,Float64}}
-  @test ∑{Op}("X", 1) isa ∑{Op}
-  @test ∑{Op}(2, "X", 1) isa ∑{α{Op,Int}}
-  @test ∑{Op}([Op("X", 1), 2Op("Y", 1)]) isa ∑
-  @test ∑{Op}([Op("X", 1), 2Op("Y", 1)]) isa ∑{<:α}
-  @test ∑{Op}([Op("X", 1), 2Op("Y", 1)]) isa ∑{<:α{Op}}
-  @test ∑{Op}([Op("X", 1), 2Op("Y", 1)]) isa ∑{α{Op,Int}}
+  @test_broken Sum{Op}(("X", 1)) isa Sum{Op}
+  @test_broken Sum{Op}((2.3, "X", 1)) isa Sum{Scaled{Float64,Op}}
+  @test_broken Sum{Op}("X", 1) isa Sum{Op}
+  @test_broken Sum{Op}(2, "X", 1) isa Sum{Scaled{Int,Op}}
+  @test_broken Sum{Op}([Op("X", 1), 2Op("Y", 1)]) isa Sum
+  @test_broken Sum{Op}([Op("X", 1), 2Op("Y", 1)]) isa Sum{<:Scaled}
+  @test_broken Sum{Op}([Op("X", 1), 2Op("Y", 1)]) isa Sum{<:Scaled{<:Number,Op}}
+  @test_broken Sum{Op}([Op("X", 1), 2Op("Y", 1)]) isa Sum{Scaled{Int,Op}}
 
   @testset "Expand expression, 2 products" begin
     expr = (Op("X", 1) + Op("Y", 2)) * (Op("Z", 1) + Op("W", 2))
@@ -172,7 +223,8 @@ end
 
   @testset "Conversion to Sum of ITensors" begin
     H = Sum{Op}() + ("X", 1) + ("Y", 2)
-    @test H == Sum{Op}([("X", 1), ("Y", 2)])
+    @test_broken H == Sum{Op}([("X", 1), ("Y", 2)])
+    @test H == Sum{Op}() + Op("X", 1) + Op("Y", 2)
     s = siteinds("Qubit", 2)
     Hₜ = Sum{ITensor}(H, s)
     @test Hₜ isa Sum{ITensor}
@@ -180,12 +232,14 @@ end
     @test Hₜ[2] ≈ ITensor(Op("Y", 2), s)
   end
 
-  @testset "Conversion to ∏ of ITensors" begin
-    C = ∏{Op}() * ("X", 1) * ("Y", 2)
-    @test C == ∏{Op}([("X", 1), ("Y", 2)])
+  @testset "Conversion to Prod of ITensors" begin
+    C = Prod{Op}() * ("X", 1) * ("Y", 2)
+    @test_broken C == Prod{Op}([("X", 1), ("Y", 2)])
+    @test C == Prod{Op}() * Op("X", 1) * Op("Y", 2)
+    @test C == Op("X", 1) * Op("Y", 2)
     s = siteinds("Qubit", 2)
-    Cₜ = ∏{ITensor}(C, s)
-    @test Cₜ isa ∏{ITensor}
+    Cₜ = Prod{ITensor}(C, s)
+    @test Cₜ isa Prod{ITensor}
     @test Cₜ[1] ≈ ITensor(Op("X", 1), s)
     @test Cₜ[2] ≈ ITensor(Op("Y", 2), s)
   end
diff --git a/test/Ops/test_ops_mpo.jl b/test/Ops/test_ops_mpo.jl
index 4ecd0ede26..0799e04fad 100644
--- a/test/Ops/test_ops_mpo.jl
+++ b/test/Ops/test_ops_mpo.jl
@@ -1,5 +1,6 @@
 using Test
 using ITensors
+using ITensors.Ops
 using LinearAlgebra
 
 @testset "Ops to MPO" begin
@@ -8,7 +9,7 @@ using LinearAlgebra
   ∑H += 2, "Z", 1
   ∑H += 2, "Z", 2
 
-  @test ∑H isa Sum{Scaled{Prod{Op},Float64}}
+  @test ∑H isa Sum{Scaled{Float64,Prod{Op}}}
 
   s = siteinds("Qubit", 2)
   H = MPO(∑H, s)
@@ -28,6 +29,27 @@ using LinearAlgebra
   @test prod(MPO(X(1) + Z(2), s)) ≈ T(X(1)) * T(Id(2)) + T(Id(1)) * T(Z(2))
   @test prod(MPO(X(1) + 3.3Z(2), s)) ≈ T(X(1)) * T(Id(2)) + 3.3T(Id(1)) * T(Z(2))
   @test prod(MPO((X(1) + Z(2)) / 2, s)) ≈ 0.5T(X(1)) * T(Id(2)) + 0.5T(Id(1)) * T(Z(2))
+
+  @testset "OpSum to MPO with repeated terms" begin
+    ℋ = OpSum()
+    ℋ += "Z", 1
+    ℋ += "Z", 1
+    ℋ += "X", 2
+    ℋ += "Z", 1
+    ℋ += "Z", 1
+    ℋ += "X", 2
+    ℋ += "X", 2
+    ℋ_merged = OpSum()
+    ℋ_merged += (4, "Z", 1)
+    ℋ_merged += (3, "X", 2)
+    @test ITensors.sortmergeterms(ℋ) == ℋ_merged
+
+    # Test with repeated terms
+    s = siteinds("S=1/2", 1)
+    ℋ = OpSum() + ("Z", 1) + ("Z", 1)
+    H = MPO(ℋ, s)
+    @test contract(H) ≈ 2 * op("Z", s, 1)
+  end
 end
 
 function heisenberg_old(N)
@@ -56,7 +78,7 @@ end
   os_old = heisenberg_old(N)
   os_new = heisenberg(N)
   @test os_old isa OpSum
-  @test os_new isa Sum{Scaled{Prod{Op},Float64}}
+  @test os_new isa Sum{Scaled{Float64,Prod{Op}}}
   Hold = MPO(os_old, s)
   Hnew = MPO(os_new, s)
   @test prod(Hold) ≈ prod(Hnew)
@@ -70,4 +92,5 @@ end
   H = MPO(ℋ, s)
   H² = MPO(ℋ², s)
   @test norm(replaceprime(H' * H, 2 => 1) - H²) ≈ 0 atol = 1e-14
+  @test norm(H(H) - H²) ≈ 0 atol = 1e-14
 end
diff --git a/test/Ops/test_trotter.jl b/test/Ops/test_trotter.jl
index 0780b68594..75fcda483b 100644
--- a/test/Ops/test_trotter.jl
+++ b/test/Ops/test_trotter.jl
@@ -1,10 +1,9 @@
 using Test
 using ITensors
-
-using ITensors: ∑, ∏
+using ITensors.Ops
 
 @testset "Simple trotterization" begin
-  H = ∑{Op}() + ("X", 1) + ("Y", 1)
+  H = Sum{Op}() + ("X", 1) + ("Y", 1)
 
   s = siteinds("Qubit", 1)
 
@@ -12,13 +11,15 @@ using ITensors: ∑, ∏
     expHᵉˣᵃᶜᵗ = ITensor(exp(H), s)
     @test expHᵉˣᵃᶜᵗ ≈ ITensor(exp(H; alg=Trotter{1}(nsteps)), s) rtol = 1 / nsteps
     @test expHᵉˣᵃᶜᵗ ≈ ITensor(exp(H; alg=Trotter{2}(nsteps)), s) rtol = (1 / nsteps)^2
-    @test expHᵉˣᵃᶜᵗ ≈ ITensor(exp(H; alg=Trotter{4}(nsteps)), s) rtol = (1 / nsteps)^2
-    @test expHᵉˣᵃᶜᵗ ≈ ITensor(exp(H; alg=Trotter{8}(nsteps)), s) rtol = (1 / nsteps)^2
+    @test_broken expHᵉˣᵃᶜᵗ ≈ ITensor(exp(H; alg=Trotter{4}(nsteps)), s) rtol =
+      (1 / nsteps)^2
+    @test_broken expHᵉˣᵃᶜᵗ ≈ ITensor(exp(H; alg=Trotter{8}(nsteps)), s) rtol =
+      (1 / nsteps)^2
 
     # Convert to ITensors
     t = 1.0
-    Uᵉˣᵃᶜᵗ = ∏([ITensor(exp(im * t * H), s)])
-    U = ∏{ITensor}(exp(im * t * H; alg=Trotter{2}(nsteps)), s)
+    Uᵉˣᵃᶜᵗ = ITensor(exp(im * t * H), s)
+    U = Prod{ITensor}(exp(im * t * H; alg=Trotter{2}(nsteps)), s)
     ψ₀ = onehot(s .=> "0")
     Uᵉˣᵃᶜᵗψ₀ = Uᵉˣᵃᶜᵗ(ψ₀)
     Uψ₀ = U(ψ₀)
@@ -43,10 +44,17 @@ end
   ψ₀ = MPS(s, n -> isodd(n) ? "↑" : "↓")
   t = 1.0
   for nsteps in [10, 100]
-    for order in [1, 2, 4]
+    for order in [1, 2] #, 4]
       𝒰 = exp(im * t * ℋ; alg=Trotter{order}(nsteps))
-      U = ∏{ITensor}(𝒰, s)
-      H = ITensor(ℋ, s)
+      U = Prod{ITensor}(𝒰, s)
+      ∑H = Sum{ITensor}(ℋ, s)
+      # XXX: Define this, filling out identities.
+      # ITensor(ℋ, s)
+      I = contract(MPO(s, "Id"))
+      H = 0.0 * contract(MPO(s, "Id"))
+      for h in ∑H
+        H += apply(h, I)
+      end
       Uʳᵉᶠψ₀ = replaceprime(exp(im * t * H) * prod(ψ₀), 1 => 0)
       atol = max(1e-6, 1 / nsteps^order)
       @test prod(U(ψ₀)) ≈ Uʳᵉᶠψ₀ atol = atol
diff --git a/test/Project.toml b/test/Project.toml
index 9cd8d41558..7aeaeb3224 100644
--- a/test/Project.toml
+++ b/test/Project.toml
@@ -6,6 +6,7 @@ Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 ITensors = "9136182c-28ba-11e9-034c-db9fb085ebd5"
+JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 OptimKit = "77e91f04-9b3b-57a6-a776-40b61faaebe0"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
diff --git a/test/XXZ_complex.jl b/test/XXZ_complex.jl
new file mode 100644
index 0000000000..7da62f5d2e
--- /dev/null
+++ b/test/XXZ_complex.jl
@@ -0,0 +1,68 @@
+#########
+## XXZ model with imaginary part
+#########
+using ITensors
+
+function Hamiltonian(sites, Δ::Float64, J::Float64, γ::Float64, h::Float64)
+  N = length(sites)
+  ampo = AutoMPO()
+
+  for j in 1:(N - 1)
+    ampo += Δ, "Sz", j, "Sz", j + 1
+    ampo += -(J + im * γ * (-1.0)^j), "Sx", j, "Sx", j + 1
+    ampo += -(J + im * γ * (-1.0)^j), "Sy", j, "Sy", j + 1
+  end
+  for j in 1:N
+    ampo += h * (-1.0)^j, "Sz", j
+  end
+  #  Convert these terms to an MPO tensor network
+  return MPO(ampo, sites)
+end
+
+let
+  #model parameters
+  N = 4
+  Δ = -0.70
+  J = 1.0
+  γ = 0.1
+  h = 0.1
+
+  alg = "qr_iteration"
+
+  #dmrg parameters
+  sweeps = Sweeps(1000)
+  minsweeps = 5
+  maxdim!(sweeps, 50, 100, 200)
+  #cutoff!(sweeps, 1E-12)
+  etol = 1E-12
+
+  sites = siteinds("S=1/2", N; conserve_qns=false)
+
+  #initial state
+  state = ["Emp" for n in 1:N]
+  p = N
+  for i in N:-1:1
+    if p > i
+      #println("Doubly occupying site $i")
+      state[i] = "UpDn"
+      p -= 2
+    elseif p > 0
+      #println("Singly occupying site $i")
+      state[i] = (isodd(i) ? "Up" : "Dn")
+      p -= 1
+    end
+  end
+  psi0 = randomMPS(sites, state)
+  @show flux(psi0)
+
+  H = Hamiltonian(sites, Δ, J, γ, h)
+
+  obs = DMRGObserver(
+    ["Sz"], sites; energy_tol=etol, minsweeps=minsweeps, complex_energies=true
+  )
+
+  energy, psi = dmrg(
+    H, psi0, sweeps; svd_alg=alg, observer=obs, outputlevel=1, ishermitian=false
+  )
+  println("Final energy = $energy")
+end
diff --git a/test/algorithm.jl b/test/algorithm.jl
new file mode 100644
index 0000000000..5cc03d8e28
--- /dev/null
+++ b/test/algorithm.jl
@@ -0,0 +1,39 @@
+using ITensors
+using Test
+
+@testset "Algorithm" begin
+  alg = ITensors.Algorithm("X")
+
+  @test alg isa ITensors.Algorithm"X"
+  @test alg == ITensors.Algorithm"X"()
+
+  s = siteinds("S=1/2", 4)
+  A = MPO(s, "Id")
+  ψ = randomMPS(s)
+
+  @test_throws MethodError contract(alg, A, ψ)
+  @test_throws MethodError contract(A, ψ; method="X")
+  @test_throws MethodError contract(A, ψ; alg="X")
+  @test contract(ITensors.Algorithm("densitymatrix"), A, ψ) ≈ A * ψ
+  @test contract(ITensors.Algorithm("naive"), A, ψ) ≈ A * ψ
+  @test contract(A, ψ; alg="densitymatrix") ≈ A * ψ
+  @test contract(A, ψ; method="densitymatrix") ≈ A * ψ
+  @test contract(A, ψ; alg="naive") ≈ A * ψ
+  @test contract(A, ψ; method="naive") ≈ A * ψ
+
+  B = copy(A)
+  truncate!(ITensors.Algorithm("frobenius"), B)
+  @test A ≈ B
+
+  B = copy(A)
+  truncate!(B; alg="frobenius")
+  @test A ≈ B
+
+  # Custom algorithm
+  function ITensors.truncate!(::ITensors.Algorithm"my_new_algorithm", A::MPO; cutoff=1e-15)
+    return "my_new_algorithm was called with cutoff $cutoff"
+  end
+  cutoff = 1e-5
+  res = truncate!(A; alg="my_new_algorithm", cutoff=cutoff)
+  @test res == "my_new_algorithm was called with cutoff $cutoff"
+end
diff --git a/test/autompo.jl b/test/autompo.jl
index 77e9ff6bbe..3d6c805856 100644
--- a/test/autompo.jl
+++ b/test/autompo.jl
@@ -1,7 +1,19 @@
-using ITensors, Test, Random
+using ITensors, Test, Random, JLD2
 
 include("util.jl")
 
+function components_to_opsum(comps, n; reverse::Bool=true)
+  opsum = OpSum()
+  for (factor, operators, sites) in comps
+    # reverse ordering for compatibility
+    sites = reverse ? (n + 1) .- sites : sites
+    sites_and_ops = [[Matrix(operator), site] for (operator, site) in zip(operators, sites)]
+    sites_and_ops = [vcat(sites_and_ops...)...]
+    opsum += factor, sites_and_ops...
+  end
+  return opsum
+end
+
 function isingMPO(sites)::MPO
   H = MPO(sites)
   N = length(H)
@@ -59,34 +71,51 @@ function NNheisenbergMPO(sites, J1::Float64, J2::Float64)::MPO
   H = MPO(sites)
   N = length(H)
   link = Vector{Index}(undef, N + 1)
-  for n in 1:(N + 1)
-    link[n] = Index(8, "Link,H,l=$(n-1)")
+  if hasqns(sites[1])
+    for n in 1:(N + 1)
+      link[n] = Index(
+        [
+          QN() => 1,
+          QN("Sz", -2) => 1,
+          QN("Sz", +2) => 1,
+          QN() => 1,
+          QN("Sz", -2) => 1,
+          QN("Sz", +2) => 1,
+          QN() => 2,
+        ],
+        "Link,H,l=$(n-1)",
+      )
+    end
+  else
+    for n in 1:(N + 1)
+      link[n] = Index(8, "Link,H,l=$(n-1)")
+    end
   end
   for n in 1:N
     s = sites[n]
-    ll = link[n]
+    ll = dag(link[n])
     rl = link[n + 1]
-    H[n] = ITensor(ll, s, s', rl)
-    H[n] += setelt(ll => 1) * setelt(rl => 1) * op(sites, "Id", n)
-    H[n] += setelt(ll => 8) * setelt(rl => 8) * op(sites, "Id", n)
-
-    H[n] += setelt(ll => 2) * setelt(rl => 1) * op(sites, "S-", n)
-    H[n] += setelt(ll => 5) * setelt(rl => 2) * op(sites, "Id", n)
-    H[n] += setelt(ll => 8) * setelt(rl => 2) * op(sites, "S+", n) * J1 / 2
-    H[n] += setelt(ll => 8) * setelt(rl => 5) * op(sites, "S+", n) * J2 / 2
-
-    H[n] += setelt(ll => 3) * setelt(rl => 1) * op(sites, "S+", n)
-    H[n] += setelt(ll => 6) * setelt(rl => 3) * op(sites, "Id", n)
-    H[n] += setelt(ll => 8) * setelt(rl => 3) * op(sites, "S-", n) * J1 / 2
-    H[n] += setelt(ll => 8) * setelt(rl => 6) * op(sites, "S-", n) * J2 / 2
-
-    H[n] += setelt(ll => 4) * setelt(rl => 1) * op(sites, "Sz", n)
-    H[n] += setelt(ll => 7) * setelt(rl => 4) * op(sites, "Id", n)
-    H[n] += setelt(ll => 8) * setelt(rl => 4) * op(sites, "Sz", n) * J1
-    H[n] += setelt(ll => 8) * setelt(rl => 7) * op(sites, "Sz", n) * J2
+    H[n] = ITensor(ll, dag(s), s', rl)
+    H[n] += onehot(ll => 1) * onehot(rl => 1) * op(sites, "Id", n)
+    H[n] += onehot(ll => 8) * onehot(rl => 8) * op(sites, "Id", n)
+
+    H[n] += onehot(ll => 2) * onehot(rl => 1) * op(sites, "S-", n)
+    H[n] += onehot(ll => 5) * onehot(rl => 2) * op(sites, "Id", n)
+    H[n] += onehot(ll => 8) * onehot(rl => 2) * op(sites, "S+", n) * J1 / 2
+    H[n] += onehot(ll => 8) * onehot(rl => 5) * op(sites, "S+", n) * J2 / 2
+
+    H[n] += onehot(ll => 3) * onehot(rl => 1) * op(sites, "S+", n)
+    H[n] += onehot(ll => 6) * onehot(rl => 3) * op(sites, "Id", n)
+    H[n] += onehot(ll => 8) * onehot(rl => 3) * op(sites, "S-", n) * J1 / 2
+    H[n] += onehot(ll => 8) * onehot(rl => 6) * op(sites, "S-", n) * J2 / 2
+
+    H[n] += onehot(ll => 4) * onehot(rl => 1) * op(sites, "Sz", n)
+    H[n] += onehot(ll => 7) * onehot(rl => 4) * op(sites, "Id", n)
+    H[n] += onehot(ll => 8) * onehot(rl => 4) * op(sites, "Sz", n) * J1
+    H[n] += onehot(ll => 8) * onehot(rl => 7) * op(sites, "Sz", n) * J2
   end
-  H[1] *= setelt(link[1] => 8)
-  H[N] *= setelt(link[N + 1] => 1)
+  H[1] *= onehot(link[1] => 8)
+  H[N] *= onehot(dag(link[N + 1]) => 1)
   return H
 end
 
@@ -144,99 +173,107 @@ end
   @test !ITensors.using_auto_fermion()
 
   @testset "Show MPOTerm" begin
-    ampo = OpSum()
-    add!(ampo, "Sz", 1, "Sz", 2)
-    @test length(sprint(show, ITensors.data(ampo)[1])) > 1
+    os = OpSum()
+    add!(os, "Sz", 1, "Sz", 2)
+    @test length(sprint(show, os[1])) > 1
   end
 
   @testset "Multisite operator" begin
     os = OpSum()
-    os += ("CX", (1, 2))
-    os += (2.3, "R", (3, 4), "S", 2)
+    os += ("CX", 1, 2)
+    os += (2.3, "R", 3, 4, "S", 2)
     os += ("X", 3)
     @test length(os) == 3
-    @test ITensors.coef(os[1]) == 1
-    @test length(ITensors.ops(os[1])) == 1
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CX"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
-    @test ITensors.coef(os[2]) == 2.3
-    @test length(ITensors.ops(os[2])) == 2
-    @test ITensors.name(ITensors.ops(os[2])[1]) == "R"
-    @test ITensors.sites(ITensors.ops(os[2])[1]) == (3, 4)
-    @test ITensors.name(ITensors.ops(os[2])[2]) == "S"
-    @test ITensors.sites(ITensors.ops(os[2])[2]) == (2,)
-    @test ITensors.coef(os[3]) == 1
-    @test length(ITensors.ops(os[3])) == 1
-    @test ITensors.name(ITensors.ops(os[3])[1]) == "X"
-    @test ITensors.sites(ITensors.ops(os[3])[1]) == (3,)
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 1
+    @test ITensors.which_op(os[1][1]) == "CX"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+    @test coefficient(os[2]) == 2.3
+    @test length(os[2]) == 2
+    @test ITensors.which_op(os[2][1]) == "R"
+    @test ITensors.sites(os[2][1]) == (3, 4)
+    @test ITensors.which_op(os[2][2]) == "S"
+    @test ITensors.sites(os[2][2]) == (2,)
+    @test coefficient(os[3]) == 1
+    @test length(os[3]) == 1
+    @test ITensors.which_op(os[3][1]) == "X"
+    @test ITensors.sites(os[3][1]) == (3,)
 
     os = OpSum() + ("CX", 1, 2)
     @test length(os) == 1
-    @test ITensors.coef(os[1]) == 1
-    @test length(ITensors.ops(os[1])) == 1
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CX"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 1
+    @test ITensors.which_op(os[1][1]) == "CX"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+
+    # Coordinate
+    os = OpSum() + ("X", (1, 2))
+    @test length(os) == 1
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 1
+    @test ITensors.which_op(os[1][1]) == "X"
+    @test ITensors.sites(os[1][1]) == ((1, 2),)
 
     os = OpSum() + ("CX", 1, 2, (ϕ=π / 3,))
     @test length(os) == 1
-    @test ITensors.coef(os[1]) == 1
-    @test length(ITensors.ops(os[1])) == 1
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CX"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
-    @test ITensors.params(ITensors.ops(os[1])[1]) == (ϕ=π / 3,)
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 1
+    @test ITensors.which_op(os[1][1]) == "CX"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+    @test ITensors.params(os[1][1]) == (ϕ=π / 3,)
 
     os = OpSum() + ("CX", 1, 2, (ϕ=π / 3,), "CZ", 3, 4, (θ=π / 2,))
     @test length(os) == 1
-    @test ITensors.coef(os[1]) == 1
-    @test length(ITensors.ops(os[1])) == 2
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CX"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
-    @test ITensors.params(ITensors.ops(os[1])[1]) == (ϕ=π / 3,)
-    @test ITensors.name(ITensors.ops(os[1])[2]) == "CZ"
-    @test ITensors.sites(ITensors.ops(os[1])[2]) == (3, 4)
-    @test ITensors.params(ITensors.ops(os[1])[2]) == (θ=π / 2,)
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 2
+    @test ITensors.which_op(os[1][1]) == "CX"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+    @test ITensors.params(os[1][1]) == (ϕ=π / 3,)
+    @test ITensors.which_op(os[1][2]) == "CZ"
+    @test ITensors.sites(os[1][2]) == (3, 4)
+    @test ITensors.params(os[1][2]) == (θ=π / 2,)
 
     os = OpSum() + ("CX", (ϕ=π / 3,), 1, 2, "CZ", (θ=π / 2,), 3, 4)
     @test length(os) == 1
-    @test ITensors.coef(os[1]) == 1
-    @test length(ITensors.ops(os[1])) == 2
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CX"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
-    @test ITensors.params(ITensors.ops(os[1])[1]) == (ϕ=π / 3,)
-    @test ITensors.name(ITensors.ops(os[1])[2]) == "CZ"
-    @test ITensors.sites(ITensors.ops(os[1])[2]) == (3, 4)
-    @test ITensors.params(ITensors.ops(os[1])[2]) == (θ=π / 2,)
-
-    os = OpSum() + ("CX", (1, 2), (ϕ=π / 3,))
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 2
+    @test ITensors.which_op(os[1][1]) == "CX"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+    @test ITensors.params(os[1][1]) == (ϕ=π / 3,)
+    @test ITensors.which_op(os[1][2]) == "CZ"
+    @test ITensors.sites(os[1][2]) == (3, 4)
+    @test ITensors.params(os[1][2]) == (θ=π / 2,)
+
+    os = OpSum() + ("CX", 1, 2, (ϕ=π / 3,))
     @test length(os) == 1
-    @test ITensors.coef(os[1]) == 1
-    @test length(ITensors.ops(os[1])) == 1
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CX"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
-    @test ITensors.params(ITensors.ops(os[1])[1]) == (ϕ=π / 3,)
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 1
+    @test ITensors.which_op(os[1][1]) == "CX"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+    @test ITensors.params(os[1][1]) == (ϕ=π / 3,)
 
     os = OpSum() + (1 + 2im, "CRz", (ϕ=π / 3,), 1, 2)
     @test length(os) == 1
-    @test ITensors.coef(os[1]) == 1 + 2im
-    @test length(ITensors.ops(os[1])) == 1
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CRz"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
-    @test ITensors.params(ITensors.ops(os[1])[1]) == (ϕ=π / 3,)
+    @test coefficient(os[1]) == 1 + 2im
+    @test length(os[1]) == 1
+    @test ITensors.which_op(os[1][1]) == "CRz"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+    @test ITensors.params(os[1][1]) == (ϕ=π / 3,)
 
-    os = OpSum() + ("CRz", (ϕ=π / 3,), (1, 2))
+    os = OpSum() + ("CRz", (ϕ=π / 3,), 1, 2)
     @test length(os) == 1
-    @test ITensors.coef(os[1]) == 1
-    @test length(ITensors.ops(os[1])) == 1
-    @test ITensors.name(ITensors.ops(os[1])[1]) == "CRz"
-    @test ITensors.sites(ITensors.ops(os[1])[1]) == (1, 2)
-    @test ITensors.params(ITensors.ops(os[1])[1]) == (ϕ=π / 3,)
+    @test coefficient(os[1]) == 1
+    @test length(os[1]) == 1
+    @test ITensors.which_op(os[1][1]) == "CRz"
+    @test ITensors.sites(os[1][1]) == (1, 2)
+    @test ITensors.params(os[1][1]) == (ϕ=π / 3,)
   end
 
   @testset "Show OpSum" begin
-    ampo = OpSum()
-    add!(ampo, "Sz", 1, "Sz", 2)
-    add!(ampo, "Sz", 2, "Sz", 3)
-    @test length(sprint(show, ampo)) > 1
+    os = OpSum()
+    add!(os, "Sz", 1, "Sz", 2)
+    add!(os, "Sz", 2, "Sz", 3)
+    @test length(sprint(show, os)) > 1
   end
 
   @testset "OpSum algebra" begin
@@ -273,188 +310,188 @@ end
   end
 
   @testset "Single creation op" begin
-    ampo = OpSum()
-    add!(ampo, "Adagup", 3)
+    os = OpSum()
+    add!(os, "Adagup", 3)
     sites = siteinds("Electron", N)
-    W = MPO(ampo, sites)
+    W = MPO(os, sites)
     psi = makeRandomMPS(sites)
     cdu_psi = copy(psi)
     cdu_psi[3] = noprime(cdu_psi[3] * op(sites, "Adagup", 3))
-    @test inner(psi, W, psi) ≈ inner(cdu_psi, psi)
+    @test inner(psi', W, psi) ≈ inner(cdu_psi, psi)
   end
 
   @testset "Ising" begin
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += "Sz", j, "Sz", j + 1
+      os += "Sz", j, "Sz", j + 1
     end
     sites = siteinds("S=1/2", N)
-    Ha = MPO(ampo, sites)
+    Ha = MPO(os, sites)
     He = isingMPO(sites)
     psi = makeRandomMPS(sites)
-    Oa = inner(psi, Ha, psi)
-    Oe = inner(psi, He, psi)
+    Oa = inner(psi', Ha, psi)
+    Oe = inner(psi', He, psi)
     @test Oa ≈ Oe
   end
 
   @testset "Ising" begin
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo -= "Sz", j, "Sz", j + 1
+      os -= "Sz", j, "Sz", j + 1
     end
     sites = siteinds("S=1/2", N)
-    Ha = MPO(ampo, sites)
+    Ha = MPO(os, sites)
     He = -isingMPO(sites)
     psi = makeRandomMPS(sites)
-    Oa = inner(psi, Ha, psi)
-    Oe = inner(psi, He, psi)
+    Oa = inner(psi', Ha, psi)
+    Oe = inner(psi', He, psi)
     @test Oa ≈ Oe
   end
 
   @testset "Ising-Different Order" begin
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += "Sz", j, "Sz", j + 1
+      os += "Sz", j, "Sz", j + 1
     end
     sites = siteinds("S=1/2", N)
-    Ha = MPO(ampo, sites)
+    Ha = MPO(os, sites)
     He = isingMPO(sites)
     psi = makeRandomMPS(sites)
-    Oa = inner(psi, Ha, psi)
-    Oe = inner(psi, He, psi)
+    Oa = inner(psi', Ha, psi)
+    Oe = inner(psi', He, psi)
     @test Oa ≈ Oe
   end
 
   @testset "Heisenberg" begin
-    ampo = OpSum()
+    os = OpSum()
     h = rand(N) #random magnetic fields
     for j in 1:(N - 1)
-      ampo += "Sz", j, "Sz", j + 1
-      ampo += 0.5, "S+", j, "S-", j + 1
-      ampo += 0.5, "S-", j, "S+", j + 1
+      os += "Sz", j, "Sz", j + 1
+      os += 0.5, "S+", j, "S-", j + 1
+      os += 0.5, "S-", j, "S+", j + 1
     end
     for j in 1:N
-      ampo += h[j], "Sz", j
+      os += h[j], "Sz", j
     end
 
     sites = siteinds("S=1/2", N)
-    Ha = MPO(ampo, sites)
+    Ha = MPO(os, sites)
     He = heisenbergMPO(sites, h)
     psi = makeRandomMPS(sites)
-    Oa = inner(psi, Ha, psi)
-    Oe = inner(psi, He, psi)
+    Oa = inner(psi', Ha, psi)
+    Oe = inner(psi', He, psi)
     @test Oa ≈ Oe
   end
 
   @testset "Multiple Onsite Ops" begin
     sites = siteinds("S=1", N)
-    ampo1 = OpSum()
+    os1 = OpSum()
     for j in 1:(N - 1)
-      ampo1 += "Sz", j, "Sz", j + 1
-      ampo1 += 0.5, "S+", j, "S-", j + 1
-      ampo1 += 0.5, "S-", j, "S+", j + 1
+      os1 += "Sz", j, "Sz", j + 1
+      os1 += 0.5, "S+", j, "S-", j + 1
+      os1 += 0.5, "S-", j, "S+", j + 1
     end
     for j in 1:N
-      ampo1 += "Sz * Sz", j
+      os1 += "Sz * Sz", j
     end
-    Ha1 = MPO(ampo1, sites)
+    Ha1 = MPO(os1, sites)
 
-    ampo2 = OpSum()
+    os2 = OpSum()
     for j in 1:(N - 1)
-      ampo2 += "Sz", j, "Sz", j + 1
-      ampo2 += 0.5, "S+", j, "S-", j + 1
-      ampo2 += 0.5, "S-", j, "S+", j + 1
+      os2 += "Sz", j, "Sz", j + 1
+      os2 += 0.5, "S+", j, "S-", j + 1
+      os2 += 0.5, "S-", j, "S+", j + 1
     end
     for j in 1:N
-      ampo2 += "Sz", j, "Sz", j
+      os2 += "Sz", j, "Sz", j
     end
-    Ha2 = MPO(ampo2, sites)
+    Ha2 = MPO(os2, sites)
 
     He = heisenbergMPO(sites, ones(N), "Sz * Sz")
     psi = makeRandomMPS(sites)
-    Oe = inner(psi, He, psi)
-    Oa1 = inner(psi, Ha1, psi)
+    Oe = inner(psi', He, psi)
+    Oa1 = inner(psi', Ha1, psi)
     @test Oa1 ≈ Oe
-    Oa2 = inner(psi, Ha2, psi)
+    Oa2 = inner(psi', Ha2, psi)
     @test Oa2 ≈ Oe
   end
 
   @testset "Three-site ops" begin
-    ampo = OpSum()
+    os = OpSum()
     # To test version of add! taking a coefficient
-    add!(ampo, 1.0, "Sz", 1, "Sz", 2, "Sz", 3)
-    @test length(ITensors.data(ampo)) == 1
+    add!(os, 1.0, "Sz", 1, "Sz", 2, "Sz", 3)
+    @test length(os) == 1
     for j in 2:(N - 2)
-      add!(ampo, "Sz", j, "Sz", j + 1, "Sz", j + 2)
+      add!(os, "Sz", j, "Sz", j + 1, "Sz", j + 2)
     end
     h = ones(N)
     for j in 1:N
-      add!(ampo, h[j], "Sx", j)
+      add!(os, h[j], "Sx", j)
     end
     sites = siteinds("S=1/2", N)
-    Ha = MPO(ampo, sites)
+    Ha = MPO(os, sites)
     He = threeSiteIsingMPO(sites, h)
     psi = makeRandomMPS(sites)
-    Oa = inner(psi, Ha, psi)
-    Oe = inner(psi, He, psi)
+    Oa = inner(psi', Ha, psi)
+    Oe = inner(psi', He, psi)
     @test Oa ≈ Oe
   end
 
   @testset "Four-site ops" begin
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 3)
-      add!(ampo, "Sz", j, "Sz", j + 1, "Sz", j + 2, "Sz", j + 3)
+      add!(os, "Sz", j, "Sz", j + 1, "Sz", j + 2, "Sz", j + 3)
     end
     sites = siteinds("S=1/2", N)
-    Ha = MPO(ampo, sites)
+    Ha = MPO(os, sites)
     He = fourSiteIsingMPO(sites)
     psi = makeRandomMPS(sites)
-    Oa = inner(psi, Ha, psi)
-    Oe = inner(psi, He, psi)
+    Oa = inner(psi', Ha, psi)
+    Oe = inner(psi', He, psi)
     @test Oa ≈ Oe
   end
 
   @testset "Next-neighbor Heisenberg" begin
-    ampo = OpSum()
+    os = OpSum()
     J1 = 1.0
     J2 = 0.5
     for j in 1:(N - 1)
-      add!(ampo, J1, "Sz", j, "Sz", j + 1)
-      add!(ampo, J1 * 0.5, "S+", j, "S-", j + 1)
-      add!(ampo, J1 * 0.5, "S-", j, "S+", j + 1)
+      add!(os, J1, "Sz", j, "Sz", j + 1)
+      add!(os, J1 * 0.5, "S+", j, "S-", j + 1)
+      add!(os, J1 * 0.5, "S-", j, "S+", j + 1)
     end
     for j in 1:(N - 2)
-      add!(ampo, J2, "Sz", j, "Sz", j + 2)
-      add!(ampo, J2 * 0.5, "S+", j, "S-", j + 2)
-      add!(ampo, J2 * 0.5, "S-", j, "S+", j + 2)
+      add!(os, J2, "Sz", j, "Sz", j + 2)
+      add!(os, J2 * 0.5, "S+", j, "S-", j + 2)
+      add!(os, J2 * 0.5, "S-", j, "S+", j + 2)
     end
     sites = siteinds("S=1/2", N)
-    Ha = MPO(ampo, sites)
+    Ha = MPO(os, sites)
 
     He = NNheisenbergMPO(sites, J1, J2)
     psi = makeRandomMPS(sites)
-    Oa = inner(psi, Ha, psi)
-    Oe = inner(psi, He, psi)
+    Oa = inner(psi', Ha, psi)
+    Oe = inner(psi', He, psi)
     @test Oa ≈ Oe
     #@test maxlinkdim(Ha) == 8
   end
 
   @testset "Onsite Regression Test" begin
     sites = siteinds("S=1", 4)
-    ampo = OpSum()
-    add!(ampo, 0.5, "Sx", 1)
-    add!(ampo, 0.5, "Sy", 1)
-    H = MPO(ampo, sites)
+    os = OpSum()
+    add!(os, 0.5, "Sx", 1)
+    add!(os, 0.5, "Sy", 1)
+    H = MPO(os, sites)
     l = commonind(H[1], H[2])
     T = setelt(l => 1) * H[1]
     O = op(sites[1], "Sx") + op(sites[1], "Sy")
     @test norm(T - 0.5 * O) < 1E-8
 
     sites = siteinds("S=1", 2)
-    ampo = OpSum()
-    add!(ampo, 0.5im, "Sx", 1)
-    add!(ampo, 0.5, "Sy", 1)
-    H = MPO(ampo, sites)
+    os = OpSum()
+    add!(os, 0.5im, "Sx", 1)
+    add!(os, 0.5, "Sy", 1)
+    H = MPO(os, sites)
     T = H[1] * H[2]
     O =
       im * op(sites[1], "Sx") * op(sites[2], "Id") + op(sites[1], "Sy") * op(sites[2], "Id")
@@ -463,182 +500,182 @@ end
 
   @testset "+ syntax" begin
     @testset "Single creation op" begin
-      ampo = OpSum()
-      ampo += "Adagup", 3
+      os = OpSum()
+      os += "Adagup", 3
       sites = siteinds("Electron", N)
-      W = MPO(ampo, sites)
+      W = MPO(os, sites)
       psi = makeRandomMPS(sites)
       cdu_psi = copy(psi)
       cdu_psi[3] = noprime(cdu_psi[3] * op(sites, "Adagup", 3))
-      @test inner(psi, W, psi) ≈ inner(cdu_psi, psi)
+      @test inner(psi', W, psi) ≈ inner(cdu_psi, psi)
     end
 
     @testset "Ising" begin
-      ampo = OpSum()
+      os = OpSum()
       for j in 1:(N - 1)
-        ampo += "Sz", j, "Sz", j + 1
+        os += "Sz", j, "Sz", j + 1
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = isingMPO(sites)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Ising-Different Order" begin
-      ampo = OpSum()
+      os = OpSum()
       for j in 1:(N - 1)
-        ampo += "Sz", j + 1, "Sz", j
+        os += "Sz", j + 1, "Sz", j
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = isingMPO(sites)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Heisenberg" begin
-      ampo = OpSum()
+      os = OpSum()
       h = rand(N) #random magnetic fields
       for j in 1:(N - 1)
-        ampo += "Sz", j, "Sz", j + 1
-        ampo += 0.5, "S+", j, "S-", j + 1
-        ampo += 0.5, "S-", j, "S+", j + 1
+        os += "Sz", j, "Sz", j + 1
+        os += 0.5, "S+", j, "S-", j + 1
+        os += 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:N
-        ampo += h[j], "Sz", j
+        os += h[j], "Sz", j
       end
 
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = heisenbergMPO(sites, h)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Multiple Onsite Ops" begin
       sites = siteinds("S=1", N)
-      ampo1 = OpSum()
+      os1 = OpSum()
       for j in 1:(N - 1)
-        ampo1 += "Sz", j, "Sz", j + 1
-        ampo1 += 0.5, "S+", j, "S-", j + 1
-        ampo1 += 0.5, "S-", j, "S+", j + 1
+        os1 += "Sz", j, "Sz", j + 1
+        os1 += 0.5, "S+", j, "S-", j + 1
+        os1 += 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:N
-        ampo1 += "Sz * Sz", j
+        os1 += "Sz * Sz", j
       end
-      Ha1 = MPO(ampo1, sites)
+      Ha1 = MPO(os1, sites)
 
-      ampo2 = OpSum()
+      os2 = OpSum()
       for j in 1:(N - 1)
-        ampo2 += "Sz", j, "Sz", j + 1
-        ampo2 += 0.5, "S+", j, "S-", j + 1
-        ampo2 += 0.5, "S-", j, "S+", j + 1
+        os2 += "Sz", j, "Sz", j + 1
+        os2 += 0.5, "S+", j, "S-", j + 1
+        os2 += 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:N
-        ampo2 += "Sz", j, "Sz", j
+        os2 += "Sz", j, "Sz", j
       end
-      Ha2 = MPO(ampo2, sites)
+      Ha2 = MPO(os2, sites)
 
       He = heisenbergMPO(sites, ones(N), "Sz * Sz")
       psi = makeRandomMPS(sites)
-      Oe = inner(psi, He, psi)
-      Oa1 = inner(psi, Ha1, psi)
+      Oe = inner(psi', He, psi)
+      Oa1 = inner(psi', Ha1, psi)
       @test Oa1 ≈ Oe
-      Oa2 = inner(psi, Ha2, psi)
+      Oa2 = inner(psi', Ha2, psi)
       @test Oa2 ≈ Oe
     end
 
     @testset "Three-site ops" begin
-      ampo = OpSum()
+      os = OpSum()
       # To test version of add! taking a coefficient
-      ampo += 1.0, "Sz", 1, "Sz", 2, "Sz", 3
-      @test length(ITensors.data(ampo)) == 1
+      os += 1.0, "Sz", 1, "Sz", 2, "Sz", 3
+      @test length(os) == 1
       for j in 2:(N - 2)
-        ampo += "Sz", j, "Sz", j + 1, "Sz", j + 2
+        os += "Sz", j, "Sz", j + 1, "Sz", j + 2
       end
       h = ones(N)
       for j in 1:N
-        ampo += h[j], "Sx", j
+        os += h[j], "Sx", j
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = threeSiteIsingMPO(sites, h)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Four-site ops" begin
-      ampo = OpSum()
+      os = OpSum()
       for j in 1:(N - 3)
-        ampo += "Sz", j, "Sz", j + 1, "Sz", j + 2, "Sz", j + 3
+        os += "Sz", j, "Sz", j + 1, "Sz", j + 2, "Sz", j + 3
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = fourSiteIsingMPO(sites)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Next-neighbor Heisenberg" begin
-      ampo = OpSum()
+      os = OpSum()
       J1 = 1.0
       J2 = 0.5
       for j in 1:(N - 1)
-        ampo += J1, "Sz", j, "Sz", j + 1
-        ampo += J1 * 0.5, "S+", j, "S-", j + 1
-        ampo += J1 * 0.5, "S-", j, "S+", j + 1
+        os += J1, "Sz", j, "Sz", j + 1
+        os += J1 * 0.5, "S+", j, "S-", j + 1
+        os += J1 * 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:(N - 2)
-        ampo += J2, "Sz", j, "Sz", j + 2
-        ampo += J2 * 0.5, "S+", j, "S-", j + 2
-        ampo += J2 * 0.5, "S-", j, "S+", j + 2
+        os += J2, "Sz", j, "Sz", j + 2
+        os += J2 * 0.5, "S+", j, "S-", j + 2
+        os += J2 * 0.5, "S-", j, "S+", j + 2
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
 
       He = NNheisenbergMPO(sites, J1, J2)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
       #@test maxlinkdim(Ha) == 8
     end
 
     #@testset "-= syntax" begin
-    #  ampo = OpSum()
-    #  ampo += (-1,"Sz",1,"Sz",2)
-    #  ampo2 = OpSum()
-    #  ampo2 -= ("Sz",1,"Sz",2)
-    #  @test ampo == ampo2
+    #  os = OpSum()
+    #  os += (-1,"Sz",1,"Sz",2)
+    #  os2 = OpSum()
+    #  os2 -= ("Sz",1,"Sz",2)
+    #  @test os == os2
     #end
 
     @testset "Onsite Regression Test" begin
       sites = siteinds("S=1", 4)
-      ampo = OpSum()
-      ampo += 0.5, "Sx", 1
-      ampo += 0.5, "Sy", 1
-      H = MPO(ampo, sites)
+      os = OpSum()
+      os += 0.5, "Sx", 1
+      os += 0.5, "Sy", 1
+      H = MPO(os, sites)
       l = commonind(H[1], H[2])
       T = setelt(l => 1) * H[1]
       O = op(sites[1], "Sx") + op(sites[1], "Sy")
       @test norm(T - 0.5 * O) < 1E-8
 
       sites = siteinds("S=1", 2)
-      ampo = OpSum()
-      ampo += 0.5im, "Sx", 1
-      ampo += 0.5, "Sy", 1
-      H = MPO(ampo, sites)
+      os = OpSum()
+      os += 0.5im, "Sx", 1
+      os += 0.5, "Sy", 1
+      H = MPO(os, sites)
       T = H[1] * H[2]
       O =
         im * op(sites[1], "Sx") * op(sites[2], "Id") +
@@ -650,182 +687,182 @@ end
   @testset ".+= and .-= syntax" begin
 
     #@testset ".-= syntax" begin
-    #  ampo = OpSum()
-    #  ampo .+= (-1,"Sz",1,"Sz",2)
-    #  ampo2 = OpSum()
-    #  ampo2 .-= ("Sz",1,"Sz",2)
-    #  @test ampo == ampo2
+    #  os = OpSum()
+    #  os .+= (-1,"Sz",1,"Sz",2)
+    #  os2 = OpSum()
+    #  os2 .-= ("Sz",1,"Sz",2)
+    #  @test os == os2
     #end
 
     @testset "Single creation op" begin
-      ampo = OpSum()
-      ampo .+= "Adagup", 3
+      os = OpSum()
+      os .+= "Adagup", 3
       sites = siteinds("Electron", N)
-      W = MPO(ampo, sites)
+      W = MPO(os, sites)
       psi = makeRandomMPS(sites)
       cdu_psi = copy(psi)
       cdu_psi[3] = noprime(cdu_psi[3] * op(sites, "Adagup", 3))
-      @test inner(psi, W, psi) ≈ inner(cdu_psi, psi)
+      @test inner(psi', W, psi) ≈ inner(cdu_psi, psi)
     end
 
     @testset "Ising" begin
-      ampo = OpSum()
+      os = OpSum()
       for j in 1:(N - 1)
-        ampo .+= "Sz", j, "Sz", j + 1
+        os .+= "Sz", j, "Sz", j + 1
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = isingMPO(sites)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Ising-Different Order" begin
-      ampo = OpSum()
+      os = OpSum()
       for j in 1:(N - 1)
-        ampo .+= "Sz", j + 1, "Sz", j
+        os .+= "Sz", j + 1, "Sz", j
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = isingMPO(sites)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Heisenberg" begin
-      ampo = OpSum()
+      os = OpSum()
       h = rand(N) #random magnetic fields
       for j in 1:(N - 1)
-        ampo .+= "Sz", j, "Sz", j + 1
-        ampo .+= 0.5, "S+", j, "S-", j + 1
-        ampo .+= 0.5, "S-", j, "S+", j + 1
+        os .+= "Sz", j, "Sz", j + 1
+        os .+= 0.5, "S+", j, "S-", j + 1
+        os .+= 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:N
-        ampo .+= h[j], "Sz", j
+        os .+= h[j], "Sz", j
       end
 
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = heisenbergMPO(sites, h)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Multiple Onsite Ops" begin
       sites = siteinds("S=1", N)
-      ampo1 = OpSum()
+      os1 = OpSum()
       for j in 1:(N - 1)
-        ampo1 .+= "Sz", j, "Sz", j + 1
-        ampo1 .+= 0.5, "S+", j, "S-", j + 1
-        ampo1 .+= 0.5, "S-", j, "S+", j + 1
+        os1 .+= "Sz", j, "Sz", j + 1
+        os1 .+= 0.5, "S+", j, "S-", j + 1
+        os1 .+= 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:N
-        ampo1 .+= "Sz * Sz", j
+        os1 .+= "Sz * Sz", j
       end
-      Ha1 = MPO(ampo1, sites)
+      Ha1 = MPO(os1, sites)
 
-      ampo2 = OpSum()
+      os2 = OpSum()
       for j in 1:(N - 1)
-        ampo2 .+= "Sz", j, "Sz", j + 1
-        ampo2 .+= 0.5, "S+", j, "S-", j + 1
-        ampo2 .+= 0.5, "S-", j, "S+", j + 1
+        os2 .+= "Sz", j, "Sz", j + 1
+        os2 .+= 0.5, "S+", j, "S-", j + 1
+        os2 .+= 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:N
-        ampo2 .+= "Sz", j, "Sz", j
+        os2 .+= "Sz", j, "Sz", j
       end
-      Ha2 = MPO(ampo2, sites)
+      Ha2 = MPO(os2, sites)
 
       He = heisenbergMPO(sites, ones(N), "Sz * Sz")
       psi = makeRandomMPS(sites)
-      Oe = inner(psi, He, psi)
-      Oa1 = inner(psi, Ha1, psi)
+      Oe = inner(psi', He, psi)
+      Oa1 = inner(psi', Ha1, psi)
       @test Oa1 ≈ Oe
-      Oa2 = inner(psi, Ha2, psi)
+      Oa2 = inner(psi', Ha2, psi)
       @test Oa2 ≈ Oe
     end
 
     @testset "Three-site ops" begin
-      ampo = OpSum()
+      os = OpSum()
       # To test version of add! taking a coefficient
-      ampo .+= 1.0, "Sz", 1, "Sz", 2, "Sz", 3
-      @test length(ITensors.data(ampo)) == 1
+      os .+= 1.0, "Sz", 1, "Sz", 2, "Sz", 3
+      @test length(os) == 1
       for j in 2:(N - 2)
-        ampo .+= "Sz", j, "Sz", j + 1, "Sz", j + 2
+        os .+= "Sz", j, "Sz", j + 1, "Sz", j + 2
       end
       h = ones(N)
       for j in 1:N
-        ampo .+= h[j], "Sx", j
+        os .+= h[j], "Sx", j
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = threeSiteIsingMPO(sites, h)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Four-site ops" begin
-      ampo = OpSum()
+      os = OpSum()
       for j in 1:(N - 3)
-        ampo .+= "Sz", j, "Sz", j + 1, "Sz", j + 2, "Sz", j + 3
+        os .+= "Sz", j, "Sz", j + 1, "Sz", j + 2, "Sz", j + 3
       end
       sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      Ha = MPO(os, sites)
       He = fourSiteIsingMPO(sites)
       psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
     end
 
     @testset "Next-neighbor Heisenberg" begin
-      ampo = OpSum()
+      os = OpSum()
       J1 = 1.0
       J2 = 0.5
       for j in 1:(N - 1)
-        ampo .+= J1, "Sz", j, "Sz", j + 1
-        ampo .+= J1 * 0.5, "S+", j, "S-", j + 1
-        ampo .+= J1 * 0.5, "S-", j, "S+", j + 1
+        os .+= J1, "Sz", j, "Sz", j + 1
+        os .+= J1 * 0.5, "S+", j, "S-", j + 1
+        os .+= J1 * 0.5, "S-", j, "S+", j + 1
       end
       for j in 1:(N - 2)
-        ampo .+= J2, "Sz", j, "Sz", j + 2
-        ampo .+= J2 * 0.5, "S+", j, "S-", j + 2
-        ampo .+= J2 * 0.5, "S-", j, "S+", j + 2
+        os .+= J2, "Sz", j, "Sz", j + 2
+        os .+= J2 * 0.5, "S+", j, "S-", j + 2
+        os .+= J2 * 0.5, "S-", j, "S+", j + 2
       end
-      sites = siteinds("S=1/2", N)
-      Ha = MPO(ampo, sites)
+      sites = siteinds("S=1/2", N; conserve_qns=true)
+      Ha = MPO(os, sites)
 
       He = NNheisenbergMPO(sites, J1, J2)
-      psi = makeRandomMPS(sites)
-      Oa = inner(psi, Ha, psi)
-      Oe = inner(psi, He, psi)
+      psi = randomMPS(sites, [isodd(n) ? "Up" : "Dn" for n in 1:N])
+      Oa = inner(psi', Ha, psi)
+      Oe = inner(psi', He, psi)
       @test Oa ≈ Oe
       #@test maxlinkdim(Ha) == 8
     end
 
     @testset "Onsite Regression Test" begin
       sites = siteinds("S=1", 4)
-      ampo = OpSum()
-      ampo .+= 0.5, "Sx", 1
-      ampo .+= 0.5, "Sy", 1
-      H = MPO(ampo, sites)
+      os = OpSum()
+      os .+= 0.5, "Sx", 1
+      os .+= 0.5, "Sy", 1
+      H = MPO(os, sites)
       l = commonind(H[1], H[2])
       T = setelt(l => 1) * H[1]
       O = op(sites[1], "Sx") + op(sites[1], "Sy")
       @test norm(T - 0.5 * O) < 1E-8
 
       sites = siteinds("S=1", 2)
-      ampo = OpSum()
-      ampo .+= 0.5im, "Sx", 1
-      ampo .+= 0.5, "Sy", 1
-      H = MPO(ampo, sites)
+      os = OpSum()
+      os .+= 0.5im, "Sx", 1
+      os .+= 0.5, "Sy", 1
+      H = MPO(os, sites)
       T = H[1] * H[2]
       O =
         im * op(sites[1], "Sx") * op(sites[2], "Id") +
@@ -853,16 +890,16 @@ end
     p011 = productMPS(s, [1, 2, 2, 1, 1])
     p110 = productMPS(s, [2, 2, 1, 1, 1])
 
-    @test inner(p110, M1, p011) ≈ -1.0
-    @test inner(p110, M2, p011) ≈ -1.0
-    @test inner(p110, M3, p011) ≈ -1.0
+    @test inner(p110', M1, p011) ≈ -1.0
+    @test inner(p110', M2, p011) ≈ -1.0
+    @test inner(p110', M3, p011) ≈ -1.0
 
     p001 = productMPS(s, [1, 1, 2, 1, 1])
     p100 = productMPS(s, [2, 1, 1, 1, 1])
 
-    @test inner(p100, M1, p001) ≈ +1.0
-    @test inner(p100, M2, p001) ≈ +1.0
-    @test inner(p100, M3, p001) ≈ 0.0
+    @test inner(p100', M1, p001) ≈ +1.0
+    @test inner(p100', M2, p001) ≈ +1.0
+    @test inner(p100', M3, p001) ≈ 0.0
 
     #
     # Repeat similar test but
@@ -888,10 +925,10 @@ end
     p00d = productMPS(s, [1, 1, 3, 1, 1])
     pd00 = productMPS(s, [3, 1, 1, 1, 1])
 
-    @test inner(puu0, M1, p0uu) ≈ -1.0
-    @test inner(pdu0, M2, p0ud) ≈ -1.0
-    @test inner(pu00, M1, p00u) ≈ +1.0
-    @test inner(pd00, M2, p00d) ≈ +1.0
+    @test inner(puu0', M1, p0uu) ≈ -1.0
+    @test inner(pdu0', M2, p0ud) ≈ -1.0
+    @test inner(pu00', M1, p00u) ≈ +1.0
+    @test inner(pd00', M2, p00d) ≈ +1.0
   end
 
   @testset "Complex OpSum Coefs" begin
@@ -899,30 +936,61 @@ end
 
     for use_qn in [false, true]
       sites = siteinds("S=1/2", N; conserve_qns=use_qn)
-      ampo = OpSum()
+      os = OpSum()
       for i in 1:(N - 1)
-        ampo += +1im, "S+", i, "S-", i + 1
-        ampo += -1im, "S-", i, "S+", i + 1
+        os += +1im, "S+", i, "S-", i + 1
+        os += -1im, "S-", i, "S+", i + 1
       end
-      H = MPO(ampo, sites)
+      H = MPO(os, sites)
       psiud = productMPS(sites, [1, 2, 1, 2])
       psidu = productMPS(sites, [2, 1, 1, 2])
-      @test inner(psiud, H, psidu) ≈ +1im
-      @test inner(psidu, H, psiud) ≈ -1im
+      @test inner(psiud', H, psidu) ≈ +1im
+      @test inner(psidu', H, psiud) ≈ -1im
     end
   end
 
+  @testset "Non-zero QN MPO" begin
+    N = 4
+    s = siteinds("Boson", N; conserve_qns=true)
+
+    j = 3
+    terms = OpSum()
+    terms += "Adag", j
+    W = MPO(terms, s)
+
+    function op_mpo(sites, which_op, j)
+      N = length(sites)
+      ops = [n < j ? "Id" : (n > j ? "Id" : which_op) for n in 1:N]
+      M = MPO([op(ops[n], sites[n]) for n in 1:length(sites)])
+      q = flux(op(which_op, sites[j]))
+      links = [Index([n < j ? q => 1 : QN() => 1], "Link,l=$n") for n in 1:N]
+      for n in 1:(N - 1)
+        M[n] *= onehot(links[n] => 1)
+        M[n + 1] *= onehot(dag(links[n]) => 1)
+      end
+      return M
+    end
+    M = op_mpo(s, "Adag", j)
+
+    @test norm(prod(W) - prod(M)) < 1E-10
+
+    psi = randomMPS(s, [isodd(n) ? "1" : "0" for n in 1:length(s)]; linkdims=4)
+    Mpsi = apply(M, psi; alg="naive")
+    Wpsi = apply(M, psi; alg="naive")
+    @test abs(inner(Mpsi, Wpsi) / inner(Mpsi, Mpsi) - 1.0) < 1E-10
+  end
+
   @testset "Fermion OpSum Issue 514 Regression Test" begin
     N = 4
     s = siteinds("Electron", N; conserve_qns=true)
-    ampo1 = OpSum()
-    ampo2 = OpSum()
+    os1 = OpSum()
+    os2 = OpSum()
 
-    ampo1 += "Nup", 1
-    ampo2 += "Cdagup", 1, "Cup", 1
+    os1 += "Nup", 1
+    os2 += "Cdagup", 1, "Cup", 1
 
-    M1 = MPO(ampo1, s)
-    M2 = MPO(ampo2, s)
+    M1 = MPO(os1, s)
+    M2 = MPO(os2, s)
 
     H1 = M1[1] * M1[2] * M1[3] * M1[4]
     H2 = M2[1] * M2[2] * M2[3] * M2[4]
@@ -933,16 +1001,16 @@ end
   @testset "OpSum in-place modification regression test" begin
     N = 2
     t = 1.0
-    ampo = OpSum()
+    os = OpSum()
     for n in 1:(N - 1)
-      ampo .+= -t, "Cdag", n, "C", n + 1
-      ampo .+= -t, "Cdag", n + 1, "C", n
+      os .+= -t, "Cdag", n, "C", n + 1
+      os .+= -t, "Cdag", n + 1, "C", n
     end
     s = siteinds("Fermion", N; conserve_qns=true)
-    ampo_original = deepcopy(ampo)
+    os_original = deepcopy(os)
     for i in 1:4
-      MPO(ampo, s)
-      @test ampo == ampo_original
+      MPO(os, s)
+      @test os == os_original
     end
   end
 
@@ -971,18 +1039,65 @@ end
     N = 20
     sites = siteinds("HardCore", N)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += -t, "Adag", j, "A", j + 1
-      ampo += -t, "A", j, "Adag", j + 1
-      ampo += V1, "N", j, "N", j + 1
+      os += -t, "Adag", j, "A", j + 1
+      os += -t, "A", j, "Adag", j + 1
+      os += V1, "N", j, "N", j + 1
     end
     for j in 1:(N - 2)
-      ampo += V2, "N", j, "N", j + 2
+      os += V2, "N", j, "N", j + 2
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
     psi0 = productMPS(sites, n -> isodd(n) ? "0" : "1")
-    @test abs(inner(psi0, H, psi0) - 0.00018) < 1E-10
+    @test abs(inner(psi0', H, psi0) - 0.00018) < 1E-10
+  end
+
+  @testset "Matrix operator representation" begin
+    dim = 4
+    op = rand(dim, dim)
+    opt = op'
+    s = [Index(dim), Index(dim)]
+    a = OpSum()
+    a += 1.0, op + opt, 1
+    a += 1.0, op + opt, 2
+    mpoa = MPO(a, s)
+    b = OpSum()
+    b += 1.0, op, 1
+    b += 1.0, opt, 1
+    b += 1.0, op, 2
+    b += 1.0, opt, 2
+    mpob = MPO(b, s)
+    @test mpoa ≈ mpob
+  end
+
+  @testset "Matrix operator representation - hashing bug" begin
+    n = 4
+    dim = 4
+    s = siteinds(dim, n)
+    o = rand(dim, dim)
+    os = OpSum()
+    for j in 1:(n - 1)
+      os += copy(o), j, copy(o), j + 1
+    end
+    H1 = MPO(os, s)
+    H2 = ITensor()
+    H2 += op(o, s[1]) * op(o, s[2]) * op("I", s[3]) * op("I", s[4])
+    H2 += op("I", s[1]) * op(o, s[2]) * op(o, s[3]) * op("I", s[4])
+    H2 += op("I", s[1]) * op("I", s[2]) * op(o, s[3]) * op(o, s[4])
+    @test contract(H1) ≈ H2
+  end
+
+  @testset "Matrix operator representation - hashing bug" begin
+    comps, n, dims = load("opsum_hash_bug.jld2", "comps", "n", "dims")
+    s = [Index(d) for d in dims]
+    for _ in 1:100
+      os = components_to_opsum(comps, n)
+      # Before defining `hash(::Op, h::UInt)`, this
+      # would randomly throw an error due to
+      # some hashing issue in `MPO(::OpSum, ...)`
+      MPO(os, s)
+    end
   end
 end
 
diff --git a/test/decomp.jl b/test/decomp.jl
index 1ff48c7d6d..c8ee14e25f 100644
--- a/test/decomp.jl
+++ b/test/decomp.jl
@@ -74,6 +74,15 @@ using ITensors, LinearAlgebra, Test
     eigArr = eigen(array(A))
     @test diag(array(eigA.D), 0) ≈ eigArr.values
     @test diag(array(Dt), 0) == eigArr.values
+
+    @test_throws ArgumentError eigen(ITensor(NaN, i', i))
+    @test_throws ArgumentError eigen(ITensor(NaN, i', i); ishermitian=true)
+    @test_throws ArgumentError eigen(ITensor(complex(NaN), i', i))
+    @test_throws ArgumentError eigen(ITensor(complex(NaN), i', i); ishermitian=true)
+    @test_throws ArgumentError eigen(ITensor(Inf, i', i))
+    @test_throws ArgumentError eigen(ITensor(Inf, i', i); ishermitian=true)
+    @test_throws ArgumentError eigen(ITensor(complex(Inf), i', i))
+    @test_throws ArgumentError eigen(ITensor(complex(Inf), i', i); ishermitian=true)
   end
 
   @testset "exp function" begin
@@ -119,6 +128,30 @@ using ITensors, LinearAlgebra, Test
 
     @test flux(F.Vt) == QN("Sz", 0)
   end
+
+  @testset "SVD block_mindim keyword" begin
+    i = Index(
+      [
+        QN("Sz", 4) => 1,
+        QN("Sz", 2) => 4,
+        QN("Sz", 0) => 6,
+        QN("Sz", -2) => 4,
+        QN("Sz", -4) => 1,
+      ],
+      "i",
+    )
+    j = sim(i)
+    X = randomITensor(QN("Sz", 0), i, j)
+
+    min_blockdim = 2
+    U, S, V = svd(X, i; cutoff=1E-1, min_blockdim)
+    u = commonind(S, U)
+
+    @test nblocks(u) == nblocks(i)
+    for b in 1:nblocks(u)
+      @test blockdim(u, b) == blockdim(i, b) || blockdim(u, b) >= min_blockdim
+    end
+  end
 end
 
 nothing
diff --git a/test/dmrg.jl b/test/dmrg.jl
index 332d694326..5c05456a7b 100644
--- a/test/dmrg.jl
+++ b/test/dmrg.jl
@@ -1,17 +1,19 @@
 using ITensors, Test, Random
 
+using ITensors: nsite, set_nsite!
+
 @testset "Basic DMRG" begin
   @testset "Spin-one Heisenberg" begin
     N = 10
     sites = siteinds("S=1", N)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      add!(ampo, "Sz", j, "Sz", j + 1)
-      add!(ampo, 0.5, "S+", j, "S-", j + 1)
-      add!(ampo, 0.5, "S-", j, "S+", j + 1)
+      add!(os, "Sz", j, "Sz", j + 1)
+      add!(os, 0.5, "S+", j, "S-", j + 1)
+      add!(os, 0.5, "S-", j, "S+", j + 1)
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     psi = randomMPS(sites)
 
@@ -31,13 +33,13 @@ using ITensors, Test, Random
     N = 10
     sites = siteinds("S=1", N; conserve_qns=true)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += "Sz", j, "Sz", j + 1
-      ampo += 0.5, "S+", j, "S-", j + 1
-      ampo += 0.5, "S-", j, "S+", j + 1
+      os += "Sz", j, "Sz", j + 1
+      os += 0.5, "S+", j, "S-", j + 1
+      os += 0.5, "S-", j, "S+", j + 1
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     state = [isodd(n) ? "Up" : "Dn" for n in 1:N]
     psi = randomMPS(sites, state; linkdims=4)
@@ -58,13 +60,13 @@ using ITensors, Test, Random
     N = 10
     sites = siteinds("S=1", N; conserve_qns=true)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += "Sz", j, "Sz", j + 1
-      ampo += 0.5, "S+", j, "S-", j + 1
-      ampo += 0.5, "S-", j, "S+", j + 1
+      os += "Sz", j, "Sz", j + 1
+      os += 0.5, "S+", j, "S-", j + 1
+      os += 0.5, "S-", j, "S+", j + 1
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     state = [isodd(n) ? "Up" : "Dn" for n in 1:N]
     psi = randomMPS(sites, state; linkdims=4)
@@ -85,18 +87,20 @@ using ITensors, Test, Random
     N = 10
     sites = siteinds("S=1", N; conserve_qns=true)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += "Sz", j, "Sz", j + 1
-      ampo += 0.5, "S+", j, "S-", j + 1
-      ampo += 0.5, "S-", j, "S+", j + 1
+      os += "Sz", j, "Sz", j + 1
+      os += 0.5, "S+", j, "S-", j + 1
+      os += 0.5, "S-", j, "S+", j + 1
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     state = [isodd(n) ? "Up" : "Dn" for n in 1:N]
     psi = randomMPS(sites, state; linkdims=4)
     PH = ProjMPO(H)
 
+    PHc = copy(PH)
+
     n = 4
     orthogonalize!(psi, n)
     position!(PH, psi, n)
@@ -109,6 +113,8 @@ using ITensors, Test, Random
     @test size(PH) == (3^2 * 4^2, 3^2 * 4^2)
     @test PH.lpos == n - 1
     @test PH.rpos == n + 2
+    @test PHc.lpos == 0
+    @test PHc.rpos == N + 1
     @test rproj(PH) ≈ rproj(PHdisk)
     @test PHdisk.LR isa ITensors.DiskVector{ITensor}
     @test PHdisk.LR[PHdisk.rpos] ≈ PHdisk.Rcache
@@ -116,18 +122,56 @@ using ITensors, Test, Random
     @test PH.lpos == N - 1
   end
 
+  @testset "ProjMPO: nsite" begin
+    N = 10
+    sites = siteinds("S=1", N)
+
+    os1 = OpSum()
+    for j in 1:(N - 1)
+      os1 += 0.5, "S+", j, "S-", j + 1
+      os1 += 0.5, "S-", j, "S+", j + 1
+    end
+    os2 = OpSum()
+    for j in 1:(N - 1)
+      os2 += "Sz", j, "Sz", j + 1
+    end
+    H1 = MPO(os1, sites)
+    H2 = MPO(os2, sites)
+
+    state = [isodd(n) ? "Up" : "Dn" for n in 1:N]
+    psi = randomMPS(sites, state; linkdims=4)
+    PH1 = ProjMPO(H1)
+    PH = ProjMPOSum([H1, H2])
+    PH1c = copy(PH1)
+    PHc = copy(PH)
+    @test nsite(PH1) == 2
+    @test nsite(PH) == 2
+    @test nsite(PH1c) == 2
+    @test nsite(PHc) == 2
+
+    set_nsite!(PH1, 3)
+    @test nsite(PH1) == 3
+    @test nsite(PH1c) == 2
+    @test nsite(PHc) == 2
+
+    set_nsite!(PH, 4)
+    @test nsite(PH) == 4
+    @test nsite(PH1c) == 2
+    @test nsite(PHc) == 2
+  end
+
   @testset "Transverse field Ising" begin
     N = 32
     sites = siteinds("S=1/2", N)
     Random.seed!(432)
     psi0 = randomMPS(sites)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:N
-      j < N && add!(ampo, -1.0, "Z", j, "Z", j + 1)
-      add!(ampo, -1.0, "X", j)
+      j < N && add!(os, -1.0, "Z", j, "Z", j + 1)
+      add!(os, -1.0, "X", j)
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     sweeps = Sweeps(5)
     maxdim!(sweeps, 10, 20)
@@ -174,12 +218,12 @@ using ITensors, Test, Random
     state = [isodd(j) ? "↑" : "↓" for j in 1:N]
     psi0 = randomMPS(sites, state)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:N
-      j < N && add!(ampo, -1.0, "X", j, "X", j + 1)
-      add!(ampo, -1.0, "Z", j)
+      j < N && add!(os, -1.0, "X", j, "X", j + 1)
+      add!(os, -1.0, "Z", j)
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     sweeps = Sweeps(5)
     maxdim!(sweeps, 10, 20)
@@ -205,14 +249,14 @@ using ITensors, Test, Random
     Random.seed!(42)
     psi0 = randomMPS(sites)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += -1, "Sz", j, "Sz", j + 1
+      os += -1, "Sz", j, "Sz", j + 1
     end
     for j in 1:N
-      ampo += -0.2, "Sx", j
+      os += -0.2, "Sx", j
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     sweeps = Sweeps(3)
     maxdim!(sweeps, 10)
@@ -239,18 +283,18 @@ using ITensors, Test, Random
     N = 10
     sites = siteinds("S=1", N)
 
-    ampoZ = OpSum()
+    osZ = OpSum()
     for j in 1:(N - 1)
-      ampoZ += "Sz", j, "Sz", j + 1
+      osZ += "Sz", j, "Sz", j + 1
     end
-    HZ = MPO(ampoZ, sites)
+    HZ = MPO(osZ, sites)
 
-    ampoXY = OpSum()
+    osXY = OpSum()
     for j in 1:(N - 1)
-      ampoXY += 0.5, "S+", j, "S-", j + 1
-      ampoXY += 0.5, "S-", j, "S+", j + 1
+      osXY += 0.5, "S+", j, "S-", j + 1
+      osXY += 0.5, "S-", j, "S+", j + 1
     end
-    HXY = MPO(ampoXY, sites)
+    HXY = MPO(osXY, sites)
 
     psi = randomMPS(sites)
 
@@ -271,13 +315,13 @@ using ITensors, Test, Random
     sites[1] = Index(2, "S=1/2,n=1,Site")
     sites[N] = Index(2, "S=1/2,n=$N,Site")
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += "Sz", j, "Sz", j + 1
-      ampo += 0.5, "S+", j, "S-", j + 1
-      ampo += 0.5, "S-", j, "S+", j + 1
+      os += "Sz", j, "Sz", j + 1
+      os += 0.5, "S+", j, "S-", j + 1
+      os += 0.5, "S-", j, "S+", j + 1
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     psi0i = randomMPS(sites; linkdims=10)
 
@@ -312,17 +356,17 @@ using ITensors, Test, Random
     state[7] = 2
     psi0 = productMPS(s, state)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      ampo += -t1, "Cdag", j, "C", j + 1
-      ampo += -t1, "Cdag", j + 1, "C", j
-      ampo += V, "N", j, "N", j + 1
+      os += -t1, "Cdag", j, "C", j + 1
+      os += -t1, "Cdag", j + 1, "C", j
+      os += V, "N", j, "N", j + 1
     end
     for j in 1:(N - 2)
-      ampo += -t2, "Cdag", j, "C", j + 2
-      ampo += -t2, "Cdag", j + 2, "C", j
+      os += -t2, "Cdag", j, "C", j + 2
+      os += -t2, "Cdag", j + 2, "C", j
     end
-    H = MPO(ampo, s)
+    H = MPO(os, s)
 
     sweeps = Sweeps(5)
     maxdim!(sweeps, 10, 20, 100, 100, 200)
@@ -340,18 +384,18 @@ using ITensors, Test, Random
     U = 1.0
     V1 = 0.5
     sites = siteinds("Electron", N; conserve_qns=true)
-    ampo = OpSum()
+    os = OpSum()
     for i in 1:N
-      ampo += (U, "Nupdn", i)
+      os += (U, "Nupdn", i)
     end
     for b in 1:(N - 1)
-      ampo += -t1, "Cdagup", b, "Cup", b + 1
-      ampo += -t1, "Cdagup", b + 1, "Cup", b
-      ampo += -t1, "Cdagdn", b, "Cdn", b + 1
-      ampo += -t1, "Cdagdn", b + 1, "Cdn", b
-      ampo += V1, "Ntot", b, "Ntot", b + 1
+      os += -t1, "Cdagup", b, "Cup", b + 1
+      os += -t1, "Cdagup", b + 1, "Cup", b
+      os += -t1, "Cdagdn", b, "Cdn", b + 1
+      os += -t1, "Cdagdn", b + 1, "Cdn", b
+      os += V1, "Ntot", b, "Ntot", b + 1
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
     sweeps = Sweeps(6)
     maxdim!(sweeps, 50, 100, 200, 400, 800, 800)
     cutoff!(sweeps, 1E-10)
@@ -365,13 +409,13 @@ using ITensors, Test, Random
     N = 6
     sites = siteinds("S=1", N)
 
-    ampo = OpSum()
+    os = OpSum()
     for j in 1:(N - 1)
-      add!(ampo, "Sz", j, "Sz", j + 1)
-      add!(ampo, 0.5, "S+", j, "S-", j + 1)
-      add!(ampo, 0.5, "S-", j, "S+", j + 1)
+      add!(os, "Sz", j, "Sz", j + 1)
+      add!(os, 0.5, "S+", j, "S-", j + 1)
+      add!(os, 0.5, "S-", j, "S+", j + 1)
     end
-    H = MPO(ampo, sites)
+    H = MPO(os, sites)
 
     sweeps = Sweeps(1)
     maxdim!(sweeps, 10)
diff --git a/test/fermions.jl b/test/fermions.jl
index cb66a93ef8..dca999d03e 100644
--- a/test/fermions.jl
+++ b/test/fermions.jl
@@ -554,8 +554,8 @@ using ITensors, Test
         psiA = productMPS(sites, stateA)
         psiB = productMPS(sites, stateB)
 
-        @test inner(psiA, H, psiB) ≈ -t1
-        @test inner(psiB, H, psiA) ≈ -t1
+        @test inner(psiA', H, psiB) ≈ -t1
+        @test inner(psiB', H, psiA) ≈ -t1
       end
 
       for j in 1:(N - 1)
@@ -563,7 +563,7 @@ using ITensors, Test
         state[j] = 2
         state[j + 1] = 2
         psi = productMPS(sites, state)
-        @test inner(psi, H, psi) ≈ V1
+        @test inner(psi', H, psi) ≈ V1
       end
     end
 
@@ -598,13 +598,13 @@ using ITensors, Test
       state3[4] = 2
       psi3 = productMPS(s, state3)
 
-      @test inner(psi1, H, psi2) ≈ -t1
-      @test inner(psi2, H, psi1) ≈ -t1
-      @test inner(psi2, H, psi3) ≈ -t1
-      @test inner(psi3, H, psi2) ≈ -t1
+      @test inner(psi1', H, psi2) ≈ -t1
+      @test inner(psi2', H, psi1) ≈ -t1
+      @test inner(psi2', H, psi3) ≈ -t1
+      @test inner(psi3', H, psi2) ≈ -t1
 
-      @test inner(psi1, H, psi3) ≈ -t2
-      @test inner(psi3, H, psi1) ≈ -t2
+      @test inner(psi1', H, psi3) ≈ -t2
+      @test inner(psi3', H, psi1) ≈ -t2
 
       # Add stationary particle to site 2,
       # hopping over should change sign:
@@ -612,8 +612,8 @@ using ITensors, Test
       psi1 = productMPS(s, state1)
       state3[2] = 2
       psi3 = productMPS(s, state3)
-      @test inner(psi1, H, psi3) ≈ +t2
-      @test inner(psi3, H, psi1) ≈ +t2
+      @test inner(psi1', H, psi3) ≈ +t2
+      @test inner(psi3', H, psi1) ≈ +t2
     end
   end
 
@@ -796,7 +796,7 @@ using ITensors, Test
 
       energy, psi = dmrg(Ht, psi0, sweeps; outputlevel=0)
 
-      energy_inner = inner(psi, Ht, psi)
+      energy_inner = inner(psi', Ht, psi)
 
       C = correlation_matrix(psi, "Cdag", "C")
       C_energy =
diff --git a/test/itensor.jl b/test/itensor.jl
index 9cb8eba48b..94cc518b89 100644
--- a/test/itensor.jl
+++ b/test/itensor.jl
@@ -54,6 +54,39 @@ end
       @test !hascommoninds(A, C)
     end
 
+    @testset "isreal, iszero, real, imag" begin
+      i, j = Index.(2, ("i", "j"))
+      A = randomITensor(i, j)
+      Ac = randomITensor(ComplexF64, i, j)
+      Ar = real(Ac)
+      Ai = imag(Ac)
+      @test Ac ≈ Ar + im * Ai
+      @test isreal(A)
+      @test !isreal(Ac)
+      @test isreal(Ar)
+      @test isreal(Ai)
+      @test !iszero(A)
+      @test !iszero(real(A))
+      @test iszero(imag(A))
+      @test iszero(ITensor(0.0, i, j))
+      @test iszero(ITensor(i, j))
+    end
+
+    @testset "map" begin
+      A = randomITensor(Index(2))
+      @test eltype(A) == Float64
+      B = map(ComplexF64, A)
+      @test B ≈ A
+      @test eltype(B) == ComplexF64
+      B = map(Float32, A)
+      @test B ≈ A
+      @test eltype(B) == Float32
+      B = map(x -> 2x, A)
+      @test B ≈ 2A
+      @test eltype(B) == Float64
+      @test_throws ErrorException map(x -> x + 1, A)
+    end
+
     @testset "getindex with state string" begin
       i₁ = Index(2, "S=1/2")
       i₂ = Index(2, "S=1/2")
@@ -628,6 +661,7 @@ end
     i = Index(2, "i")
 
     T = onehot(i => 1)
+    @test eltype(T) === Float64
     @test T[i => 1] ≈ 1.0
     @test T[i => 2] ≈ 0.0
 
@@ -642,6 +676,16 @@ end
     @test T[j => 2, i => 1] ≈ 1.0
     @test T[j => 1, i => 2] ≈ 0.0
     @test T[j => 2, i => 2] ≈ 0.0
+
+    T = onehot(Float32, i => 1)
+    @test eltype(T) === Float32
+    @test T[i => 1] ≈ 1.0
+    @test T[i => 2] ≈ 0.0
+
+    T = onehot(ComplexF32, i => 1)
+    @test eltype(T) === ComplexF32
+    @test T[i => 1] ≈ 1.0
+    @test T[i => 2] ≈ 0.0
   end
 
   @testset "add, subtract, and axpy" begin
@@ -1249,6 +1293,25 @@ end
         array(permute(A, i, j, k)) + array(permute(B, i, j, k))
     end
 
+    @testset "Test array" begin
+      A = randomITensor(SType, i, j, k)
+      B = randomITensor(SType, i, j)
+      C = randomITensor(SType, i)
+
+      @test array(permute(A, j, i, k)) == array(A, j, i, k)
+      @test_throws DimensionMismatch matrix(A, j, i, k)
+      @test_throws DimensionMismatch vector(A, j, i, k)
+
+      @test array(permute(B, j, i)) == array(B, j, i)
+      @test matrix(permute(B, j, i)) == matrix(B, j, i)
+      @test_throws DimensionMismatch vector(B, j, i)
+
+      @test array(permute(C, i)) == array(C, i)
+      @test vector(permute(C, i)) == vector(C, i)
+      @test vector(C) == vector(C, i)
+      @test_throws DimensionMismatch matrix(C, i)
+    end
+
     @testset "Test factorizations of an ITensor" begin
       A = randomITensor(SType, i, j, k, l)
 
@@ -1401,9 +1464,8 @@ end
 
       @testset "Test error for bad decomposition inputs" begin
         @test_throws ErrorException svd(A)
-        @test_throws ErrorException svd(A, inds(A))
+        @test_throws ErrorException factorize(A)
         @test_throws ErrorException eigen(A, inds(A), inds(A))
-        #@test_throws ErrorException factorize(A)
       end
     end
   end # End Dense storage test
@@ -1598,6 +1660,49 @@ end
         end
       end
     end
+
+    i1, i2, j, k, l = Index.((2, 3, 4, 5, 6), ("i1", "i2", "j", "k", "l"))
+
+    A = randomITensor(i1, i2, j)
+    B = randomITensor(i1, i2, k)
+    C = randomITensor(i1, i2, l)
+
+    S, s = directsum(A => j, B => k)
+    @test dim(s) == dim(j) + dim(k)
+    @test hassameinds(S, (i1, i2, s))
+
+    S, s = (A => j) ⊕ (B => k)
+    @test dim(s) == dim(j) + dim(k)
+    @test hassameinds(S, (i1, i2, s))
+
+    S, s = directsum(A => j, B => k, C => l)
+    @test dim(s) == dim(j) + dim(k) + dim(l)
+    @test hassameinds(S, (i1, i2, s))
+
+    @test_throws ErrorException directsum(A => i2, B => i2)
+
+    S, (s,) = directsum(A => (j,), B => (k,))
+    @test s == uniqueind(S, A)
+    @test dim(s) == dim(j) + dim(k)
+    @test hassameinds(S, (i1, i2, s))
+
+    S, ss = directsum(A => (i2, j), B => (i2, k))
+    @test length(ss) == 2
+    @test dim(ss[1]) == dim(i2) + dim(i2)
+    @test hassameinds(S, (i1, ss...))
+
+    S, ss = directsum(A => (j,), B => (k,), C => (l,))
+    s = only(ss)
+    @test s == uniqueind(S, A)
+    @test dim(s) == dim(j) + dim(k) + dim(l)
+    @test hassameinds(S, (i1, i2, s))
+
+    S, ss = directsum(A => (i2, i1, j), B => (i1, i2, k), C => (i1, i2, l))
+    @test length(ss) == 3
+    @test dim(ss[1]) == dim(i2) + dim(i1) + dim(i1)
+    @test dim(ss[2]) == dim(i1) + dim(i2) + dim(i2)
+    @test dim(ss[3]) == dim(j) + dim(k) + dim(l)
+    @test hassameinds(S, ss)
   end
 
   @testset "ishermitian" begin
@@ -1607,6 +1712,56 @@ end
     @test ishermitian(Sz)
     @test !ishermitian(Sp)
   end
+
+  @testset "convert_eltype, convert_leaf_eltype, $new_eltype" for new_eltype in
+                                                                  (Float32, ComplexF64)
+    s = Index(2)
+    A = randomITensor(s)
+    @test eltype(A) == Float64
+
+    Af32 = convert_eltype(new_eltype, A)
+    @test Af32 ≈ A
+    @test eltype(Af32) == new_eltype
+
+    Af32_2 = convert_leaf_eltype(new_eltype, A)
+    @test eltype(Af32_2) == new_eltype
+    @test Af32_2 ≈ A
+
+    As1 = [A, A]
+    As1_f32 = convert_leaf_eltype(new_eltype, As1)
+    @test length(As1_f32) == length(As1)
+    @test typeof(As1_f32) == typeof(As1)
+    @test eltype(As1_f32[1]) == new_eltype
+    @test eltype(As1_f32[2]) == new_eltype
+
+    As2 = [[A, A], [A]]
+    As2_f32 = convert_leaf_eltype(new_eltype, As2)
+    @test length(As2_f32) == length(As2)
+    @test typeof(As2_f32) == typeof(As2)
+    @test eltype(As2_f32[1][1]) == new_eltype
+    @test eltype(As2_f32[1][2]) == new_eltype
+    @test eltype(As2_f32[2][1]) == new_eltype
+  end
+
+  @testset "nullspace $eltype" for (ss, sl, sr) in [
+      ([QN(-1) => 2, QN(1) => 3], [QN(-1) => 2], [QN(0) => 3]), (5, 2, 3)
+    ],
+    eltype in (Float32, Float64, ComplexF32, ComplexF64),
+    nullspace_kwargs in ((; atol=eps(real(eltype)) * 100), (;))
+
+    s, l, r = Index.((ss, sl, sr), ("s", "l", "r"))
+    A = randomITensor(eltype, dag(l), s, r)
+    N = nullspace(A, dag(l); nullspace_kwargs...)
+    @test Base.eltype(N) === eltype
+    n = uniqueind(N, A)
+    @test op("I", n) ≈ N * dag(prime(N, n))
+    @test hassameinds(N, (s, r, n))
+    @test norm(A * N) ≈ 0 atol = eps(real(eltype)) * 100
+    @test dim(l) + dim(n) == dim((s, r))
+    A′, (rn,) = ITensors.directsum(A => (l,), dag(N) => (n,); tags=["⊕"])
+    @test dim(rn) == dim((s, r))
+    @test norm(A * dag(prime(A, l))) ≈ norm(A * dag(A′))
+  end
 end # End Dense ITensor basic functionality
 
 # Disable debug checking once tests are completed
diff --git a/test/mpo.jl b/test/mpo.jl
index b322a2a584..0984856b39 100644
--- a/test/mpo.jl
+++ b/test/mpo.jl
@@ -53,10 +53,10 @@ end
     K = randomMPO(sites)
     orthogonalize!(phi, 1)
     orthogonalize!(K, 1)
-    orig_inner = ⋅(phi, K, phi)
+    orig_inner = ⋅(phi', K, phi)
     orthogonalize!(phi, div(N, 2))
     orthogonalize!(K, div(N, 2))
-    @test ⋅(phi, K, phi) ≈ orig_inner
+    @test ⋅(phi', K, phi) ≈ orig_inner
   end
 
   @testset "norm MPO" begin
@@ -102,11 +102,11 @@ end
     for j in 2:N
       phiKpsi *= phidag[j] * K[j] * psi[j]
     end
-    @test phiKpsi[] ≈ inner(phi, K, psi)
+    @test phiKpsi[] ≈ inner(phi', K, psi)
 
     badsites = [Index(2, "Site") for n in 1:(N + 1)]
     badpsi = randomMPS(badsites)
-    @test_throws DimensionMismatch inner(phi, K, badpsi)
+    @test_throws DimensionMismatch inner(phi', K, badpsi)
 
     # make bigger random MPO...
     for link_dim in 2:5
@@ -142,7 +142,7 @@ end
       for j in 2:N
         phiKpsi *= phidag[j] * K[j] * psi[j]
       end
-      @test scalar(phiKpsi) ≈ inner(phi, K, psi)
+      @test scalar(phiKpsi) ≈ inner(phi', K, psi)
     end
   end
 
@@ -182,7 +182,7 @@ end
     psi = makeRandomMPS(sites)
 
     dist = sqrt(
-      abs(1 + (inner(phi, phi) - 2 * real(inner(phi, K, psi))) / inner(K, psi, K, psi))
+      abs(1 + (inner(phi, phi) - 2 * real(inner(phi', K, psi))) / inner(K, psi, K, psi))
     )
     @test dist ≈ error_contract(phi, K, psi)
 
@@ -190,7 +190,7 @@ end
     badpsi = randomMPS(badsites)
     # Apply K to phi and check that error_contract is close to 0.
     Kphi = contract(K, phi; method="naive", cutoff=1E-8)
-    @test error_contract(Kphi, K, phi) ≈ 0.0 atol = 1e-4
+    @test error_contract(noprime(Kphi), K, phi) ≈ 0.0 atol = 1e-4
 
     @test_throws DimensionMismatch contract(K, badpsi; method="naive", cutoff=1E-8)
     @test_throws DimensionMismatch error_contract(phi, K, badpsi)
@@ -202,8 +202,8 @@ end
     @test maxlinkdim(K) == 1
     psi = randomMPS(sites)
     psi_out = contract(K, psi; maxdim=1)
-    @test inner(phi, psi_out) ≈ inner(phi, K, psi)
-    @test_throws ArgumentError contract(K, psi; method="fakemethod")
+    @test inner(phi', psi_out) ≈ inner(phi', K, psi)
+    @test_throws MethodError contract(K, psi; method="fakemethod")
 
     badsites = [Index(2, "Site") for n in 1:(N + 1)]
     badpsi = randomMPS(badsites)
@@ -238,7 +238,7 @@ end
       orthogonalize!(K, 1; maxdim=link_dim)
       orthogonalize!(phi, 1; normalize=true, maxdim=link_dim)
       psi_out = contract(deepcopy(K), deepcopy(psi); maxdim=10 * link_dim, cutoff=0.0)
-      @test inner(phi, psi_out) ≈ inner(phi, K, psi)
+      @test inner(phi', psi_out) ≈ inner(phi', K, psi)
     end
   end
 
@@ -251,8 +251,8 @@ end
     psi = randomMPS(shsites)
     k_psi = contract(K, psi; maxdim=1)
     l_psi = contract(L, psi; maxdim=1)
-    @test inner(psi, k_psi + l_psi) ≈ ⋅(psi, M, psi) atol = 5e-3
-    @test inner(psi, sum([k_psi, l_psi])) ≈ dot(psi, M, psi) atol = 5e-3
+    @test inner(psi', k_psi + l_psi) ≈ ⋅(psi', M, psi) atol = 5e-3
+    @test inner(psi', sum([k_psi, l_psi])) ≈ dot(psi', M, psi) atol = 5e-3
     for dim in 2:4
       shsites = siteinds("S=1/2", N)
       K = basicRandomMPO(shsites; dim=dim)
@@ -262,13 +262,13 @@ end
       psi = randomMPS(shsites)
       k_psi = contract(K, psi)
       l_psi = contract(L, psi)
-      @test inner(psi, k_psi + l_psi) ≈ dot(psi, M, psi) atol = 5e-3
-      @test inner(psi, sum([k_psi, l_psi])) ≈ inner(psi, M, psi) atol = 5e-3
+      @test inner(psi', k_psi + l_psi) ≈ dot(psi', M, psi) atol = 5e-3
+      @test inner(psi', sum([k_psi, l_psi])) ≈ inner(psi', M, psi) atol = 5e-3
       psi = randomMPS(shsites)
       M = add(K, L; cutoff=1E-9)
       k_psi = contract(K, psi)
       l_psi = contract(L, psi)
-      @test inner(psi, k_psi + l_psi) ≈ inner(psi, M, psi) atol = 5e-3
+      @test inner(psi', k_psi + l_psi) ≈ inner(psi', M, psi) atol = 5e-3
     end
   end
 
@@ -312,7 +312,7 @@ end
     @test maxlinkdim(L) == 1
     KL = contract(prime(K), L; maxdim=1)
     psi_kl_out = contract(prime(K), contract(L, psi; maxdim=1); maxdim=1)
-    @test inner(psi, KL, psi) ≈ inner(psi, psi_kl_out) atol = 5e-3
+    @test inner(psi'', KL, psi) ≈ inner(psi'', psi_kl_out) atol = 5e-3
 
     # where both K and L have differently labelled sites
     othersitesk = [Index(2, "Site,aaa") for n in 1:N]
@@ -342,7 +342,13 @@ end
     @test maxlinkdim(L) == 1
     KL = *(prime(K), L; maxdim=1)
     psi_kl_out = *(prime(K), *(L, psi; maxdim=1); maxdim=1)
-    @test ⋅(psi, KL, psi) ≈ dot(psi, psi_kl_out) atol = 5e-3
+    @test ⋅(psi'', KL, psi) ≈ dot(psi'', psi_kl_out) atol = 5e-3
+
+    @test_throws ErrorException K * L
+    @test_throws ErrorException contract(K, L)
+
+    @test replaceprime(KL, 2 => 1) ≈ apply(K, L; maxdim=1)
+    @test replaceprime(KL, 2 => 1) ≈ K(L; maxdim=1)
 
     # where both K and L have differently labelled sites
     othersitesk = [Index(2, "Site,aaa") for n in 1:N]
@@ -364,6 +370,14 @@ end
     @test_throws DimensionMismatch K * badL
   end
 
+  @testset "Multi-arg apply(::MPO...)" begin
+    ρ1 = (x -> outer(x', x; maxdim=4))(randomMPS(sites; linkdims=2))
+    ρ2 = (x -> outer(x', x; maxdim=4))(randomMPS(sites; linkdims=2))
+    ρ3 = (x -> outer(x', x; maxdim=4))(randomMPS(sites; linkdims=2))
+    @test apply(ρ1, ρ2, ρ3; cutoff=1e-8) ≈
+      apply(apply(ρ1, ρ2; cutoff=1e-8), ρ3; cutoff=1e-8)
+  end
+
   sites = siteinds("S=1/2", N)
   O = MPO(sites, "Sz")
   @test length(O) == N # just make sure this works
@@ -393,7 +407,7 @@ end
     l = [Index(3, "left_$n") for n in 1:2]
     r = [Index(3, "right_$n") for n in 1:2]
 
-    sis = IndexSet.(prime.(s), s)
+    sis = [[sₙ', sₙ] for sₙ in s]
 
     A = randomITensor(s..., prime.(s)...)
     ψ = MPO(A, sis; orthocenter=4)
@@ -423,6 +437,10 @@ end
     @test ITensors.orthocenter(ψ) == 3
     @test maxlinkdim(ψ) == 1
 
+    # Use matrix
+    @test_throws ErrorException MPO(s, [1/2 0; 0 1/2])
+    @test MPO(s, _ -> [1/2 0; 0 1/2]) ≈ MPO(s, "Id") ./ 2
+
     ψ0 = MPO(s, "Id")
     A = prod(ψ0)
     ψ = MPO(A, s; cutoff=1e-15, orthocenter=3)
@@ -532,7 +550,7 @@ end
     M = A' * dag(A)
     ψ = MPS(A, [i, j])
     @test prod(ψ) ≈ A
-    ρ = outer(ψ, ψ)
+    ρ = outer(ψ', ψ)
     @test prod(ρ) ≈ M
     ρ = projector(ψ; normalize=false)
     @test prod(ρ) ≈ M
@@ -555,7 +573,7 @@ end
     Pψ = projector(ψ; normalize=false, cutoff=1e-8)
     Pψᴴ = swapprime(dag(Pψ), 0 => 1)
     @test maxlinkdim(Pψ) == χψ^2
-    @test sqrt(inner(Pψ, Pψ) + inner(ψ, ψ)^2 - inner(ψ, Pψ, ψ) - inner(ψ, Pψᴴ, ψ)) /
+    @test sqrt(inner(Pψ, Pψ) + inner(ψ, ψ)^2 - inner(ψ', Pψ, ψ) - inner(ψ', Pψᴴ, ψ)) /
           abs(inner(ψ, ψ)) ≈ 0 atol = 1e-5 * N
 
     normψ = norm(ψ)
@@ -563,15 +581,15 @@ end
     Pψᴴ = swapprime(dag(Pψ), 0 => 1)
     @test maxlinkdim(Pψ) == χψ^2
     @test sqrt(
-      inner(Pψ, Pψ) * normψ^4 + inner(ψ, ψ)^2 - inner(ψ, Pψ, ψ) * normψ^2 -
-      inner(ψ, Pψᴴ, ψ) * normψ^2,
+      inner(Pψ, Pψ) * normψ^4 + inner(ψ, ψ)^2 - inner(ψ', Pψ, ψ) * normψ^2 -
+      inner(ψ', Pψᴴ, ψ) * normψ^2,
     ) / abs(inner(ψ, ψ)) ≈ 0 atol = 1e-5 * N
 
-    ψϕ = outer(ψ, ϕ; cutoff=1e-8)
+    ψϕ = outer(ψ', ϕ; cutoff=1e-8)
     ϕψ = swapprime(dag(ψϕ), 0 => 1)
     @test maxlinkdim(ψϕ) == χψ * χϕ
     @test sqrt(
-      inner(ψϕ, ψϕ) + inner(ψ, ψ) * inner(ϕ, ϕ) - inner(ψ, ψϕ, ϕ) - inner(ϕ, ϕψ, ψ)
+      inner(ψϕ, ψϕ) + inner(ψ, ψ) * inner(ϕ, ϕ) - inner(ψ', ψϕ, ϕ) - inner(ϕ', ϕψ, ψ)
     ) / sqrt(inner(ψ, ψ) * inner(ϕ, ϕ)) ≈ 0 atol = 1e-5 * N
   end
 
@@ -683,6 +701,34 @@ end
     for d in dims
       @test d <= chi1 * chi2
     end
+
+    @test apply(A, psi) ≈ noprime(Apsi)
+    @test ITensors.materialize(Apply(A, psi)) ≈ noprime(Apsi)
+    @test A(psi) ≈ noprime(Apsi)
+    @test inner(noprime(Apsi), Apply(A, psi)) ≈ inner(Apsi, Apsi)
+  end
+
+  @testset "MPO with no link indices" for conserve_qns in [false, true]
+    s = siteinds("S=1/2", 4; conserve_qns)
+    H = MPO([op("Id", sn) for sn in s])
+    @test linkinds(H) == fill(nothing, length(s) - 1)
+    @test norm(H) == √(2^length(s))
+
+    Hortho = orthogonalize(H, 1)
+    @test Hortho ≈ H
+    @test linkdims(Hortho) == fill(1, length(s) - 1)
+
+    Htrunc = truncate(H; cutoff=1e-8)
+    @test Htrunc ≈ H
+    @test linkdims(Htrunc) == fill(1, length(s) - 1)
+
+    H² = apply(H, H; cutoff=1e-8)
+    H̃² = MPO([apply(H[n], H[n]) for n in 1:length(s)])
+    @test linkdims(H²) == fill(1, length(s) - 1)
+    @test H² ≈ H̃²
+
+    e, ψ = dmrg(H, randomMPS(s, n -> isodd(n) ? "↑" : "↓"); nsweeps=2, outputlevel=0)
+    @test e ≈ 1
   end
 end
 
diff --git a/test/mps.jl b/test/mps.jl
index 294cd8f826..832d40e3ac 100644
--- a/test/mps.jl
+++ b/test/mps.jl
@@ -206,6 +206,17 @@ include("util.jl")
       @test dim(l) == expected_dims[i]
     end
   end
+  
+  @testset "randomMPS with chi>1" for linkdims in [1, 4]
+    phi = randomMPS(Float32, sites; linkdims)
+    @test LinearAlgebra.promote_leaf_eltypes(phi) === Float32
+    @test all(x -> eltype(x) === Float32, phi)
+    @test maxlinkdim(phi) == linkdims
+    phic = randomMPS(ComplexF32, sites; linkdims)
+    @test LinearAlgebra.promote_leaf_eltypes(phic) === ComplexF32
+    @test maxlinkdim(phic) == linkdims
+    @test all(x -> eltype(x) === ComplexF32, phic)
+  end
 
   @testset "inner different MPS" begin
     phi = randomMPS(sites)
@@ -221,6 +232,19 @@ include("util.jl")
     @test_throws DimensionMismatch inner(phi, badpsi)
   end
 
+  @testset "loginner" begin
+    n = 4
+    c = 2
+
+    s = siteinds("S=1/2", n)
+    ψ = c .* randomMPS(s; linkdims=4)
+    @test exp(loginner(ψ, ψ)) ≈ c^(2n)
+    @test exp(loginner(ψ, -ψ)) ≈ -c^(2n)
+
+    α = randn(ComplexF64)
+    @test exp(loginner(ψ, α * ψ)) ≈ α * c^(2n)
+  end
+
   @testset "broadcasting" begin
     psi = randomMPS(sites)
     orthogonalize!(psi, 1)
@@ -338,6 +362,17 @@ include("util.jl")
     @test norm(psi) ≈ 1
     @test inner(phi, psi) ≈ 1
 
+    # Zero norm
+    @test norm(0phi) == 0
+    @test lognorm(0phi) == -Inf
+
+    zero_phi = 0phi
+    lognorm_zero_phi = []
+    normalize!(zero_phi; (lognorm!)=lognorm_zero_phi)
+    @test lognorm_zero_phi[1] == -Inf
+    @test norm(zero_phi) == 0
+    @test norm(normalize(0phi)) == 0
+
     # Large number of sites
     psi = randomMPS(siteinds("S=1/2", 1_000); linkdims=10)
 
@@ -443,6 +478,23 @@ include("util.jl")
     K12 = Ks[1] + Ks[2]
     K123 = K12 + Ks[3]
     @test inner(sum(Ks), K123) ≈ inner(K123, K123)
+
+    χ1 = 2
+    χ2 = 3
+    ψ1 = randomMPS(sites; linkdims=χ1)
+    ψ2 = 0.0 * randomMPS(sites; linkdims=χ2)
+
+    ϕ1 = +(ψ1, ψ2; alg="densitymatrix", cutoff=nothing)
+    for j in 2:7
+      @test linkdim(ϕ1, j) == χ1 + χ2
+    end
+    @test inner(ϕ1, ψ1) + inner(ϕ1, ψ2) ≈ inner(ϕ1, ϕ1)
+
+    ϕ2 = +(ψ1, ψ2; alg="directsum")
+    for j in 1:8
+      @test linkdim(ϕ2, j) == χ1 + χ2
+    end
+    @test inner(ϕ2, ψ1) + inner(ϕ2, ψ2) ≈ inner(ϕ2, ϕ2)
   end
 
   @testset "+ MPS with coefficients" begin
@@ -464,6 +516,8 @@ include("util.jl")
 
     ψ = +(ψ₁, ψ₂; cutoff=0.0)
 
+    @test_throws ErrorException ψ₁ + ψ₂'
+
     @test inner(ψ, ψ) ≈ inner_add(ψ₁, ψ₂)
     @test maxlinkdim(ψ) ≤ maxlinkdim(ψ₁) + maxlinkdim(ψ₂)
 
@@ -583,12 +637,14 @@ function test_correlation_matrix(psi::MPS, ops::Vector{Tuple{String,String}}; kw
   for op in ops
     Cpm = correlation_matrix(psi, op[1], op[2]; kwargs...)
     # Check using OpSum:
+    Copsum = 0.0 * Cpm
     for i in 1:N, j in 1:N
       a = OpSum()
       a += op[1], i, op[2], j
-      X = MPO(a, s)
-      @test inner(psi, MPO(a, s), psi) ≈ Cpm[i, j] atol = 5e-15
+      Copsum[i, j] = inner(psi', MPO(a, s), psi)
     end
+    @test Cpm ≈ Copsum rtol = 1E-11
+
     PM = expect(psi, op[1] * " * " * op[2])
     @test norm(PM - diag(Cpm)) < 1E-8
   end
@@ -788,6 +844,12 @@ end
     psi = randomMPS(s, n -> isodd(n) ? "Up" : "Dn"; linkdims=m)
     test_correlation_matrix(psi, [("S-", "S+"), ("S+", "S-")])
 
+    @test correlation_matrix(psi, [1/2 0; 0 -1/2], [1/2 0; 0 -1/2]) ≈
+      correlation_matrix(psi, "Sz", "Sz")
+    @test expect(psi, [1/2 0; 0 -1/2]) ≈ expect(psi, "Sz")
+    @test all(expect(psi, [1/2 0; 0 -1/2], [1/2 0; 0 -1/2]) .≈ expect(psi, "Sz", "Sz"))
+    @test expect(psi, [[1/2 0; 0 -1/2], [1/2 0; 0 -1/2]]) ≈ expect(psi, ["Sz", "Sz"])
+
     s = siteinds("S=1/2", length(s); conserve_qns=false)
     psi = randomMPS(s, n -> isodd(n) ? "Up" : "Dn"; linkdims=m)
     test_correlation_matrix(
@@ -813,13 +875,13 @@ end
     # need to be calculated explicitely.
     #test_correlation_matrix(psi,[("Sz", "Sx")];ishermitian=true)
 
-    #Test site_range feature
+    #Test sites feature
     s = siteinds("S=1/2", 8; conserve_qns=false)
     psi = randomMPS(s, n -> isodd(n) ? "Up" : "Dn"; linkdims=m)
     PM = expect(psi, "S+ * S-")
     Cpm = correlation_matrix(psi, "S+", "S-")
     range = 3:7
-    Cpm37 = correlation_matrix(psi, "S+", "S-"; site_range=range)
+    Cpm37 = correlation_matrix(psi, "S+", "S-"; sites=range)
     @test norm(Cpm37 - Cpm[range, range]) < 1E-8
 
     @test norm(PM[range] - expect(psi, "S+ * S-"; sites=range)) < 1E-8
@@ -829,14 +891,14 @@ end
     psi = randomMPS(ComplexF64, s; linkdims=m)
     ss, es = 3, 6
     Nb = es - ss + 1
-    Cpm = correlation_matrix(psi, "S+", "S-"; site_range=ss:es)
-    Czz = correlation_matrix(psi, "Sz", "Sz"; site_range=ss:es)
+    Cpm = correlation_matrix(psi, "S+", "S-"; sites=ss:es)
+    Czz = correlation_matrix(psi, "Sz", "Sz"; sites=ss:es)
     @test size(Cpm) == (Nb, Nb)
     # Check using OpSum:
     for i in ss:es, j in i:es
       a = OpSum()
       a += "S+", i, "S-", j
-      @test inner(psi, MPO(a, s), psi) ≈ Cpm[i - ss + 1, j - ss + 1]
+      @test inner(psi', MPO(a, s), psi) ≈ Cpm[i - ss + 1, j - ss + 1]
     end
 
     # Electron case
@@ -884,6 +946,20 @@ end
     s = siteinds("Fermion", 8; conserve_qns=false)
     psi = randomMPS(s; linkdims=m)
     test_correlation_matrix(psi, [("N", "N"), ("Cdag", "C"), ("C", "Cdag"), ("C", "C")])
+
+    #
+    # Test non-contiguous sites input
+    #
+    C = correlation_matrix(psi, "N", "N")
+    non_contiguous = [1, 3, 8]
+    Cs = correlation_matrix(psi, "N", "N"; sites=non_contiguous)
+    for (ni, i) in enumerate(non_contiguous), (nj, j) in enumerate(non_contiguous)
+      @test Cs[ni, nj] ≈ C[i, j]
+    end
+
+    C2 = correlation_matrix(psi, "N", "N"; sites=2)
+    @test C2 isa Matrix
+    @test C2[1, 1] ≈ C[2, 2]
   end #testset
 
   @testset "expect regression test for in-place modification of input MPS" begin
@@ -1825,16 +1901,20 @@ end
     N = 4
     s = siteinds("S=1/2", N)
     ψ = MPS([itensor(randn(ComplexF64, 2), s[n]) for n in 1:N])
-    ρ = outer(ψ, ψ)
+    ρ = outer(ψ', ψ)
     @test !ITensors.hasnolinkinds(ρ)
     @test inner(ρ, ρ) ≈ inner(ψ, ψ)^2
-    @test inner(ψ, ρ, ψ) ≈ inner(ψ, ψ)^2
+    @test inner(ψ', ρ, ψ) ≈ inner(ψ, ψ)^2
 
     # Deprecated syntax
+    @test_deprecated outer(ψ, ψ)
+    @test_deprecated inner(ψ, ψ')
+    @test_deprecated inner(ψ, ρ, ψ)
+
     ρ = @test_deprecated MPO(ψ)
     @test !ITensors.hasnolinkinds(ρ)
     @test inner(ρ, ρ) ≈ inner(ψ, ψ)^2
-    @test inner(ψ, ρ, ψ) ≈ inner(ψ, ψ)^2
+    @test inner(ψ', ρ, ψ) ≈ inner(ψ, ψ)^2
   end
 
   @testset "Truncate MPO with no link indices" begin
diff --git a/test/opsum_hash_bug.jld2 b/test/opsum_hash_bug.jld2
new file mode 100644
index 0000000000..ac16f6ccb2
Binary files /dev/null and b/test/opsum_hash_bug.jld2 differ
diff --git a/test/phys_site_types.jl b/test/phys_site_types.jl
index 432b7b2381..80605c2ae2 100644
--- a/test/phys_site_types.jl
+++ b/test/phys_site_types.jl
@@ -435,6 +435,7 @@ using ITensors, Test
     s = siteinds(st, 4; dim=3, conserve_qns=true)
     @test all(hasqns, s)
     @test op(s, "Id", 2) == itensor([1 0 0; 0 1 0; 0 0 1], s[2]', dag(s[2]))
+    @test op(s, "I", 2) == itensor([1 0 0; 0 1 0; 0 0 1], s[2]', dag(s[2]))
     @test op(s, "N", 2) == itensor([0 0 0; 0 1 0; 0 0 2], s[2]', dag(s[2]))
     @test op(s, "n", 2) == itensor([0 0 0; 0 1 0; 0 0 2], s[2]', dag(s[2]))
     @test op(s, "Adag", 2) ≈ itensor([0 0 0; 1 0 0; 0 √2 0], s[2]', dag(s[2]))
diff --git a/test/qnitensor.jl b/test/qnitensor.jl
index a76732d73d..0cca94acab 100644
--- a/test/qnitensor.jl
+++ b/test/qnitensor.jl
@@ -1779,6 +1779,72 @@ Random.seed!(1234)
     # increase the number of blocks of A's storage
     @test length(ITensors.blockoffsets(ITensors.tensor(A))) == 1
   end
+
+  @testset "removeqns and removeqn" begin
+    s = siteind("Electron"; conserve_qns=true)
+    T = op("c†↑", s)
+
+    @test hasqns(s)
+    @test hasqns(T)
+    @test qn(s, 1) == QN(("Nf", 0, -1), ("Sz", 0))
+    @test qn(s, 2) == QN(("Nf", 1, -1), ("Sz", 1))
+    @test qn(s, 3) == QN(("Nf", 1, -1), ("Sz", -1))
+    @test qn(s, 4) == QN(("Nf", 2, -1), ("Sz", 0))
+    @test blockdim(s, 1) == 1
+    @test blockdim(s, 2) == 1
+    @test blockdim(s, 3) == 1
+    @test blockdim(s, 4) == 1
+    @test nblocks(s) == 4
+    @test dim(s) == 4
+
+    s1 = removeqns(s)
+    T1 = removeqns(T)
+    @test !hasqns(s1)
+    @test !hasqns(T1)
+    @test nblocks(s1) == 1
+    @test dim(s1) == 4
+    for I in eachindex(T1)
+      @test T1[I] == T[I]
+    end
+
+    s2 = removeqn(s, "Sz")
+    T2 = removeqn(T, "Sz")
+    @test hasqns(s2)
+    @test hasqns(T2)
+    @test nnzblocks(T2) == 2
+    @test nblocks(s2) == 3
+    @test nblocks(T2) == (3, 3)
+    @test qn(s2, 1) == QN(("Nf", 0, -1))
+    @test qn(s2, 2) == QN(("Nf", 1, -1))
+    @test qn(s2, 3) == QN(("Nf", 2, -1))
+    @test blockdim(s2, 1) == 1
+    @test blockdim(s2, 2) == 2
+    @test blockdim(s2, 3) == 1
+    @test dim(s2) == 4
+    for I in eachindex(T2)
+      @test T2[I] == T[I]
+    end
+
+    s3 = removeqn(s, "Nf")
+    T3 = removeqn(T, "Nf")
+    @test hasqns(s3)
+    @test hasqns(T3)
+    @test nnzblocks(T3) == 2
+    @test nblocks(s3) == 4
+    @test nblocks(T3) == (4, 4)
+    @test qn(s3, 1) == QN(("Sz", 0))
+    @test qn(s3, 2) == QN(("Sz", 1))
+    @test qn(s3, 3) == QN(("Sz", -1))
+    @test qn(s3, 4) == QN(("Sz", 0))
+    @test blockdim(s3, 1) == 1
+    @test blockdim(s3, 2) == 1
+    @test blockdim(s3, 3) == 1
+    @test blockdim(s3, 4) == 1
+    @test dim(s3) == 4
+    for I in eachindex(T3)
+      @test T3[I] == T[I]
+    end
+  end
 end
 
 nothing
diff --git a/test/qnmpo.jl b/test/qnmpo.jl
index 2798c5303f..5622bcd673 100644
--- a/test/qnmpo.jl
+++ b/test/qnmpo.jl
@@ -1,5 +1,15 @@
 using ITensors, Test
 
+function op_mpo(sites, which_op, j)
+  left_ops = "Id"
+  right_ops = "Id"
+  if has_fermion_string(which_op, sites[j])
+    left_ops = "F"
+  end
+  ops = [n < j ? left_ops : (n > j ? right_ops : which_op) for n in 1:length(sites)]
+  return MPO([op(ops[n], sites[n]) for n in 1:length(sites)])
+end
+
 @testset "MPO Basics" begin
   N = 6
   sites = [Index(QN(-1) => 1, QN(1) => 1; tags="Site,n=$n") for n in 1:N]
@@ -61,10 +71,10 @@ using ITensors, Test
   @testset "orthogonalize!" begin
     orthogonalize!(phi, 1)
     orthogonalize!(K, 1)
-    orig_inner = ⋅(phi, K, phi)
+    orig_inner = ⋅(phi', K, phi)
     orthogonalize!(phi, div(N, 2))
     orthogonalize!(K, div(N, 2))
-    @test ⋅(phi, K, phi) ≈ orig_inner
+    @test ⋅(phi', K, phi) ≈ orig_inner
   end
 
   @testset "inner <y|A|x>" begin
@@ -75,7 +85,7 @@ using ITensors, Test
     for j in 2:N
       phiKpsi *= phidag[j] * K[j] * psi[j]
     end
-    @test phiKpsi[] ≈ inner(phi, K, psi)
+    @test phiKpsi[] ≈ inner(phi', K, psi)
   end
 
   @testset "inner <By|A|x>" begin
@@ -103,7 +113,7 @@ using ITensors, Test
 
   @testset "error_contract" begin
     dist = sqrt(
-      abs(1 + (inner(phi, phi) - 2 * real(inner(phi, K, psi))) / inner(K, psi, K, psi))
+      abs(1 + (inner(phi, phi) - 2 * real(inner(phi', K, psi))) / inner(K, psi, K, psi))
     )
     @test dist ≈ error_contract(phi, K, psi)
   end
@@ -111,8 +121,8 @@ using ITensors, Test
   @testset "contract" begin
     @test maxlinkdim(K) == 1
     psi_out = contract(K, psi; maxdim=1)
-    @test inner(phi, psi_out) ≈ inner(phi, K, psi)
-    @test_throws ArgumentError contract(K, psi; method="fakemethod")
+    @test inner(phi', psi_out) ≈ inner(phi', K, psi)
+    @test_throws MethodError contract(K, psi; method="fakemethod")
   end
 
   # TODO: implement add for QN MPOs and add this test back
@@ -122,8 +132,8 @@ using ITensors, Test
   #  @test length(M) == N
   #  k_psi = contract(K, psi, maxdim=1)
   #  l_psi = contract(L, psi, maxdim=1)
-  #  @test inner(psi, k_psi + l_psi) ≈ ⋅(psi, M, psi) atol=5e-3
-  #  @test inner(psi, sum([k_psi, l_psi])) ≈ dot(psi, M, psi) atol=5e-3
+  #  @test inner(psi', k_psi + l_psi) ≈ ⋅(psi', M, psi) atol=5e-3
+  #  @test inner(psi', sum([k_psi, l_psi])) ≈ dot(psi', M, psi) atol=5e-3
   #  for dim in 2:4
   #    shsites = siteinds("S=1/2",N)
   #    K = basicRandomMPO(N, shsites; dim=dim)
@@ -149,7 +159,23 @@ using ITensors, Test
     KL = contract(prime(K), L; maxdim=1)
     Lpsi = contract(L, psi; maxdim=1)
     psi_kl_out = contract(prime(K), Lpsi; maxdim=1)
-    @test inner(psi, KL, psi) ≈ inner(psi, psi_kl_out) atol = 5e-3
+    @test inner(psi'', KL, psi) ≈ inner(psi'', psi_kl_out) atol = 5e-3
+  end
+
+  @testset "contract(::MPO, ::MPO) without truncation" begin
+    s = siteinds("Electron", 10; conserve_qns=true)
+    j1, j2 = 2, 4
+    Cdagup = op_mpo(s, "Cdagup", j1)
+    Cdagdn = op_mpo(s, "Cdagdn", j2)
+    Cdagmpo = apply(Cdagup, Cdagdn; alg="naive", truncate=false)
+    @test norm(Cdagmpo) ≈ 2^length(s) / 2
+    for j in 1:length(s)
+      if (j == j1) || (j == j2)
+        @test norm(Cdagmpo[j]) ≈ √2
+      else
+        @test norm(Cdagmpo[j]) ≈ 2
+      end
+    end
   end
 
   @testset "*(::MPO, ::MPO)" begin
@@ -157,7 +183,7 @@ using ITensors, Test
     @test maxlinkdim(L) == 1
     KL = *(prime(K), L; maxdim=1)
     psi_kl_out = *(prime(K), *(L, psi; maxdim=1); maxdim=1)
-    @test ⋅(psi, KL, psi) ≈ dot(psi, psi_kl_out) atol = 5e-3
+    @test ⋅(psi'', KL, psi) ≈ dot(psi'', psi_kl_out) atol = 5e-3
   end
 
   sites = siteinds("S=1/2", N)
@@ -185,15 +211,15 @@ end
 
   @test prod(H) ≈ prod(H̃)
 
-  @test nnz(H[1]) == 13
-  @test nnz(H[2]) == 51
-  @test nnz(H[3]) == 51
-  @test nnz(H[4]) == 13
+  @test nnz(H[1]) == 9
+  @test nnz(H[2]) == 18
+  @test nnz(H[3]) == 18
+  @test nnz(H[4]) == 9
 
-  @test nnzblocks(H[1]) == 7
-  @test nnzblocks(H[2]) == 11
-  @test nnzblocks(H[3]) == 11
-  @test nnzblocks(H[4]) == 7
+  @test nnzblocks(H[1]) == 9
+  @test nnzblocks(H[2]) == 18
+  @test nnzblocks(H[3]) == 18
+  @test nnzblocks(H[4]) == 9
 
   @test nnz(H̃[1]) == nnzblocks(H̃[1]) == count(≠(0), H[1]) == count(≠(0), H̃[1]) == 9
   @test nnz(H̃[2]) == nnzblocks(H̃[2]) == count(≠(0), H[2]) == count(≠(0), H̃[2]) == 18
diff --git a/test/runtests.jl b/test/runtests.jl
index 54285bc792..3c6b6d4f20 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -37,6 +37,7 @@ if Threads.nthreads() == 1
       "lattices.jl",
       "mps.jl",
       "mpo.jl",
+      "algorithm.jl",
       "sweeps.jl",
       "sweepnext.jl",
       "autompo.jl",
diff --git a/test/sitetype.jl b/test/sitetype.jl
index a2437649da..cd5e82c762 100644
--- a/test/sitetype.jl
+++ b/test/sitetype.jl
@@ -1,5 +1,10 @@
 using ITensors, Test
 
+function is_unitary(U::ITensor; kwargs...)
+  s = noprime(filterinds(U; plev=1))
+  return isapprox(transpose(dag(U))(U), op("I", s...))
+end
+
 @testset "SiteType" begin
   N = 10
 
@@ -14,6 +19,15 @@ using ITensors, Test
     SySy = op(sites, "Sy * Sy", 2)
     @test SySy ≈ product(Sy, Sy)
 
+    Sz1 = op("Sz", sites, 1)
+    @test op("Sz", [sites[1]]) ≈ Sz1
+    @test op([sites[1]], "Sz") ≈ Sz1
+    @test op([1 0; 0 -1] / 2, [sites[1]]) ≈ Sz1
+    @test op([sites[1]], [1 0; 0 -1] / 2) ≈ Sz1
+
+    @test op([sites[1]], "Ry"; θ=π / 2) ≈
+      itensor([1 -1; 1 1] / √2, sites[1]', dag(sites[1]))
+
     sites = siteinds("S=1", N)
     #@test_throws ArgumentError op(sites, "Sp", 1)
     Sz = op(sites, "Sz", 2)
@@ -35,7 +49,7 @@ using ITensors, Test
     @test x ≈ array(op("a - a†", q))
     x = Amat * Adagmat - Adagmat
     @test x ≈ array(op("a * a† - a†", q))
-    @test x ≈ array(op("a*a† - a†", q))
+    @test x ≈ array(op("a * a† - a†", q))
     x = Adagmat * Adagmat * Amat * Amat
     @test x ≈ array(op("a† * a† * a * a", q))
 
@@ -53,10 +67,11 @@ using ITensors, Test
     @test x ≈ array(op("S+ - S- - S+", q))
     x = Sp * Sm + Sm * Sp
     @test x ≈ array(op("S+ * S- + S- * S+", q))
-    @test x ≈ array(op("S+*S- + S-*S+", q))
+    # Deprecated syntax
+    @test x ≈ array(op("S+ * S- + S-*S+", q))
     x = Sp * Sm - Sm * Sp
     @test x ≈ array(op("S+ * S- - S- * S+", q))
-    @test x ≈ array(op("S+* S- - S- * S+", q))
+    @test x ≈ array(op("S+ * S- - S- * S+", q))
     x = Sp * Sm + Sm * Sp + Sz * Sx * Sy
     @test x ≈ array(op("S+ * S- + S- * S+ + Sz * Sx * Sy", q))
     x = Sp * Sm - Sm * Sp + Sz * Sx * Sy
@@ -121,7 +136,7 @@ using ITensors, Test
     @test α[s' => 4, t' => 1, s => 4, t => 2] ≈ -3 / 2
 
     s1 = Index(4, "_Custom1, __x")
-    @test_throws ErrorException op("α", s, s1)
+    @test_throws ArgumentError op("α", s, s1)
 
     s2 = Index(4, "_Custom2, __x")
     β = op("β", s1, s2)
@@ -129,7 +144,7 @@ using ITensors, Test
     @test β[s1' => 2, s2' => 1, s1 => 2, s2 => 2] ≈ +3 / 2
     @test β[s1' => 3, s2' => 3, s1 => 3, s2 => 4] ≈ -3 / 2
     @test β[s1' => 4, s2' => 1, s1 => 4, s2 => 2] ≈ -5 / 2
-    @test_throws ErrorException op("β", s2, s1)
+    @test_throws ArgumentError op("β", s2, s1)
   end
 
   @testset "Custom OpName with long name" begin
@@ -213,7 +228,7 @@ using ITensors, Test
     @test α[s' => 4, t' => 1, s => 4, t => 2] ≈ -3 / 2
 
     s1 = Index(4, "_Custom1, __x")
-    @test_throws ErrorException op("α", t, s1)
+    @test_throws ArgumentError op("α", t, s1)
 
     s2 = Index(4, "_Custom2, __x")
     β = op("β", s1, s2)
@@ -221,7 +236,7 @@ using ITensors, Test
     @test β[s1' => 2, s2' => 1, s1 => 2, s2 => 2] ≈ +3 / 2
     @test β[s1' => 3, s2' => 3, s1 => 3, s2 => 4] ≈ -3 / 2
     @test β[s1' => 4, s2' => 1, s1 => 4, s2 => 2] ≈ -5 / 2
-    @test_throws ErrorException op("β", s2, s1)
+    @test_throws ArgumentError op("β", s2, s1)
   end
 
   @testset "Custom SiteType using older op interface" begin
@@ -454,6 +469,46 @@ using ITensors, Test
     s = siteind("Xev")
     @test state(s, "0") ≈ ITensor([1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], s)
   end
+
+  @testset "function applied to a gate" begin
+    s = siteinds("Qubit", 2)
+
+    θ = 0.1
+    rx = array(op("Rx", s[1]; θ=0.1))
+    exp_rx = exp(rx)
+    gtest = op(x -> exp(x), "Rx", s[1]; θ=0.1)
+    @test exp_rx ≈ array(op(x -> exp(x), "Rx", s[1]; θ=0.1))
+    @test exp_rx ≈ array(op(x -> exp(x), ("Rx", 1, (θ=0.1,)), s))
+
+    cx = 0.1 * reshape(array(op("CX", s[1], s[2])), (4, 4))
+    exp_cx = reshape(exp(cx), (2, 2, 2, 2))
+    @test exp_cx ≈ array(op(x -> exp(0.1 * x), "CX", s[1], s[2]))
+    @test exp_cx ≈ array(op(x -> exp(0.1 * x), ("CX", (1, 2)), s))
+  end
+
+  @testset "Haar-random unitary RandomUnitary" begin
+    s = siteinds(2, 3)
+
+    U = op("RandomUnitary", s, 1, 2)
+    @test eltype(U) == ComplexF64
+    @test order(U) == 4
+    @test is_unitary(U; rtol=1e-15)
+
+    U = op("RandomUnitary", s, 1, 2, 3)
+    @test eltype(U) == ComplexF64
+    @test order(U) == 6
+    @test is_unitary(U; rtol=1e-15)
+
+    U = op("RandomUnitary", s, 1, 2; eltype=Float64)
+    @test eltype(U) == Float64
+    @test order(U) == 4
+    @test is_unitary(U; rtol=1e-15)
+
+    U = op("RandomUnitary", s, 1, 2, 3; eltype=Float64)
+    @test eltype(U) == Float64
+    @test order(U) == 6
+    @test is_unitary(U; rtol=1e-15)
+  end
 end
 
 nothing
diff --git a/test/svd.jl b/test/svd.jl
index 6f723cac04..3a6db913c9 100644
--- a/test/svd.jl
+++ b/test/svd.jl
@@ -72,24 +72,131 @@ include("util.jl")
     @test norm(U * S * V - T) / norm(T) < 1E-10
   end
 
-  # TODO: remove this test, it takes a long time
-  @testset "Ill-conditioned matrix" begin
-    d = 5000
-    i = Index(d, "i")
-    T = itensor(make_illconditioned_matrix(dim(i)), i', i)
-
-    @suppress begin
-      F = svd(T, i'; alg="divide_and_conquer")
-    end
-    # Depending on the LAPACK implementation,
-    # this sometimes works so don't test it
-    #@test isnothing(F)
-
-    # XXX: This fails on Windows, removing for now.
-    # F = svd(T, i'; alg="qr_iteration")
-    # @test !isnothing(F)
-    # @test F.U * F.S * F.V ≈ T
+  @testset "svd with empty left or right indices" for space in
+                                                      (2, [QN(0, 2) => 1, QN(1, 2) => 1]),
+    cutoff in (nothing, 1e-15)
+
+    i = Index(space)
+    j = Index(space)
+    A = randomITensor(i, j)
+
+    U, S, V = svd(A, i, j; cutoff)
+    @test U * S * V ≈ A
+    @test hassameinds(uniqueinds(U, S), A)
+    @test isempty(uniqueinds(V, S))
+    @test dim(U) == dim(A)
+    @test dim(S) == 1
+    @test dim(V) == 1
+    @test order(U) == order(A) + 1
+    @test order(S) == 2
+    @test order(V) == 1
+
+    U, S, V = svd(A, (); cutoff)
+    @test U * S * V ≈ A
+    @test hassameinds(uniqueinds(V, S), A)
+    @test isempty(uniqueinds(U, S))
+    @test dim(U) == 1
+    @test dim(S) == 1
+    @test dim(V) == dim(A)
+    @test order(U) == 1
+    @test order(S) == 2
+    @test order(V) == order(A) + 1
+
+    @test_throws ErrorException svd(A)
+  end
+
+  @testset "factorize with empty left or right indices" for space in (
+      2, [QN(0, 2) => 1, QN(1, 2) => 1]
+    ),
+    cutoff in (nothing, 1e-15)
+
+    i = Index(space)
+    j = Index(space)
+    A = randomITensor(i, j)
+
+    X, Y = factorize(A, i, j; cutoff)
+    @test X * Y ≈ A
+    @test hassameinds(uniqueinds(X, Y), A)
+    @test isempty(uniqueinds(Y, X))
+    @test dim(X) == dim(A)
+    @test dim(Y) == 1
+    @test order(X) == order(A) + 1
+    @test order(Y) == 1
+
+    X, Y = factorize(A, (); cutoff)
+    @test X * Y ≈ A
+    @test hassameinds(uniqueinds(Y, X), A)
+    @test isempty(uniqueinds(X, Y))
+    @test dim(X) == 1
+    @test dim(Y) == dim(A)
+    @test order(X) == 1
+    @test order(Y) == order(A) + 1
+
+    @test_throws ErrorException factorize(A)
+  end
+
+  @testset "svd with empty left and right indices" for cutoff in (nothing, 1e-15)
+    A = ITensor(3.4)
+
+    U, S, V = svd(A, (); cutoff)
+    @test U * S * V ≈ A
+    @test isempty(uniqueinds(U, S))
+    @test isempty(uniqueinds(V, S))
+    @test dim(U) == 1
+    @test dim(S) == 1
+    @test dim(V) == 1
+    @test order(U) == 1
+    @test order(S) == 2
+    @test order(V) == 1
+
+    @test_throws ErrorException svd(A)
+  end
+
+  @testset "factorize with empty left and right indices" for cutoff in (nothing, 1e-15)
+    A = ITensor(3.4)
+
+    X, Y = factorize(A, (); cutoff)
+    @test X * Y ≈ A
+    @test isempty(uniqueinds(X, Y))
+    @test isempty(uniqueinds(Y, X))
+    @test dim(X) == 1
+    @test dim(Y) == 1
+    @test order(X) == 1
+    @test order(Y) == 1
+
+    @test_throws ErrorException factorize(A)
   end
+
+  @testset "svd with single precision element type" for eltype in (Float32, ComplexF32),
+    space in (2, [QN(0) => 1, QN(1) => 1])
+
+    i = Index(space)
+    A = randomITensor(eltype, i', dag(i))
+    @test Base.eltype(A) === eltype
+    U, S, V = svd(A, i'; maxdim=1)
+    @test Base.eltype(U) === eltype
+    @test Base.eltype(S) === real(eltype)
+    @test Base.eltype(V) === eltype
+  end
+
+  # TODO: remove this test, it takes a long time
+  ## @testset "Ill-conditioned matrix" begin
+  ##   d = 5000
+  ##   i = Index(d, "i")
+  ##   T = itensor(make_illconditioned_matrix(dim(i)), i', i)
+
+  ##   @suppress begin
+  ##     F = svd(T, i'; alg="divide_and_conquer")
+  ##   end
+  ##   # Depending on the LAPACK implementation,
+  ##   # this sometimes works so don't test it
+  ##   #@test isnothing(F)
+
+  ##   # XXX: This fails on Windows, removing for now.
+  ##   # F = svd(T, i'; alg="qr_iteration")
+  ##   # @test !isnothing(F)
+  ##   # @test F.U * F.S * F.V ≈ T
+  ## end
 end
 
 nothing
diff --git a/test/tagset.jl b/test/tagset.jl
index 624239edd3..9e3f12f2cf 100644
--- a/test/tagset.jl
+++ b/test/tagset.jl
@@ -66,10 +66,17 @@ using ITensors, Test
     @test ts[4] == ITensors.SmallString("αβγδϵζηθ")
   end
 
+  @testset "Tag long" begin
+    ts = TagSet("abcdefghijklmnop,ijklmnopqabcdefg")
+    @test length(ts) == 2
+    @test hastags(ts, "abcdefghijklmnop")
+    @test hastags(ts, "ijklmnopqabcdefg")
+  end
+
   @testset "Tag too long" begin
-    @test_throws ErrorException TagSet("ijklmnopq")
-    @test_throws ErrorException TagSet("abcd,ijklmnopq")
-    @test_throws ErrorException TagSet("ijklmnopqr,abcd")
+    @test_throws ErrorException TagSet("ijklmnopqabcdefgh")
+    @test_throws ErrorException TagSet("abcd,ijklmnopqabcdefgh")
+    @test_throws ErrorException TagSet("ijklmnopqabcdefgh,abcd")
   end
 
   @testset "Integer Tags" begin
diff --git a/test/trans_ising_complex.jl b/test/trans_ising_complex.jl
new file mode 100644
index 0000000000..f76022d8df
--- /dev/null
+++ b/test/trans_ising_complex.jl
@@ -0,0 +1,68 @@
+using ITensors
+
+function Hamiltonian(sites, λ::Float64, k::Float64)
+  N = length(sites)
+  ampo = AutoMPO()
+
+  for j in 1:(N - 1)
+    ampo += -0.5 * 2 * λ, "Sz", j, "Sz", j + 1
+  end
+  for j in 1:N
+    ampo += -0.5 * 2 * im * k, "Sz", j
+    ampo += -0.5, "S+", j
+    ampo += -0.5, "S-", j
+  end
+  #  Convert these terms to an MPO tensor network
+  return MPO(ampo, sites)
+end
+
+let
+  #-----------------------------------------------------------------------
+
+  #models parameters
+  N = 4
+  λ = 0.1
+  k = 0.5
+
+  alg = "qr_iteration"
+
+  #dmrg parameters
+  sweeps = Sweeps(1000)
+  minsweeps = 5
+  maxdim!(sweeps, 50, 100, 200)
+  #cutoff!(sweeps, 1E-12)
+  etol = 1E-12
+
+  #-----------------------------------------------------------------------
+
+  sites = siteinds("S=1/2", N; conserve_qns=false)
+  #-----------------------------------------------------------------------
+
+  #inicial state
+  state = ["Emp" for n in 1:N]
+  p = N
+  for i in N:-1:1
+    if p > i
+      state[i] = "UpDn"
+      p -= 2
+    elseif p > 0
+      state[i] = (isodd(i) ? "Up" : "Dn")
+      p -= 1
+    end
+  end
+  psi0 = randomMPS(sites, state)
+  @show flux(psi0)
+  #-----------------------------------------------------------------------
+
+  #-----------------------------------------------------------------------
+
+  H = Hamiltonian(sites, λ, k)
+  #-----------------------------------------------------------------------
+
+  obs = DMRGObserver(; energy_tol=etol, minsweeps=2, complex_energies=true)
+
+  energy, psi = dmrg(
+    H, psi0, sweeps; svd_alg=alg, observer=obs, outputlevel=1, ishermitian=false
+  )
+  println("Final energy = $energy")
+end