diff --git a/.travis.yml b/.travis.yml
index 9890ddcb..8f40d6fa 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,6 +2,8 @@ sudo: false
 language: node_js
 node_js: 5.1
 install: npm install
+branches:
+  only: master
 before_script:
   - export DISPLAY=:99.0
   - sh -e /etc/init.d/xvfb start
diff --git a/doc/MANUAL_amp-display.png b/doc/MANUAL_amp-display.png
new file mode 100644
index 00000000..05bf8097
Binary files /dev/null and b/doc/MANUAL_amp-display.png differ
diff --git a/doc/MANUAL_bloch-display.png b/doc/MANUAL_bloch-display.png
new file mode 100644
index 00000000..4939f91a
Binary files /dev/null and b/doc/MANUAL_bloch-display.png differ
diff --git a/doc/MANUAL_chance-display.png b/doc/MANUAL_chance-display.png
new file mode 100644
index 00000000..3b960767
Binary files /dev/null and b/doc/MANUAL_chance-display.png differ
diff --git a/doc/MANUAL_circuit-editing-area.png b/doc/MANUAL_circuit-editing-area.png
new file mode 100644
index 00000000..266a8605
Binary files /dev/null and b/doc/MANUAL_circuit-editing-area.png differ
diff --git a/doc/MANUAL_controlled-display.png b/doc/MANUAL_controlled-display.png
new file mode 100644
index 00000000..83c73a25
Binary files /dev/null and b/doc/MANUAL_controlled-display.png differ
diff --git a/doc/MANUAL_controlled-epr-display.png b/doc/MANUAL_controlled-epr-display.png
new file mode 100644
index 00000000..2447e36f
Binary files /dev/null and b/doc/MANUAL_controlled-epr-display.png differ
diff --git a/doc/MANUAL_density-display.png b/doc/MANUAL_density-display.png
new file mode 100644
index 00000000..ad44bfd6
Binary files /dev/null and b/doc/MANUAL_density-display.png differ
diff --git a/doc/MANUAL_measurement-types.png b/doc/MANUAL_measurement-types.png
new file mode 100644
index 00000000..e7430846
Binary files /dev/null and b/doc/MANUAL_measurement-types.png differ
diff --git a/doc/MANUAL_menu.png b/doc/MANUAL_menu.png
new file mode 100644
index 00000000..2a5e4976
Binary files /dev/null and b/doc/MANUAL_menu.png differ
diff --git a/doc/MANUAL_state-channel-duality.png b/doc/MANUAL_state-channel-duality.png
new file mode 100644
index 00000000..69df46de
Binary files /dev/null and b/doc/MANUAL_state-channel-duality.png differ
diff --git a/doc/MANUAL_various-displays.png b/doc/MANUAL_various-displays.png
new file mode 100644
index 00000000..7b3bc912
Binary files /dev/null and b/doc/MANUAL_various-displays.png differ
diff --git a/html/export.partial.html b/html/export.partial.html
index 1b42e0fd..af7d65a9 100644
--- a/html/export.partial.html
+++ b/html/export.partial.html
@@ -13,11 +13,21 @@
             <button tabindex="102" id="download-offline-copy-button" style="width:600px; height:60px;">Download ...</button>
         </div>
 
-        <strong>JSON</strong> - Parsable representation of current circuit.
+        <strong>Circuit JSON</strong> - Parsable representation of current circuit.
         <div style="margin: 10px 0 0 20px;">
             <button tabindex="103" id="export-json-copy-button">Copy to Clipboard</button>&nbsp;&nbsp;<span id="export-json-copy-result"></span>
             <br>
             <pre tabindex="104" id="export-circuit-json-pre" style="overflow:auto; max-width:600px; max-height:60px; border: 1px solid black; padding:5px; margin:2px;"></pre>
         </div>
+
+        <br>
+        <strong>Simulation Data JSON</strong> - Output amplitudes, detector results, display data, etc.
+        <div style="margin: 10px 0 0 20px;">
+            <button tabindex="105" id="export-amplitudes-button">Generate and Copy to Clipboard</button>&nbsp;<span id="export-amplitudes-result"></span>
+            <input type="checkbox" tabindex="106" id="export-amplitudes-use-amps" style="float: right; margin-right: 10px;">
+            <label style="float: right" for="export-amplitudes-use-amps">Skip output amplitudes</label>
+            <br>
+            <pre tabindex="107" id="export-amplitudes-pre" style="overflow:auto; max-width:600px; max-height:60px; border: 1px solid black; padding:5px; margin:2px;"></pre>
+        </div>
     </div>
 </div>
diff --git a/html/forge.partial.html b/html/forge.partial.html
index 329865fa..6db612c3 100644
--- a/html/forge.partial.html
+++ b/html/forge.partial.html
@@ -31,7 +31,7 @@
                 <td></td>
                 <td>
                     <style scoped>
-                        input[type="checkbox"]:not(:checked) + label {
+                        input[id="gate-forge-matrix-fix"]:not(:checked) + label {
                             font-weight: bold;
                             background-color: pink;
                         }
diff --git a/html/menu.partial.html b/html/menu.partial.html
index 0ebb87bc..970f5b14 100644
--- a/html/menu.partial.html
+++ b/html/menu.partial.html
@@ -1,5 +1,5 @@
 <div id="menu-div" style="display:block;">
-    <div id="menu-overlay" style="position:fixed; left: 0; top: 0; height: 100vh; width: 100vw; background: rgba(0, 0, 0, 0.7);">
+    <div id="menu-overlay" style="position:fixed; left: 0; top: 0; height: 100vh; width: 100vw; background: rgba(0, 0, 0, 0.8);">
     </div>
     <div style="position:absolute; top:20px; left:50px; margin:0;">
         <div style="display:inline-block; padding:20px; background-color:white; border:1px solid black; text-align:center;">
@@ -11,14 +11,26 @@
             A drag-and-drop quantum circuit simulator.
 
             <div style="margin:20px;">
-                <div id="loading-div" style="color:#D90; font-size:40px; display:block; height:120px; width:344px;">
+                <div id="loading-div" style="color:#D90; font-size:40px; display:block; height:120px; width:410px;">
                     Loading...
                 </div>
-                <button tabindex="50" id="close-menu-button" style="width:344px; height:120px; font-size:20px; display:none;">Edit Circuit</button>
+                <button tabindex="50" id="close-menu-button" style="width:410px; height:120px; font-size:20px; display:none;">Edit Circuit</button>
             </div>
 
-            <div style="display:inline-block; text-align:center; border:1px solid black; padding:4px; margin-right:64px;">
-                <a tabindex="51" href="https://www.youtube.com/watch?v=aloFwlBUwsQ">
+            <div style="display:inline-block; text-align:center; border:1px solid black; padding:2px;">
+                <a tabindex="51" href="https://github.com/Strilanc/Quirk/wiki/How-to-use-Quirk">
+                    <div style="width:128px;">
+                        <svg version="1.1" viewBox="0 0 20 25" width="48" height="48">
+                          <text x="5" y="9" style="font-size: 8px;">???</text>
+                          <path d="M0 0 h20 v25 h-20 v-25 M3 13 h14 M3 17 h14 M3 21 h14" stroke="black" fill="transparent"></path>
+                        </svg>
+                        <div>How to Use</div>
+                    </div>
+                </a>
+            </div>
+
+            <div style="display:inline-block; text-align:center; border:1px solid black; padding:2px;">
+                <a tabindex="52" href="https://www.youtube.com/watch?v=aloFwlBUwsQ">
                     <div style="width:128px;">
                         <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAACt0lEQVQoz+3SP09TYRQG8IOL4RsgSNvbv4C4uMAkLgbippEw6CKwqIuGwW/gZEI6kIiDo0MnEk1MmEBLRQFbCnJLa6WlFK6K2kKrBarH55p7TUWa1vgm8pqe5Jc0vbfneZ+8JWYmmUl9+FqBWoFagf+hwP5Jn/TUQw/cgmG4Dz54DH4IQQwSkIaMgf+Q+bu0sStm7PYbWT4je9g4i36meio3a+2eOrgBGeBDKmOcse63Aql29yiwJO79cvjVE+4+YMn0/SyQbHNPA0tm+sfhV9rcdmBJOehNq2sQWFKDFG91eYEl5aXXLS4fsKR8FPM4A8BCtLq3hO2qToCiHqcKLMJOKrW3NnTzZbTFlRO1swKVlt1ODViEr9ks65NPpQor/VeCyx5XQdTuMjSKuBw5YBHMAvoU9/Z4MxzejvdeDOJZUVTGPjlS8UGUYkkBc/JbW7weCGRi53rm8c43kXk6euV0sCgHFTBv46OmcXp8/F3kTNeCyExadDhYlHIFSm/jbTLJqbGx9aWOjoiITFpw2FmUSgXM2/iwscFaIsHRgf7I32ZS2G5nUaopoM+237+61Nm5JCKT5hU7i1LxLxQKaerprrDITAopCotSrsAXVX0f6e4OiswyUdCmsCj7C+wkk9no+QtzeFYUmVOK5qxKDlgEs8CupuWjly7P4LtdUbvLyNGsVdGARSisJArxq9dmZ232gqidFWg0Y7GpwEJYlbywXdVR6UWzbQpYUlP0vNnmA5aUj6aPW73AkvLSsybrALCkBijQZFWAJaWQPlONlgCwZAJkztNGSy+wZHqpdJ4cs4wAS2KEDprJBssgJIEPqU24DnVUbiYamo/AKeiH23AXHsAjmISQIQ4J0CBjyAJX4bPx/idjh27R2DsBD43MUbgDQ3AWjv52YGaWWq1ArUCtQK3Av/UdR/1BF+14cggAAAAASUVORK5CYII=">
                         <div>Tutorial Video</div>
@@ -26,8 +38,8 @@
                 </a>
             </div>
 
-            <div style="display:inline-block; text-align:center; border:1px solid black; padding:4px;">
-                <a tabindex="52" href="https://github.com/Strilanc/Quirk">
+            <div style="display:inline-block; text-align:center; border:1px solid black; padding:2px;">
+                <a tabindex="53" href="https://github.com/Strilanc/Quirk">
                     <div style="width:128px;">
                         <svg version="1.1" viewBox="0 0 16 16" width="48" height="48">
                             <path fill-rule="evenodd"
@@ -39,7 +51,7 @@
                 </a>
             </div>
         </div>
-        <div style="display:inline-block; vertical-align:top; line-height:1.8; padding:15px 15px 15px 5px; background-color:#DDD; border:1px solid gray; margin:10px 0 0 -5px;">
+        <div style="display:inline-block; vertical-align:top; line-height:1.8; padding:13px 15px 13px 5px; background-color:#DDD; border:1px solid gray; margin:0 0 0 -5px;">
             Example Circuits<br>
             <a id="example-anchor-grover">Grover Search</a><br>
             <a id="example-anchor-shor">Shor Period Finding</a><br>
@@ -50,6 +62,7 @@
             <a id="example-symmetry-break">Symmetry Breaking</a><br>
             <a id="example-qft">Quantum Fourier Transform</a><br>
             <a id="example-addition">Reversible Addition</a><br>
+            <a id="example-anchor-distill">Magic State Distillation</a><br>
         </div>
     </div>
 </div>
diff --git a/src/Config.js b/src/Config.js
index e6bccfb8..a5e518fb 100644
--- a/src/Config.js
+++ b/src/Config.js
@@ -92,4 +92,6 @@ Config.DEFAULT_STROKE_THICKNESS = 1;
 Config.CHECK_WEB_GL_ERRORS_EVEN_ON_HOT_PATHS = false;
 Config.SEMI_STABLE_RANDOM_VALUE_LIFETIME_MILLIS = 300;
 
+Config.IGNORED_WEBGL_INFO_TERMS = [];
+
 export {Config}
diff --git a/src/base/Equate.js b/src/base/Equate.js
index 32b874d1..438c5740 100644
--- a/src/base/Equate.js
+++ b/src/base/Equate.js
@@ -240,4 +240,4 @@ function equate_Objects(subject, other) {
     return true;
 }
 
-export {equate}
+export {equate, equate_Maps}
diff --git a/src/circuit/CircuitComputeUtil.js b/src/circuit/CircuitComputeUtil.js
index d56449cc..5ef3c8f5 100644
--- a/src/circuit/CircuitComputeUtil.js
+++ b/src/circuit/CircuitComputeUtil.js
@@ -14,6 +14,7 @@
 
 import {CircuitEvalContext} from "src/circuit/CircuitEvalContext.js"
 import {CircuitShaders} from "src/circuit/CircuitShaders.js"
+import {DetailedError} from "src/base/DetailedError.js"
 import {KetTextureUtil} from "src/circuit/KetTextureUtil.js"
 import {Controls} from "src/circuit/Controls.js"
 import {GateBuilder} from "src/circuit/Gate.js"
@@ -83,6 +84,8 @@ function advanceStateWithCircuit(ctx, circuitDefinition, collectStats) {
         }
     };
 
+    circuitDefinition.applyInitialStateOperations(ctx);
+
     // Apply each column in the circuit.
     for (let col = 0; col < circuitDefinition.columns.length; col++) {
         _advanceStateWithCircuitDefinitionColumn(
diff --git a/src/circuit/CircuitDefinition.js b/src/circuit/CircuitDefinition.js
index 463a5632..2b9201a3 100644
--- a/src/circuit/CircuitDefinition.js
+++ b/src/circuit/CircuitDefinition.js
@@ -17,10 +17,11 @@ import {Config} from "src/Config.js"
 import {Controls} from "src/circuit/Controls.js"
 import {CustomGateSet} from "src/circuit/CustomGateSet.js"
 import {DetailedError} from "src/base/DetailedError.js"
+import {equate_Maps} from "src/base/Equate.js";
 import {Gate} from "src/circuit/Gate.js"
 import {GateColumn} from "src/circuit/GateColumn.js"
 import {GateShaders} from "src/circuit/GateShaders.js"
-import {Gates} from "src/gates/AllGates.js"
+import {Gates, INITIAL_STATES_TO_GATES} from "src/gates/AllGates.js"
 import {Point} from "src/math/Point.js"
 import {seq, Seq} from "src/base/Seq.js"
 import {Util} from "src/base/Util.js"
@@ -39,13 +40,15 @@ class CircuitDefinition {
      * @param {undefined|!Map.<!string, *>=} outerContext
      * @param {!CustomGateSet} customGateSet
      * @param {!boolean} isNested
+     * @param {!Map.<!int, !string>} customInitialValues
      */
     constructor(numWires,
                 columns,
                 outerRowOffset=0,
                 outerContext=new Map(),
                 customGateSet=new CustomGateSet(),
-                isNested=false) {
+                isNested=false,
+                customInitialValues=new Map()) {
         if (numWires < 0) {
             throw new DetailedError("Bad numWires", {numWires})
         }
@@ -69,6 +72,17 @@ class CircuitDefinition {
         this.outerRowOffset = outerRowOffset;
         this.outerContext = outerContext;
         this.isNested = isNested;
+        /** @type {!Map.<!int, !string>} */
+        this.customInitialValues = new Map();
+        for (let [k, v] of customInitialValues.entries()) {
+            if (!Number.isInteger(k) || k < 0) {
+                throw new DetailedError('Initial state key out of range.', {customInitialValues, numWires});
+            }
+            if (k >= this.numWires) {
+                continue;
+            }
+            this.customInitialValues.set(k, v);
+        }
 
         /**
          * @type {!Array.<!Array.<undefined|!string>>}
@@ -126,6 +140,38 @@ class CircuitDefinition {
         return !this.columns.every(e => !e.hasControl(-1));
     }
 
+    /**
+     * @param {!int} wire
+     * @returns {!CircuitDefinition}
+     */
+    withSwitchedInitialStateOn(wire) {
+        let m = new Map([...this.customInitialValues.entries()]);
+        let v = m.get(wire);
+        let cycle = [...INITIAL_STATES_TO_GATES.keys()];
+        let newVal = cycle[(cycle.indexOf(v) + 1) % cycle.length];
+        if (newVal === undefined) {
+            m.delete(wire);
+        } else {
+            m.set(wire, newVal);
+        }
+        return this.withInitialStates(m);
+    }
+
+    /**
+     * @param {!Map.<!int, *>} map
+     * @returns {!CircuitDefinition}
+     */
+    withInitialStates(map) {
+        return new CircuitDefinition(
+            this.numWires,
+            this.columns,
+            this.outerRowOffset,
+            this.outerContext,
+            this.customGateSet,
+            this.isNested,
+            map);
+    }
+
     /**
      * @returns {!boolean}
      */
@@ -194,7 +240,8 @@ class CircuitDefinition {
             outerRowOffset,
             outerContext,
             this.customGateSet,
-            true);
+            true,
+            this.customInitialValues);
     }
 
     /**
@@ -235,7 +282,8 @@ class CircuitDefinition {
         }
         return other instanceof CircuitDefinition &&
             this.numWires === other.numWires &&
-            seq(this.columns).isEqualTo(seq(other.columns), Util.CUSTOM_IS_EQUAL_TO_EQUALITY);
+            seq(this.columns).isEqualTo(seq(other.columns), Util.CUSTOM_IS_EQUAL_TO_EQUALITY) &&
+            equate_Maps(this.customInitialValues, other.customInitialValues);
     }
 
     /**
@@ -355,7 +403,9 @@ class CircuitDefinition {
             cols,
             this.outerRowOffset,
             this.outerContext,
-            this.customGateSet);
+            this.customGateSet,
+            false,
+            this.customInitialValues);
     }
 
     /**
@@ -508,7 +558,9 @@ class CircuitDefinition {
             seq(this.columns).filterWithIndex((e, i) => used.has(i)).toArray(),
             this.outerRowOffset,
             this.outerContext,
-            this.customGateSet);
+            this.customGateSet,
+            false,
+            this.customInitialValues);
     }
 
     /**
@@ -527,7 +579,9 @@ class CircuitDefinition {
             ])),
             this.outerRowOffset,
             this.outerContext,
-            this.customGateSet);
+            this.customGateSet,
+            false,
+            this.customInitialValues);
     }
 
     /**
@@ -539,6 +593,9 @@ class CircuitDefinition {
         for (let c of this.columns) {
             best = Math.max(best, c.minimumRequiredWireCount());
         }
+        for (let usedWire of this.customInitialValues.keys()) {
+            best = Math.max(best, usedWire + 1);
+        }
         return best;
     }
 
@@ -845,6 +902,22 @@ class CircuitDefinition {
         return this._colRowDisabledReason[col][row];
     }
 
+    /**
+     * @param {!CircuitEvalContext} ctx
+     * @return {void}
+     */
+    applyInitialStateOperations(ctx) {
+        for (let wire = 0; wire < this.numWires; wire++) {
+            let state = this.customInitialValues.get(wire);
+            if (!INITIAL_STATES_TO_GATES.has(state)) {
+                throw new DetailedError('Unrecognized initial state.', {state});
+            }
+            for (let gate of INITIAL_STATES_TO_GATES.get(state)) {
+                GateShaders.applyMatrixOperation(ctx.withRow(ctx.row + wire), gate.knownMatrixAt(ctx.time))
+            }
+        }
+    }
+
     /**
      * @param {!int} colIndex
      * @param {!CircuitEvalContext} ctx
@@ -964,7 +1037,9 @@ class CircuitDefinition {
             this.columns,
             this.outerRowOffset,
             this.outerContext,
-            this.customGateSet.withGate(gate));
+            this.customGateSet.withGate(gate),
+            false,
+            this.customInitialValues);
     }
 
     /**
diff --git a/src/circuit/CircuitStats.js b/src/circuit/CircuitStats.js
index bcd78719..80801fad 100644
--- a/src/circuit/CircuitStats.js
+++ b/src/circuit/CircuitStats.js
@@ -18,7 +18,7 @@ import {CircuitShaders} from "src/circuit/CircuitShaders.js"
 import {KetTextureUtil} from "src/circuit/KetTextureUtil.js"
 import {Controls} from "src/circuit/Controls.js"
 import {DetailedError} from "src/base/DetailedError.js"
-import {Matrix} from "src/math/Matrix.js"
+import {Matrix, complexVectorToReadableJson} from "src/math/Matrix.js"
 import {Shaders} from "src/webgl/Shaders.js"
 import {Serializer} from "src/circuit/Serializer.js"
 import {Util} from "src/base/Util.js"
@@ -108,6 +108,52 @@ class CircuitStats {
         return this._qubitDensities[col][wireIndex];
     }
 
+    /**
+     * Converts the circuit stats into an exportable JSON object.
+     * @param {!boolean} includeOutputAmplitudes
+     * @returns {!object}
+     */
+    toReadableJson(includeOutputAmplitudes=true) {
+        let result = {
+            time_parameter: this.time,
+            circuit: Serializer.toJson(this.circuitDefinition),
+            chance_of_surviving_to_each_column: this._survivalRates,
+            computed_bloch_vectors_by_column_then_wire: this._qubitDensities.map(
+                col => col.map(singleQubitDensityMatrixToReadableJson)
+            ),
+            displays: this._customStatsToReadableJson()
+        };
+        if (includeOutputAmplitudes) {
+            result['output_amplitudes'] = complexVectorToReadableJson(this.finalState.getColumn(0));
+        }
+        return result;
+    }
+
+    _customStatsToReadableJson() {
+        let result = [];
+        for (let [key, data] of this._customStatsProcessed.entries()) {
+            let [col, row] = key.split(':');
+            row = parseInt(row);
+            col = parseInt(col);
+            let gate = this.circuitDefinition.columns[col].gates[row];
+            if (gate.processedStatsToJsonFunc !== undefined) {
+                data = gate.processedStatsToJsonFunc(data);
+            }
+            result.push({
+                location: {
+                    wire: row,
+                    column: col,
+                },
+                type: {
+                    serialized_id: gate.serializedId,
+                    name: gate.name,
+                },
+                data
+            });
+        }
+        return result;
+    }
+
     /**
      * Determines how often the circuit evaluation survives to the given column, without being post-selected out.
      *
@@ -341,6 +387,19 @@ class CircuitStats {
     }
 }
 
+/**
+ * @param {!Matrix} matrix
+ */
+function singleQubitDensityMatrixToReadableJson(matrix) {
+    if (matrix.hasNaN()) {
+        return null;
+    }
+    let [x, y, z] = matrix.qubitDensityMatrixToBlochVector();
+    x *= -1;
+    z *= -1;
+    return {x, y, z};
+}
+
 CircuitStats.EMPTY = CircuitStats.withNanDataFromCircuitAtTime(CircuitDefinition.EMPTY, 0);
 
 export {CircuitStats}
diff --git a/src/circuit/Gate.js b/src/circuit/Gate.js
index ad751710..9e50e93c 100644
--- a/src/circuit/Gate.js
+++ b/src/circuit/Gate.js
@@ -71,6 +71,11 @@ class Gate {
          * @type {undefined|!function(!Float32Array, !CircuitDefinition, !int, !int) : *}
          */
         this.customStatPostProcesser = undefined;
+        /**
+         * Returns a json form of the custom-stat data, used when exporting it.
+         * @type {undefined|!function(data: *) : *}
+         */
+        this.processedStatsToJsonFunc = undefined;
         /** @type {!Array.<!Gate>} A list of size variants of this gate.*/
         this.gateFamily = [this];
 
@@ -153,6 +158,14 @@ class Gate {
          * @private
          */
         this._controlBit = undefined;
+        /**
+         * Determines if a controlled gate's control is guaranteed to be known classically. This is used by the
+         * combination detect-control-reset gates as a way to communicate that they can control permutation operations
+         * on classical wires.
+         * @type {boolean}
+         * @private
+         */
+        this._isClassicalControl = false;
         /**
          * Indicates that this gate is guaranteed to preserve probability (as opposed to e.g. post-selection).
          * When gates with this property not set to true are present in a column, the simulator computes losses/gains.
@@ -180,6 +193,12 @@ class Gate {
          * @type {undefined | !function(!int) : !int}
          */
         this.knownBitPermutationFunc = undefined;
+        /**
+         * When a permutation factors into sub-permutations over subsets of the bits, this map indexes each bit with
+         * an id for the group that it belongs to.
+         * @type {!Array.<!int>}
+         */
+        this.knownBitPermutationGroupMasks = undefined;
         /**
          * Indicates that a gate is a phasing function, and that it phases each computation basis state by the amount
          * returned by this function.
@@ -215,15 +234,16 @@ class Gate {
      * @param {!Matrix} matrix
      * @param {!string} name
      * @param {!string} blurb
+     * @param {undefined|!string} serializedId
      * @returns {!Gate}
      */
-    static fromKnownMatrix(symbol, matrix, name='', blurb='') {
+    static fromKnownMatrix(symbol, matrix, name='', blurb='', serializedId=undefined) {
         if (!(matrix instanceof Matrix)) {
             throw new DetailedError("Bad matrix.", {symbol, matrix, name, blurb});
         }
         let g = new Gate();
         g.symbol = symbol;
-        g.serializedId = symbol;
+        g.serializedId = serializedId === undefined ? symbol : serializedId;
         g.name = name;
         g.blurb = blurb;
         g._isDefinitelyUnitary = matrix.isUnitary(0.01);
@@ -255,6 +275,7 @@ class Gate {
         g.customAfterOperation = this.customAfterOperation;
         g.customStatTexturesMaker = this.customStatTexturesMaker;
         g.customStatPostProcesser = this.customStatPostProcesser;
+        g.processedStatsToJsonFunc = this.processedStatsToJsonFunc;
         g.width = this.width;
         g.height = this.height;
         g.isSingleQubitDisplay = this.isSingleQubitDisplay;
@@ -271,12 +292,14 @@ class Gate {
         g._effectCreatesSuperpositions = this._effectCreatesSuperpositions;
         g._affectsOtherWires = this._affectsOtherWires;
         g._controlBit = this._controlBit;
+        g._isClassicalControl = this._isClassicalControl;
         g.isControlWireSource = this.isControlWireSource;
         g._isDefinitelyUnitary = this._isDefinitelyUnitary;
         g.knownPhaseTurnsFunc = this.knownPhaseTurnsFunc;
         g.knownPermutationFuncTakingInputs = this.knownPermutationFuncTakingInputs;
         g.customColumnContextProvider = this.customColumnContextProvider;
         g.customDisableReasonFinder = this.customDisableReasonFinder;
+        g.knownBitPermutationGroupMasks = this.knownBitPermutationGroupMasks;
         return g;
     }
 
@@ -379,6 +402,13 @@ class Gate {
         return this._controlBit !== undefined;
     }
 
+    /**
+     * @returns {!boolean}
+     */
+    isClassicalControl() {
+        return this._isClassicalControl;
+    }
+
     /**
      * @returns {undefined|!boolean}
      */
@@ -567,11 +597,12 @@ class GateBuilder {
      * Provides a function equivalent to how the gate rearranges wires, for checking in tests if the gate's behavior is
      * correct.
      * @param {!function(!int) : !int} knownBitPermutationFunc Returns the output of the permutation for a
-     * given input, assuming the gate is exactly sized to the overall circuit.
+     *     given input, assuming the gate is exactly sized to the overall circuit.
      * @returns {!GateBuilder}
      */
     setKnownEffectToBitPermutation(knownBitPermutationFunc) {
         this.gate.knownBitPermutationFunc = knownBitPermutationFunc;
+        this.gate.knownBitPermutationGroupMasks = permutationGrouping(knownBitPermutationFunc, this.gate.height);
         this.gate._isDefinitelyUnitary = true;
         this.gate._stableDuration = Infinity;
         this.gate._hasNoEffect = false;
@@ -794,13 +825,15 @@ class GateBuilder {
     /**
      * Sets meta-properties to indicate a gate is a control.
      * @param {!boolean} bit: Whether gate is a control or anti-control. Use before/after operations for flexibility.
+     * @param {!boolean} guaranteedClassical Whether or not the control can be used to control permutations of classical
+     *     wires, even if placed on a coherent wire.
      * @returns {!GateBuilder}
      */
-    markAsControlExpecting(bit) {
+    markAsControlExpecting(bit, guaranteedClassical=false) {
         this.gate._controlBit = bit;
         this.gate.isControlWireSource = true;
-        this.gate._isDefinitelyUnitary = true;
         this.gate.interestedInControls = false;
+        this.gate._isClassicalControl = guaranteedClassical;
         return this;
     }
 
@@ -918,6 +951,16 @@ class GateBuilder {
         return this;
     }
 
+    /**
+     * Specifies how to convert custom stats data into json when exporting.
+     * @param {undefined|!function(data: *) : *} jsonFunc
+     * @returns {!GateBuilder}
+     */
+    setProcessedStatsToJsonFunc(jsonFunc) {
+        this.gate.processedStatsToJsonFunc = jsonFunc;
+        return this;
+    }
+
     /**
      * @param {*} tag
      * @returns {!GateBuilder}
@@ -928,4 +971,28 @@ class GateBuilder {
     }
 }
 
+/**
+ * @param {!function(!int) : !int} knownBitPermutationFunc Returns the output of the permutation for a
+ *     given input, assuming the gate is exactly sized to the overall circuit.
+ * @param {!int} height
+ * @returns {!Array.<!int>}
+ */
+function permutationGrouping(knownBitPermutationFunc, height) {
+    let seen = new Set();
+    let result = [];
+    for (let i = 0; i < height; i++) {
+        let mask = 0;
+        let j = i;
+        while (!seen.has(j)) {
+            seen.add(j);
+            mask |= 1 << j;
+            j = knownBitPermutationFunc(j);
+        }
+        if (mask !== 0) {
+            result.push(mask);
+        }
+    }
+    return result;
+}
+
 export {Gate, GateBuilder}
diff --git a/src/circuit/GateColumn.js b/src/circuit/GateColumn.js
index 8d2d8a21..d7ecf18e 100644
--- a/src/circuit/GateColumn.js
+++ b/src/circuit/GateColumn.js
@@ -69,22 +69,37 @@ class GateColumn {
         return this.gates.every(e => e === undefined);
     }
 
-    hasControl(inputMeasureMask) {
-        return this.hasCoherentControl(inputMeasureMask) || this.hasMeasuredControl(inputMeasureMask);
+    /**
+     * @param {!int} inputMeasureMask
+     * @param {!int} ignoreMask
+     * @returns {!boolean}
+     */
+    hasControl(inputMeasureMask=0, ignoreMask=0) {
+        return this.hasCoherentControl(inputMeasureMask | ignoreMask) ||
+            this.hasMeasuredControl(inputMeasureMask & ~ignoreMask);
     }
 
-    hasCoherentControl(inputMeasureMask) {
+    /**
+     * @param {!int} inputMeasureMask
+     * @returns {!boolean}
+     */
+    hasCoherentControl(inputMeasureMask=0) {
         for (let i = 0; i < this.gates.length; i++) {
             if ((inputMeasureMask & (1 << i)) === 0 &&
                     this.gates[i] !== undefined &&
-                    this.gates[i].isControl()) {
+                    this.gates[i].isControl() &&
+                    !this.gates[i].isClassicalControl()) {
                 return true;
             }
         }
         return false;
     }
 
-    hasMeasuredControl(inputMeasureMask) {
+    /**
+     * @param {!int} inputMeasureMask
+     * @returns {!boolean}
+     */
+    hasMeasuredControl(inputMeasureMask=0) {
         for (let i = 0; i < this.gates.length; i++) {
             if ((inputMeasureMask & (1 << i)) !== 0 &&
                     this.gates[i] !== undefined &&
@@ -96,6 +111,21 @@ class GateColumn {
         return false;
     }
 
+    /**
+     * @returns {!int}
+     */
+    controlMask() {
+        let mask = 0;
+        for (let i = 0; i < this.gates.length; i++) {
+            if (this.gates[i] !== undefined &&
+                    this.gates[i].definitelyHasNoEffect() &&
+                    this.gates[i].isControl()) {
+                mask |= 1 << i;
+            }
+        }
+        return mask;
+    }
+
     /**
      * @param {!int} inputMeasureMask
      * @param {!int} row
@@ -156,25 +186,41 @@ class GateColumn {
         let g = this.gates[row];
         let mask = ((1 << g.height) - 1) << row;
         let maskMeasured = mask & inputMeasureMask;
-        if (maskMeasured !== 0) {
+        if (maskMeasured !== 0 && g.knownBitPermutationFunc === undefined) {
             // Don't try to superpose measured qubits.
             if (g.effectMightCreateSuperpositions()) {
                 return "no\nremix\n(sorry)";
             }
 
+            // Don't try to mix measured and coherent qubits, or coherently mix measured qubits.
             if (g.effectMightPermutesStates()) {
-                // Only permutations that respect bit boundaries can be performed on mixed qubits.
-                if (maskMeasured !== mask && (g.knownBitPermutationFunc === undefined ||
-                                              this.hasMeasuredControl(inputMeasureMask))) {
+                if (maskMeasured !== mask || this.hasCoherentControl(inputMeasureMask)) {
                     return "no\nremix\n(sorry)";
                 }
+            }
+        }
 
-                // Permutations affecting classical states can't have quantum controls.
-                if (this.hasCoherentControl(inputMeasureMask)) {
+        // Check permutation subgroups for bad mixing of measured and coherent qubits.
+        if (g.knownBitPermutationGroupMasks !== undefined) {
+            for (let maskGroup of g.knownBitPermutationGroupMasks) {
+                let isSingleton = ((maskGroup - 1) & maskGroup) === 0;
+                if (isSingleton) {
+                    continue;
+                }
+
+                maskGroup <<= row;
+                let hasCoherentQubits = (maskGroup & inputMeasureMask) !== maskGroup;
+                let hasMeasuredQubits = (maskGroup & inputMeasureMask) !== 0;
+                let coherentControl = this.hasCoherentControl(inputMeasureMask);
+                let controlled = this.hasControl(inputMeasureMask);
+                let coherentControlledMixingOfMeasured = hasMeasuredQubits && coherentControl;
+                let controlledMixingOfCoherentAndMeasured = hasCoherentQubits && hasMeasuredQubits && controlled;
+                if (coherentControlledMixingOfMeasured || controlledMixingOfCoherentAndMeasured) {
                     return "no\nremix\n(sorry)";
                 }
             }
         }
+
         return undefined;
     }
 
@@ -380,8 +426,9 @@ class GateColumn {
         // without getting the wrong answer, at least).
         let hasSingleResult = gate === Gates.PostSelectionGates.PostSelectOn
             || gate === Gates.PostSelectionGates.PostSelectOff
-            || gate === Gates.Detector;
-        if (!this.hasControl() && hasSingleResult) {
+            || gate === Gates.Detectors.ZDetector
+            || gate === Gates.Detectors.ZDetectControlClear;
+        if (!this.hasControl(0, 1 << row) && hasSingleResult) {
             state.measureMask &= ~(1<<row);
             return;
         }
diff --git a/src/circuit/GateShaders.js b/src/circuit/GateShaders.js
index f6444a1c..9835acf9 100644
--- a/src/circuit/GateShaders.js
+++ b/src/circuit/GateShaders.js
@@ -164,7 +164,7 @@ const CYCLE_ALL_SHADER_VEC2 = makePseudoShaderWithInputsAndOutputAndCode(
  * @returns {!WglConfiguredShader}
  */
 GateShaders.cycleAllBitsFloat = (inputTexture, shiftAmount) => {
-    let size = currentShaderCoder().vec2.arrayPowerSizeOfTexture(inputTexture);
+    let size = currentShaderCoder().float.arrayPowerSizeOfTexture(inputTexture);
     return CYCLE_ALL_SHADER_FLOAT(
         inputTexture,
         WglArg.float("shiftAmount", 1 << Util.properMod(-shiftAmount, size)));
diff --git a/src/circuit/Serializer.js b/src/circuit/Serializer.js
index 1f4dddc1..18ca83fb 100644
--- a/src/circuit/Serializer.js
+++ b/src/circuit/Serializer.js
@@ -21,7 +21,7 @@ import {DetailedError} from "src/base/DetailedError.js"
 import {Format} from "src/base/Format.js"
 import {Gate, GateBuilder} from "src/circuit/Gate.js"
 import {GateColumn} from "src/circuit/GateColumn.js"
-import {Gates} from "src/gates/AllGates.js"
+import {Gates, INITIAL_STATES_TO_GATES} from "src/gates/AllGates.js"
 import {Matrix} from "src/math/Matrix.js"
 import {Util} from "src/base/Util.js"
 import {notifyAboutRecoveryFromUnexpectedError} from "src/fallback.js"
@@ -381,6 +381,17 @@ let toJson_CircuitDefinition = (v, context) => {
     if (context === undefined && v.customGateSet.gates.length > 0) {
         result.gates = toJson_CustomGateSet(v.customGateSet);
     }
+    if (v.customInitialValues.size > 0) {
+        result.init = [];
+        let maxInit = seq(v.customInitialValues.keys()).max();
+        for (let i = 0; i <= maxInit; i++) {
+            let s = v.customInitialValues.get(i);
+            result.init.push(
+                s === undefined ? 0 :
+                s === '1' ? 1 :
+                s);
+        }
+    }
     return result;
 };
 
@@ -395,6 +406,38 @@ function fromJsonText_CircuitDefinition(jsonText) {
     return _cachedCircuit;
 }
 
+/**
+ * @param {object} json
+ * @returns {!Map.<!int, !string>}
+ * @throws
+ */
+function _fromJson_InitialState(json) {
+    let {init} = json;
+    if (init === undefined) {
+        return new Map();
+    }
+
+    if (!Array.isArray(init)) {
+        throw new DetailedError('Initial states must be an array.', {json});
+    }
+
+    let result = new Map();
+    for (let i = 0; i < init.length; i++) {
+        let v = init[i];
+        if (v === 0) {
+            // 0 is the default. Don't need to do anything.
+        } else if (v === 1) {
+            result.set(i, '1');
+        } else if (INITIAL_STATES_TO_GATES.has(v)) {
+            result.set(i, v);
+        } else {
+            throw new DetailedError('Unrecognized initial state key.', {v, json});
+        }
+    }
+
+    return result;
+}
+
 /**
  * @param {object} json
  * @param {undefined|!CustomGateSet} context
@@ -411,11 +454,16 @@ function fromJson_CircuitDefinition(json, context=undefined) {
     }
     let gateCols = cols.map(e => fromJson_GateColumn(e, customGateSet));
 
+    let initialValues = _fromJson_InitialState(json);
+
     let numWires = 0;
     for (let col of gateCols) {
         numWires = Math.max(numWires, col.minimumRequiredWireCount());
     }
-    numWires = Math.max(Config.MIN_WIRE_COUNT, Math.min(numWires, Config.MAX_WIRE_COUNT));
+    numWires = Math.max(
+        Config.MIN_WIRE_COUNT,
+        Math.min(numWires, Config.MAX_WIRE_COUNT),
+        ...[...initialValues.keys()].map(e => e + 1));
 
     gateCols = gateCols.map(col => new GateColumn([
             ...col.gates,
@@ -424,7 +472,7 @@ function fromJson_CircuitDefinition(json, context=undefined) {
         // Silently discard gates off the edge of the circuit.
         ].slice(0, numWires)));
 
-    return new CircuitDefinition(numWires, gateCols, undefined, undefined, customGateSet).
+    return new CircuitDefinition(numWires, gateCols, undefined, undefined, customGateSet, false, initialValues).
         withTrailingSpacersIncluded();
 }
 
diff --git a/src/draw/MathPainter.js b/src/draw/MathPainter.js
index 12f19052..26521b6a 100644
--- a/src/draw/MathPainter.js
+++ b/src/draw/MathPainter.js
@@ -623,7 +623,7 @@ class MathPainter {
         MathPainter.paintMatrixTooltip(painter, matrix, drawArea, focusPoints,
             (c, r) => c === r ?
                 `Probability of |${Util.bin(c, n)}⟩` :
-                `Coupling of |${Util.bin(c, n)}⟩ to ⟨${Util.bin(r, n)}|`,
+                `Coupling of |${Util.bin(r, n)}⟩ to ⟨${Util.bin(c, n)}|`,
             (c, r, v) => c === r ?
                 (matrix.cell(c, r).real*100).toFixed(4) + "%" :
                 matrix.cell(c, r).toString(new Format(false, 0, 6, ", ")));
diff --git a/src/draw/Painter.js b/src/draw/Painter.js
index f70f93b6..dded626c 100644
--- a/src/draw/Painter.js
+++ b/src/draw/Painter.js
@@ -56,13 +56,25 @@ class Painter {
          * @type {!RestartableRng}
          */
         this.rng = rng;
+
+        this._ignoringTouchBlockers = 0;
+    }
+
+    startIgnoringIncomingTouchBlockers() {
+        this._ignoringTouchBlockers += 1
+    }
+
+    stopIgnoringIncomingTouchBlockers() {
+        this._ignoringTouchBlockers -= 1
     }
 
     /**
      * @param {!{rect: !Rect, cursor: undefined|!string}} blocker
      */
     noteTouchBlocker(blocker) {
-        this.touchBlockers.push(blocker);
+        if (this._ignoringTouchBlockers === 0) {
+            this.touchBlockers.push(blocker);
+        }
     }
 
     /**
diff --git a/src/gates/AllGates.js b/src/gates/AllGates.js
index ed4104ae..ca04ffc3 100644
--- a/src/gates/AllGates.js
+++ b/src/gates/AllGates.js
@@ -25,6 +25,7 @@ import {ErrorInjectionGate} from "src/gates/Debug_ErrorInjectionGate.js"
 import {ExponentiatingGates} from "src/gates/ExponentiatingGates.js"
 import {FourierTransformGates} from "src/gates/FourierTransformGates.js"
 import {HalfTurnGates} from "src/gates/HalfTurnGates.js"
+import {ImaginaryGate} from "src/gates/Joke_ImaginaryGate.js"
 import {IncrementGates} from "src/gates/IncrementGates.js"
 import {InputGates} from "src/gates/InputGates.js"
 import {InterleaveBitsGates} from "src/gates/InterleaveBitsGates.js"
@@ -45,7 +46,7 @@ import {ProbabilityDisplayFamily} from "src/gates/ProbabilityDisplay.js"
 import {QuarterTurnGates} from "src/gates/QuarterTurnGates.js"
 import {ReverseBitsGateFamily} from "src/gates/ReverseBitsGate.js"
 import {SampleDisplayFamily} from "src/gates/SampleDisplay.js"
-import {Detector} from "src/gates/Detector.js"
+import {Detectors} from "src/gates/Detector.js"
 import {SpacerGate} from "src/gates/SpacerGate.js"
 import {SwapGateHalf} from "src/gates/SwapGateHalf.js"
 import {UniversalNotGate} from "src/gates/Impossible_UniversalNotGate.js"
@@ -89,6 +90,7 @@ Gates.ErrorInjection = ErrorInjectionGate;
 Gates.Exponentiating = ExponentiatingGates;
 Gates.FourierTransformGates = FourierTransformGates;
 Gates.HalfTurns = HalfTurnGates;
+Gates.ImaginaryGate = ImaginaryGate;
 Gates.IncrementGates = IncrementGates;
 Gates.InputGates = InputGates;
 Gates.InterleaveBitsGates = InterleaveBitsGates;
@@ -109,7 +111,7 @@ Gates.PostSelectionGates = PostSelectionGates;
 Gates.Powering = PoweringGates;
 Gates.QuarterTurns = QuarterTurnGates;
 Gates.ReverseBitsGateFamily = ReverseBitsGateFamily;
-Gates.Detector = Detector;
+Gates.Detectors = Detectors;
 Gates.SpacerGate = SpacerGate;
 Gates.UniversalNot = UniversalNotGate;
 Gates.XorGates = XorGates;
@@ -120,13 +122,13 @@ Gates.KnownToSerializer = [
     ...Controls.all,
     ...InputGates.all,
     MeasurementGate,
-    Detector,
     SwapGateHalf,
     SpacerGate,
     UniversalNotGate,
     ErrorInjectionGate,
     ZeroGate,
     NeGate,
+    ImaginaryGate,
 
     ...AmplitudeDisplayFamily.all,
     ...ProbabilityDisplayFamily.all,
@@ -139,6 +141,7 @@ Gates.KnownToSerializer = [
     ...ComparisonGates.all,
     ...CountingGates.all,
     ...CycleBitsGates.all,
+    ...Detectors.all,
     ...ExponentiatingGates.all,
     ...FourierTransformGates.all,
     ...HalfTurnGates.all,
@@ -239,14 +242,22 @@ Gates.TopToolboxGroups = [
             ParametrizedRotationGates.XToA, ParametrizedRotationGates.XToMinusA,
         ]
     },
+    {
+        hint: 'Sampling',
+        gates: [
+            Detectors.ZDetector, Detectors.ZDetectControlClear,
+            Detectors.YDetector, Detectors.YDetectControlClear,
+            Detectors.XDetector, Detectors.XDetectControlClear,
+        ]
+    },
     {
         hint: 'Silly',
         gates: [
             ZeroGate,   MysteryGateMaker(),
-            NeGate,     undefined,
-            SpacerGate, undefined
+            NeGate,     ImaginaryGate,
+            SpacerGate, undefined,
         ]
-    }
+    },
 ];
 
 /** @type {!Array<!{hint: !string, gates: !Array<undefined|!Gate>}>} */
@@ -323,4 +334,14 @@ Gates.BottomToolboxGroups = [
     },
 ];
 
-export {Gates}
+/** @type {!Map.<undefined|!string, !Array.<!Gate>>} */
+const INITIAL_STATES_TO_GATES = new Map([
+    [undefined, []],
+    ['1', [Gates.HalfTurns.X]],
+    ['+', [Gates.HalfTurns.H]],
+    ['-', [Gates.HalfTurns.H, Gates.HalfTurns.Z]],
+    ['i', [Gates.HalfTurns.H, Gates.QuarterTurns.SqrtZForward]],
+    ['-i', [Gates.HalfTurns.H, Gates.QuarterTurns.SqrtZBackward]]
+]);
+
+export {Gates, INITIAL_STATES_TO_GATES}
diff --git a/src/gates/AmplitudeDisplay.js b/src/gates/AmplitudeDisplay.js
index cf89fb6a..d76795ce 100644
--- a/src/gates/AmplitudeDisplay.js
+++ b/src/gates/AmplitudeDisplay.js
@@ -19,10 +19,11 @@ import {GatePainting} from "src/draw/GatePainting.js"
 import {GateShaders} from "src/circuit/GateShaders.js"
 import {Format} from "src/base/Format.js"
 import {MathPainter} from "src/draw/MathPainter.js"
-import {Matrix} from "src/math/Matrix.js"
+import {Matrix, complexVectorToReadableJson, realVectorToReadableJson} from "src/math/Matrix.js"
+import {probabilityStatTexture} from "src/gates/ProbabilityDisplay.js"
 import {Point} from "src/math/Point.js"
 import {Util} from "src/base/Util.js"
-import {WglArg} from "src/webgl/WglArg.js"
+import {Shaders} from "src/webgl/Shaders.js"
 import {WglConfiguredShader} from "src/webgl/WglConfiguredShader.js"
 import {
     Inputs,
@@ -36,11 +37,14 @@ import {WglTextureTrader} from "src/webgl/WglTextureTrader.js"
 /**
  * @param {!WglTexture} stateKet
  * @param {!Controls} controls
+ * @param {!WglTexture} controlsTexture
  * @param {!int} rangeOffset
  * @param {!int} rangeLength
  * @returns {!Array.<!WglTexture>}
  */
-function amplitudeDisplayStatTextures(stateKet, controls, rangeOffset, rangeLength) {
+function amplitudeDisplayStatTextures(stateKet, controls, controlsTexture, rangeOffset, rangeLength) {
+    let incoherentKet = probabilityStatTexture(stateKet, controlsTexture, rangeOffset, rangeLength);
+
     let trader = new WglTextureTrader(stateKet);
     trader.dontDeallocCurrentTexture();
 
@@ -49,65 +53,114 @@ function amplitudeDisplayStatTextures(stateKet, controls, rangeOffset, rangeLeng
     let lostQubits = Util.numberOfSetBits(controls.inclusionMask);
     let lostHeadQubits = Util.numberOfSetBits(controls.inclusionMask & ((1<<rangeOffset)-1));
     let involvedQubits = startingQubits - lostQubits;
+    let broadcastQubits = involvedQubits - rangeLength;
+
+    // Get relevant case vectors.
     trader.shadeAndTrade(
         tex => CircuitShaders.controlSelect(controls, tex),
         WglTexturePool.takeVec2Tex(involvedQubits));
     trader.shadeAndTrade(tex => GateShaders.cycleAllBits(tex, lostHeadQubits-rangeOffset));
     let ketJustAfterCycle = trader.dontDeallocCurrentTexture();
 
-    // Look over all superposed values of the target qubits and pick the one with the most amplitude.
-    trader.shadeAndTrade(amplitudesToPolarKets, WglTexturePool.takeVec4Tex(involvedQubits));
-    spreadLengthAcrossPolarKets(trader, rangeLength);
-    reduceToLongestPolarKet(trader, rangeLength);
-    trader.shadeAndTrade(convertAwayFromPolar);
-    let amps = trader.dontDeallocCurrentTexture();
+    // Compute magnitude of each case's vector.
+    trader.shadeAndTrade(AMPS_TO_SQUARED_MAGS_SHADER, WglTexturePool.takeVecFloatTex(involvedQubits));
+    for (let k = 0; k < rangeLength; k++) {
+        trader.shadeHalveAndTrade(Shaders.sumFoldFloatAdjacents);
+    }
+
+    // Find the index of the case with the largest vector.
+    trader.shadeAndTrade(MAGS_TO_INDEXED_MAGS_SHADER, WglTexturePool.takeVec2Tex(broadcastQubits));
+    for (let k = 0; k < broadcastQubits; k++) {
+        trader.shadeHalveAndTrade(FOLD_MAX_INDEXED_MAG_SHADER);
+    }
+
+    // Lookup the components of the largest vector.
+    trader.shadeAndTrade(
+        indexed_mag => LOOKUP_KET_AT_INDEXED_MAG_SHADER(ketJustAfterCycle, indexed_mag),
+        WglTexturePool.takeVec2Tex(rangeLength));
+    let rawKet = trader.dontDeallocCurrentTexture();
 
-    // Compare the chosen case against other cases. If they aren't multiples, we're not separable (i.e. incoherent).
+    // Compute the dot product of the largest vector against every other vector.
     trader.shadeAndTrade(
-        winningVectorKet => toRatiosVsRepresentative(ketJustAfterCycle, winningVectorKet),
-        WglTexturePool.takeVec4Tex(involvedQubits));
+        small_input => POINTWISE_CMUL_CONJ_SHADER(small_input, ketJustAfterCycle),
+        WglTexturePool.takeVec2Tex(involvedQubits));
     ketJustAfterCycle.deallocByDepositingInPool("ketJustAfterCycle in makeAmplitudeSpanPipeline");
-    foldConsistentRatios(trader, rangeLength);
-    signallingSumAll(trader);
+    for (let k = 0; k < rangeLength; k++) {
+        trader.shadeHalveAndTrade(Shaders.sumFoldVec2Adjacents);
+    }
 
-    return [amps, trader.currentTexture];
+    // Sum up the magnitudes of the dot products to get a quality metric for how well the largest vector worked.
+    trader.shadeAndTrade(AMPS_TO_SQUARED_MAGS_SHADER, WglTexturePool.takeVecFloatTex(broadcastQubits));
+    for (let k = 0; k < broadcastQubits; k++) {
+        trader.shadeHalveAndTrade(Shaders.sumFoldFloat);
+    }
+
+    if (currentShaderCoder().float.needRearrangingToBeInVec4Format) {
+        trader.shadeHalveAndTrade(Shaders.packFloatIntoVec4);
+    }
+    let denormalizedQuality = trader.currentTexture;
+
+    trader.currentTexture = rawKet;
+    if (currentShaderCoder().vec2.needRearrangingToBeInVec4Format) {
+        trader.shadeHalveAndTrade(Shaders.packVec2IntoVec4);
+    }
+    let ket = trader.currentTexture;
+
+    return [ket, denormalizedQuality, incoherentKet];
 }
 
 /**
  * @param {!int} span
  * @param {!Array.<!Float32Array>} pixelGroups
  * @param {!CircuitDefinition} circuitDefinition
- * @returns {!{probabilities: undefined|!Float32Array, superposition: undefined|!Matrix, phaseLockIndex:undefined|!int}}
+ * @returns {!{quality: !number, ket: !Matrix, phaseLockIndex: !int,incoherentKet: !Matrix}}
  */
 function processOutputs(span, pixelGroups, circuitDefinition) {
-    let [ketPixels, consistentPixel] = pixelGroups;
-    let n = ketPixels.length >> 2;
+    let [ketPixels, qualityPixels, rawIncoherentKetPixels] = pixelGroups;
+    let denormalizedQuality = qualityPixels[0];
+    let n = 1 << span;
     let w = n === 2 ? 2 : 1 << Math.floor(Math.round(Math.log2(n))/2);
     let h = n/w;
-    let isPure = !isNaN(consistentPixel[0]) && consistentPixel[0] !== -666.0;
-    let unity = ketPixels[2];
 
-    if (!isPure) {
-        return _processOutputs_probabilities(w, h, n, unity, ketPixels);
+    // Rescale quantities.
+    let unity = 0;
+    for (let e of ketPixels) {
+        unity += e*e;
     }
+    let incoherentKetPixels = new Float32Array(w * h * 2);
+    let incoherentUnity = 0;
+    for (let i = 0; i < n; i++) {
+        incoherentUnity += rawIncoherentKetPixels[i];
+        incoherentKetPixels[i << 1] = Math.sqrt(rawIncoherentKetPixels[i]);
+    }
+    if (isNaN(incoherentUnity) || incoherentUnity < 0.000001) {
+        return {
+            quality: 0.0,
+            ket: Matrix.zero(w, h).times(NaN),
+            phaseLockIndex: 0,
+            incoherentKet: Matrix.zero(w, h).times(NaN),
+        };
+    }
+    let quality = denormalizedQuality / unity / incoherentUnity;
 
     let phaseIndex = span === circuitDefinition.numWires ? undefined : _processOutputs_pickPhaseLockIndex(ketPixels);
-    let phase = phaseIndex === undefined ? 0 : Math.atan2(ketPixels[phaseIndex*4+1], ketPixels[phaseIndex*4]);
+    let phase = phaseIndex === undefined ? 0 : Math.atan2(ketPixels[phaseIndex*2+1], ketPixels[phaseIndex*2]);
     let c = Math.cos(phase);
     let s = -Math.sin(phase);
 
     let buf = new Float32Array(n*2);
     let sqrtUnity = Math.sqrt(unity);
     for (let i = 0; i < n; i++) {
-        let real = ketPixels[i*4]/sqrtUnity;
-        let imag = ketPixels[i*4+1]/sqrtUnity;
+        let real = ketPixels[i*2]/sqrtUnity;
+        let imag = ketPixels[i*2+1]/sqrtUnity;
         buf[i*2] = real*c + imag*-s;
         buf[i*2+1] = real*s + imag*c;
     }
     return {
-        probabilities: undefined,
-        superposition: new Matrix(w, h, buf),
-        phaseLockIndex: phaseIndex
+        quality,
+        ket: new Matrix(w, h, buf),
+        phaseLockIndex: phaseIndex,
+        incoherentKet: new Matrix(w, h, incoherentKetPixels),
     };
 }
 
@@ -119,230 +172,80 @@ function processOutputs(span, pixelGroups, circuitDefinition) {
 function _processOutputs_pickPhaseLockIndex(ketPixels) {
     let result = 0;
     let best = 0;
-    for (let k = 0; k < ketPixels.length; k += 4) {
+    for (let k = 0; k < ketPixels.length; k += 2) {
         let r = ketPixels[k];
         let i = ketPixels[k+1];
         let m = r*r + i*i;
         if (m > best*10000) {
             best = m;
-            result = k >> 2;
+            result = k >> 1;
         }
     }
     return result;
 }
 
-function _processOutputs_probabilities(w, h, n, unity, ketPixels) {
-    let pBuf = new Float32Array(n*2);
-    for (let k = 0; k < n; k++) {
-        let r = ketPixels[k*4];
-        let i = ketPixels[k*4+1];
-        pBuf[k*2] = Math.sqrt((r*r + i*i)/unity);
-    }
-    return {
-        probabilities: new Matrix(w, h, pBuf),
-        superposition: undefined,
-        phaseLockIndex: undefined
-    };
-}
-
-/**
- * @param {!WglTexture} input
- * @returns {!WglConfiguredShader}
- */
-function amplitudesToPolarKets(input) {
-    return AMPLITUDES_TO_POLAR_KETS_SHADER(input);
-}
-const AMPLITUDES_TO_POLAR_KETS_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
+const AMPS_TO_SQUARED_MAGS_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
     [Inputs.vec2('input')],
-    Outputs.vec4(),
-    `vec4 outputFor(float k) {
+    Outputs.float(),
+    `float outputFor(float k) {
         vec2 ri = read_input(k);
-        float mag = dot(ri, ri);
-        float phase = mag == 0.0 ? 0.0 : atan(ri.y, ri.x);
-        return vec4(mag, phase, mag, 0.0);
+        return dot(ri, ri);
     }`);
 
-/**
- * Goes from (mag, angle, mag, 0) form to (mag, angle, total_vector_mag, 0) form.
- * @param {!WglTextureTrader} textureTrader
- * @param {!int} includedQubitCount
- * @returns {void}
- */
-function spreadLengthAcrossPolarKets(textureTrader, includedQubitCount) {
-    for (let bit = 0; bit < includedQubitCount; bit++) {
-        textureTrader.shadeAndTrade(inp => SPREAD_LENGTH_ACROSS_POLAR_KETS_SHADER(
-            inp,
-            WglArg.float('bit', 1 << bit)));
-    }
-}
-const SPREAD_LENGTH_ACROSS_POLAR_KETS_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
-    [Inputs.vec4('input')],
-    Outputs.vec4(),
-    `
-    uniform float bit;
-
-    float xorBit(float v) {
-        float b = mod(floor(v/bit), 2.0);
-        float d = 1.0 - 2.0*b;
-        return v + bit*d;
-    }
-
-    vec4 outputFor(float k) {
-        float partner = xorBit(k);
-        vec4 v = read_input(k);
-        vec4 p = read_input(partner);
-        return vec4(v.x, v.y, v.z + p.z, 0.0);
+const MAGS_TO_INDEXED_MAGS_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
+    [Inputs.float('input')],
+    Outputs.vec2(),
+    `vec2 outputFor(float k) {
+        return vec2(float(k), read_input(k));
     }`);
 
-/**
- * Reduces a list of vectors in (mag, angle, total_mag_of_vector, 0) form to the single highest-total-magnitude vector.
- * @param {!WglTextureTrader} textureTrader
- * @param {!int} includedQubitCount
- * @returns {void}
- */
-function reduceToLongestPolarKet(textureTrader, includedQubitCount) {
-    let curQubitCount = currentShaderCoder().vec4.arrayPowerSizeOfTexture(textureTrader.currentTexture);
-    while (curQubitCount > includedQubitCount) {
-        curQubitCount -= 1;
-        textureTrader.shadeHalveAndTrade(
-            inp => FOLD_REPRESENTATIVE_POLAR_KET_SHADER(
-                inp,
-                WglArg.float('offset', 1 << curQubitCount)));
-    }
-}
-const FOLD_REPRESENTATIVE_POLAR_KET_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
-    [Inputs.vec4('input')],
-    Outputs.vec4(),
-    `
-    uniform float offset;
-
-    vec4 outputFor(float k) {
-        vec4 p = read_input(k);
-        vec4 q = read_input(k + offset);
-        return vec4(
-            p.x + q.x,
-            // Bias towards p1 is to keep the choice stable in the face of uniform superpositions and noise.
-            p.z*1.001 >= q.z ? p.y : q.y,
-            p.z + q.z,
-            0.0);
-    }`);
-
-/**
- * @param {!WglTexture} input
- * @returns {!WglConfiguredShader}
- */
-function convertAwayFromPolar(input) {
-    return CONVERT_AWAY_FROM_POLAR_SHADER(input);
-}
-const CONVERT_AWAY_FROM_POLAR_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
-    [Inputs.vec4('input')],
-    Outputs.vec4(),
-    `
-    vec4 outputFor(float k) {
-        vec4 polar = read_input(k);
-        float mag = sqrt(polar.x);
-        return vec4(mag * cos(polar.y), mag * sin(polar.y), polar.z, 0.0);
+const FOLD_MAX_INDEXED_MAG_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
+    [Inputs.vec2('input')],
+    Outputs.vec2(),
+    `vec2 outputFor(float k) {
+        vec2 a = read_input(k);
+        vec2 b = read_input(k + len_output());
+        return a.y >= b.y ? a : b;
     }`);
 
-/**
- * @param {!WglTexture} ket
- * @param {!WglTexture} rep
- * @returns {!WglConfiguredShader}
- */
-let toRatiosVsRepresentative = (ket, rep) => TO_RATIOS_VS_REPRESENTATIVE_SHADER(ket, rep);
-const TO_RATIOS_VS_REPRESENTATIVE_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
-    [
-        Inputs.vec2('ket'),
-        Inputs.vec4('rep')
-    ],
-    Outputs.vec4(),
-    `vec4 outputFor(float k) {
-        return vec4(read_ket(k), read_rep(mod(k, len_rep())).xy);
+const LOOKUP_KET_AT_INDEXED_MAG_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
+    [Inputs.vec2('input'), Inputs.vec2('indexed_mag')],
+    Outputs.vec2(),
+    `vec2 outputFor(float k) {
+        return read_input(k + read_indexed_mag(0.0).x * len_output());
     }`);
 
-/**
- * @param {!WglTextureTrader} textureTrader
- * @param {!int} includedQubitCount
- * @returns {void}
- */
-function foldConsistentRatios(textureTrader, includedQubitCount) {
-    let curQubitCount = currentShaderCoder().vec4.arrayPowerSizeOfTexture(textureTrader.currentTexture);
-    let remainingIncludedQubitCount = includedQubitCount;
-    while (remainingIncludedQubitCount > 0) {
-        remainingIncludedQubitCount -= 1;
-        curQubitCount -= 1;
-        textureTrader.shadeHalveAndTrade(
-            inp => FOLD_CONSISTENT_RATIOS_SHADER(
-                inp,
-                WglArg.float('bit', 1 << remainingIncludedQubitCount)));
-    }
-}
-const FOLD_CONSISTENT_RATIOS_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
-    [Inputs.vec4('input')],
-    Outputs.vec4(),
+const POINTWISE_CMUL_CONJ_SHADER = makePseudoShaderWithInputsAndOutputAndCode(
+    [Inputs.vec2('small_input'), Inputs.vec2('large_input')],
+    Outputs.vec2(),
     `
-    uniform float bit;
-
-    vec2 mul(vec2 c1, vec2 c2) {
-        return vec2(c1.x*c2.x - c1.y*c2.y, c1.x*c2.y + c1.y*c2.x);
-    }
-    vec4 mergeRatios(vec4 a, vec4 b) {
-        vec2 c1 = mul(a.xy, b.zw);
-        vec2 c2 = mul(a.zw, b.xy);
-        vec2 d = c1 - c2;
-        float err = dot(d, d);
-        // The max up-scaling controls a tricky tradeoff between noisy false positives and blurry false negatives.
-        err /= max(0.00000000001, min(abs(dot(c1, c1)), abs(dot(c2,c2))));
-        float m1 = dot(a, a);
-        float m2 = dot(b, b);
-        return a.x == -666.0 || b.x == -666.0 || err > 0.001 ? vec4(-666.0, -666.0, -666.0, -666.0)
-            : m1 >= m2 ? a
-            : b;
+    vec2 cmul_conj(vec2 c1, vec2 c2) {
+        return mat2(c1.x, -c1.y, c1.y, c1.x) * c2;
     }
-
-    vec4 outputFor(float k) {
-        float s1 = mod(k, bit) + floor(k/bit)*2.0*bit;
-        float s2 = s1 + bit;
-        vec4 v1 = read_input(s1);
-        vec4 v2 = read_input(s2);
-
-        return mergeRatios(v1, v2);
-    }`);
-
-/**
- * @param {!WglTextureTrader} textureTrader
- */
-function signallingSumAll(textureTrader) {
-    let curQubitCount = currentShaderCoder().vec4.arrayPowerSizeOfTexture(textureTrader.currentTexture);
-    while (curQubitCount > 0) {
-        curQubitCount -= 1;
-        textureTrader.shadeHalveAndTrade(SIGNALLING_SUM_SHADER_VEC4);
+    vec2 outputFor(float k) {
+        vec2 in1 = read_small_input(floor(mod(k + 0.5, len_small_input())));
+        vec2 in2 = read_large_input(k);
+        return cmul_conj(in1, in2);
     }
-}
-const SIGNALLING_SUM_SHADER_VEC4 = makePseudoShaderWithInputsAndOutputAndCode(
-    [Inputs.vec4('input')],
-    Outputs.vec4(),
-    `vec4 outputFor(float k) {
-        vec4 a = read_input(k);
-        vec4 b = read_input(k + len_output());
-        return a.x == -666.0 || b.x == -666.0 ? vec4(-666.0, -666.0, -666.0, -666.0) : a + b;
-    }`);
+    `);
 
 /**
  * @type {!function(!GateDrawParams)}
  */
 const AMPLITUDE_DRAWER_FROM_CUSTOM_STATS = GatePainting.makeDisplayDrawer(args => {
     let n = args.gate.height;
-    let {probabilities, superposition, phaseLockIndex} = args.customStats || {
-        probabilities: undefined,
-        superposition: (n === 1 ? Matrix.zero(2, 1) : Matrix.zero(1 << Math.floor(n / 2), 1 << Math.ceil(n / 2))).
-            times(NaN),
-        phaseLockIndex: undefined
+    let {quality, ket, phaseLockIndex, incoherentKet} = args.customStats || {
+        ket: (n === 1 ? Matrix.zero(2, 1) : Matrix.zero(1 << Math.floor(n / 2), 1 << Math.ceil(n / 2))).times(NaN),
+        quality: 1,
+        phaseLockIndex: 0,
+        incoherentKet: undefined
     };
-    let matrix = probabilities || superposition;
-    let isIncoherent = superposition === undefined;
-    let dw = args.rect.w - args.rect.h*matrix.width()/matrix.height();
+
+    let isIncoherent = quality < 0.99;
+    let matrix = isIncoherent ? incoherentKet : ket;
+    let dw = args.rect.w - args.rect.h*ket.width()/ket.height();
     let drawRect = args.rect.skipLeft(dw/2).skipRight(dw/2);
+    let indicatorAlpha = Math.min(1, Math.max(0, (quality - 0.9999) / 0.0001));
     MathPainter.paintMatrix(
         args.painter,
         matrix,
@@ -351,7 +254,7 @@ const AMPLITUDE_DRAWER_FROM_CUSTOM_STATS = GatePainting.makeDisplayDrawer(args =
         'black',
         Config.SUPERPOSITION_FORE_COLOR,
         Config.SUPERPOSITION_BACK_COLOR,
-        isIncoherent ? 'transparent' : 'black');
+        `rgba(0, 0, 0, ${indicatorAlpha})`);
 
     let forceSign = v => (v >= 0 ? '+' : '') + v.toFixed(2);
     if (isIncoherent) {
@@ -371,36 +274,40 @@ const AMPLITUDE_DRAWER_FROM_CUSTOM_STATS = GatePainting.makeDisplayDrawer(args =
             let r = Math.floor(phaseLockIndex / matrix.width());
             let cx = drawRect.x + cw*(c+0.5);
             let cy = drawRect.y + rh*(r+0.5);
-            args.painter.strokeLine(new Point(cx, cy), new Point(cx + cw/2, cy), 'red', 2);
+            args.painter.strokeLine(
+                new Point(cx, cy),
+                new Point(cx + cw/2, cy),
+                `rgba(255,0,0,${indicatorAlpha})`,
+                2);
             args.painter.print(
                 'fixed',
                 cx + 0.5*cw,
                 cy,
                 'right',
                 'bottom',
-                'red',
+                `rgba(255,0,0,${indicatorAlpha})`,
                 '12px monospace',
                 cw*0.5,
                 rh*0.5);
         }
     }
 
-    paintErrorIfPresent(args, isIncoherent);
+    paintErrorIfPresent(args, indicatorAlpha);
 });
 
 /**
  * @param {!GateDrawParams} args
- * @param {!boolean} isIncoherent
+ * @param {!number} indicatorAlpha
  */
-function paintErrorIfPresent(args, isIncoherent) {
+function paintErrorIfPresent(args, indicatorAlpha) {
     /** @type {undefined|!string} */
     let err = undefined;
     let {col, row} = args.positionInCircuit;
     let measured = ((args.stats.circuitDefinition.colIsMeasuredMask(col) >> row) & ((1 << args.gate.height) - 1)) !== 0;
-    if (isIncoherent) {
-        err = 'incoherent';
-    } else if (measured) {
+    if (measured && indicatorAlpha > 0.9) {
         err = args.gate.width <= 2 ? '(w/ measure defer)' : '(assuming measurement deferred)';
+    } else if (indicatorAlpha < 0.999) {
+        err = 'incoherent';
     }
     if (err !== undefined) {
         args.painter.print(
@@ -409,7 +316,7 @@ function paintErrorIfPresent(args, isIncoherent) {
             args.rect.y+args.rect.h,
             'center',
             'hanging',
-            'red',
+            `rgba(255,0,0,${1-indicatorAlpha})`,
             '12px sans-serif',
             args.rect.w,
             args.rect.h,
@@ -417,6 +324,20 @@ function paintErrorIfPresent(args, isIncoherent) {
     }
 }
 
+/**
+ * @param {!{quality: !number, ket: !Matrix, phaseLockIndex: !int,incoherentKet: !Matrix}} customStats
+ */
+function customStatsToJsonData(customStats) {
+    let {quality, ket, phaseLockIndex, incoherentKet} = customStats;
+    let n = ket.width() * ket.height();
+    return {
+        coherence_measure: quality,
+        superposition_phase_locked_state_index: phaseLockIndex === undefined ? null : phaseLockIndex,
+        ket: complexVectorToReadableJson(new Matrix(1, n, ket.rawBuffer()).getColumn(0)),
+        incoherentKet: realVectorToReadableJson(new Matrix(1, n, incoherentKet.rawBuffer()).getColumn(0))
+    };
+}
+
 let AmplitudeDisplayFamily = Gate.buildFamily(1, 16, (span, builder) => builder.
     setSerializedId("Amps" + span).
     setSymbol("Amps").
@@ -426,18 +347,22 @@ let AmplitudeDisplayFamily = Gate.buildFamily(1, 16, (span, builder) => builder.
     promiseHasNoNetEffectOnStateVector().
     setExtraDisableReasonFinder(args => args.isNested ? "can't\nnest\ndisplays\n(sorry)" : undefined).
     setStatTexturesMaker(ctx =>
-        amplitudeDisplayStatTextures(ctx.stateTrader.currentTexture, ctx.controls, ctx.row, span)).
+        amplitudeDisplayStatTextures(
+            ctx.stateTrader.currentTexture,
+            ctx.controls,
+            ctx.controlsTexture,
+            ctx.row,
+            span)).
     setStatPixelDataPostProcessor((val, def) => processOutputs(span, val, def)).
+    setProcessedStatsToJsonFunc(customStatsToJsonData).
     setDrawer(AMPLITUDE_DRAWER_FROM_CUSTOM_STATS));
 
 export {
     AmplitudeDisplayFamily,
-    amplitudesToPolarKets,
-    convertAwayFromPolar,
+    AMPS_TO_SQUARED_MAGS_SHADER,
+    MAGS_TO_INDEXED_MAGS_SHADER,
+    FOLD_MAX_INDEXED_MAG_SHADER,
+    LOOKUP_KET_AT_INDEXED_MAG_SHADER,
+    POINTWISE_CMUL_CONJ_SHADER,
     amplitudeDisplayStatTextures,
-    reduceToLongestPolarKet,
-    foldConsistentRatios,
-    spreadLengthAcrossPolarKets,
-    signallingSumAll,
-    toRatiosVsRepresentative
 };
diff --git a/src/gates/Controls.js b/src/gates/Controls.js
index edd41b4b..20fb018b 100644
--- a/src/gates/Controls.js
+++ b/src/gates/Controls.js
@@ -26,6 +26,7 @@ Controls.Control = new GateBuilder().
     setBlurb("Conditions on a qubit being ON.\nGates in the same column only apply to states meeting the condition.").
     promiseHasNoNetEffectOnStateVector().
     markAsControlExpecting(true).
+    promiseEffectIsUnitary().
     setDrawer(args => {
         if (args.isInToolbox || args.isHighlighted) {
             GatePainting.paintBackground(args);
@@ -41,6 +42,7 @@ Controls.AntiControl = new GateBuilder().
     setBlurb("Conditions on a qubit being OFF.\nGates in the same column only apply to states meeting the condition.").
     promiseHasNoNetEffectOnStateVector().
     markAsControlExpecting(false).
+    promiseEffectIsUnitary().
     setDrawer(args => {
         if (args.isInToolbox || args.isHighlighted) {
             GatePainting.paintBackground(args);
@@ -64,6 +66,7 @@ Controls.XAntiControl = new GateBuilder().
         HalfTurnGates.H.customOperation).
     setActualEffectToUpdateFunc(() => {}).
     promiseEffectIsStable().
+    promiseEffectIsUnitary().
     setDrawer(args => {
         if (args.isInToolbox || args.isHighlighted) {
             GatePainting.paintBackground(args);
@@ -88,6 +91,7 @@ Controls.XControl = new GateBuilder().
         HalfTurnGates.H.customOperation).
     setActualEffectToUpdateFunc(() => {}).
     promiseEffectIsStable().
+    promiseEffectIsUnitary().
     setDrawer(args => {
         if (args.isInToolbox || args.isHighlighted) {
             GatePainting.paintBackground(args);
@@ -113,6 +117,7 @@ Controls.YAntiControl = new GateBuilder().
         ctx => GateShaders.applyMatrixOperation(ctx, QuarterTurnGates.SqrtXBackward._knownMatrix)).
     setActualEffectToUpdateFunc(() => {}).
     promiseEffectIsStable().
+    promiseEffectIsUnitary().
     setDrawer(args => {
         if (args.isInToolbox || args.isHighlighted) {
             GatePainting.paintBackground(args);
@@ -141,6 +146,7 @@ Controls.YControl = new GateBuilder().
         ctx => GateShaders.applyMatrixOperation(ctx, QuarterTurnGates.SqrtXBackward._knownMatrix)).
     setActualEffectToUpdateFunc(() => {}).
     promiseEffectIsStable().
+    promiseEffectIsUnitary().
     setDrawer(ctx => {
         if (ctx.isInToolbox || ctx.isHighlighted) {
             GatePainting.paintBackground(ctx);
diff --git a/src/gates/DensityMatrixDisplay.js b/src/gates/DensityMatrixDisplay.js
index 13177556..9bba9214 100644
--- a/src/gates/DensityMatrixDisplay.js
+++ b/src/gates/DensityMatrixDisplay.js
@@ -144,7 +144,7 @@ function densityPixelsToMatrix(pixels, circuitDefinition, col, row) {
     }
 
     let isMeasuredMask = circuitDefinition.colIsMeasuredMask(col) >> row;
-    return decohereMeasuredBitsInDensityMatrix(new Matrix(d, d, pixels), isMeasuredMask);
+    return decohereMeasuredBitsInDensityMatrix(new Matrix(d, d, pixels), isMeasuredMask).transpose();
 }
 
 /**
@@ -186,6 +186,9 @@ function largeDensityMatrixDisplayMaker(span, builder) {
         setSerializedId("Density" + span).
         setWidth(span).
         setDrawer(DENSITY_MATRIX_DRAWER_FROM_CUSTOM_STATS).
+        setProcessedStatsToJsonFunc(data => {
+            return {density_matrix: data.toReadableJson()};
+        }).
         setStatTexturesMaker(ctx => densityDisplayStatTexture(
             ctx.stateTrader.currentTexture, ctx.wireCount, ctx.controls, ctx.row, span)).
         setStatPixelDataPostProcessor(densityPixelsToMatrix);
diff --git a/src/gates/Detector.js b/src/gates/Detector.js
index cb4b5991..857a7926 100644
--- a/src/gates/Detector.js
+++ b/src/gates/Detector.js
@@ -24,6 +24,12 @@ import {WglArg} from 'src/webgl/WglArg.js';
 import {Config} from 'src/Config.js'
 import {GatePainting} from 'src/draw/GatePainting.js'
 import {makePseudoShaderWithInputsAndOutputAndCode, Outputs} from 'src/webgl/ShaderCoders.js';
+import {Matrix} from "src/math/Matrix.js";
+import {GateShaders} from "src/circuit/GateShaders.js";
+import {Point} from "src/math/Point.js";
+import {DetailedError} from "src/base/DetailedError.js";
+import {QuarterTurnGates} from "src/gates/QuarterTurnGates.js";
+import {HalfTurnGates} from "src/gates/HalfTurnGates.js";
 
 /**
  * @param {!CircuitEvalContext} ctx
@@ -94,10 +100,39 @@ let detectorShader = makePseudoShaderWithInputsAndOutputAndCode(
             float detectChance = read_detection_weight(0.0) / read_total_weight(0.0);
             float detection_type = float(rnd < detectChance);
             float own_type = read_classification(k);
-            return read_ket(k) * float(detection_type == own_type);
+            if (detection_type == own_type) {
+                float matchChance = detectChance * own_type + (1.0 - own_type) * (1.0 - detectChance);
+                return read_ket(k) / sqrt(matchChance);
+            } else {
+                return vec2(0.0, 0.0);
+            }
         }
     `);
 
+/**
+ * @param {!CircuitEvalContext} ctx
+ * @param {!string} axis
+ * @param {!boolean} inverse
+ */
+function switchToBasis(ctx, axis, inverse) {
+    switch (axis) {
+        case 'X':
+            GateShaders.applyMatrixOperation(ctx, HalfTurnGates.H.knownMatrixAt(0));
+            break;
+        case 'Y':
+            if (inverse) {
+                GateShaders.applyMatrixOperation(ctx, QuarterTurnGates.SqrtXBackward.knownMatrixAt(0));
+            } else {
+                GateShaders.applyMatrixOperation(ctx, QuarterTurnGates.SqrtXForward.knownMatrixAt(0));
+            }
+            break;
+        case 'Z':
+            break; // Already in the right basis.
+        default:
+            throw new DetailedError('Unrecognized axis.', {axis});
+    }
+
+}
 /**
  * Applies a sample measurement operation to the state.
  * @param {!CircuitEvalContext} ctx
@@ -123,19 +158,35 @@ function sampleMeasure(ctx) {
 
 /**
  * @param {!GateDrawParams} args
+ * @param {!string} axis
  */
-function drawDetector(args) {
-    // Draw framing.
+function drawDetector(args, axis) {
+    drawHighlight(args);
+    drawWedge(args, axis);
+    drawClick(args, axis);
+}
+
+/**
+ * @param {!GateDrawParams} args
+ */
+function drawHighlight(args) {
+    // Can't use the typical highlight function because the detector has no box outline.
     if (args.isHighlighted || args.isInToolbox) {
         args.painter.fillRect(
             args.rect,
-            args.isHighlighted ? Config.HIGHLIGHTED_GATE_FILL_COLOR : Config.TIME_DEPENDENT_HIGHLIGHT_COLOR);
+            args.isHighlighted ? Config.HIGHLIGHTED_GATE_FILL_COLOR : Config.GATE_FILL_COLOR);
         GatePainting.paintOutline(args);
     }
+}
 
+/**
+ * @param {!GateDrawParams} args
+ * @param {!string} axis
+ */
+function drawWedge(args, axis) {
     // Draw semi-circle wedge.
     const τ = Math.PI * 2;
-    let r = args.rect.w*0.4;
+    let r = Math.min(args.rect.h / 2, args.rect.w) - 1;
     let {x, y} = args.rect.center();
     x -= r*0.5;
     x += 0.5;
@@ -144,42 +195,247 @@ function drawDetector(args) {
         trace.ctx.arc(x, y, r, τ*3/4, τ/4);
         trace.ctx.lineTo(x, y - r - 1);
     }).thenStroke('black', 2).thenFill(Config.TIME_DEPENDENT_HIGHLIGHT_COLOR);
+    args.painter.printLine(axis, args.rect, 0.5, undefined, undefined, undefined, 0.5);
+}
 
+/**
+ * @param {!GateDrawParams} args
+ * @param {undefined|!string} axis
+ */
+function drawClick(args, axis) {
     // Draw tilted "*click*" text.
     let clicked = args.customStats;
-    if (clicked) {
-        args.painter.ctx.save();
-        args.painter.ctx.translate(args.rect.center().x, args.rect.center().y);
-        args.painter.ctx.rotate(τ/8);
-        args.painter.ctx.strokeStyle = 'white';
-        args.painter.ctx.lineWidth = 2;
+    if (!clicked) {
+        return;
+}
+    let r = Math.min(args.rect.h / 2, args.rect.w);
+    args.painter.ctx.save();
+    args.painter.ctx.translate(args.rect.center().x, args.rect.center().y);
+    args.painter.ctx.rotate(axis === undefined ? Math.PI/3 : Math.PI/4);
+    args.painter.ctx.strokeStyle = 'white';
+    args.painter.ctx.lineWidth = 3;
+    args.painter.print(
+        '*click*',
+        0,
+        axis === undefined ? 0 : -5,
+        'center',
+        'middle',
+        'black',
+        'bold 16px sans-serif',
+        r*2.8,
+        r*2.8,
+        undefined,
+        true);
+
+    if (axis !== undefined) {
         args.painter.print(
-            '*click*',
-            0,
+            axis,
             0,
+            10,
             'center',
             'middle',
             'black',
             'bold 16px sans-serif',
-            args.rect.w*1.4,
-            args.rect.h*1.4,
+            r * 2.8,
+            r * 2.8,
             undefined,
             true);
-        args.painter.ctx.restore();
     }
+    args.painter.ctx.restore();
+}
+
+/**
+ * @param {!GateDrawParams} args
+ * @param {!string} axis
+ */
+function drawControlBulb(args, axis) {
+    redrawControlWires(args);
+    let p = args.rect.center();
+    switch (axis) {
+        case 'X':
+            args.painter.fillCircle(p, 5);
+            args.painter.strokeCircle(p, 5);
+            args.painter.strokeLine(p.offsetBy(0, -5), p.offsetBy(0, +5));
+            args.painter.strokeLine(p.offsetBy(-5, 0), p.offsetBy(+5, 0));
+            break;
+        case 'Y':
+            args.painter.fillCircle(p, 5);
+            args.painter.strokeCircle(p, 5);
+            let r = 5*Math.sqrt(0.5)*1.1;
+            args.painter.strokeLine(p.offsetBy(+r, -r), p.offsetBy(-r, +r));
+            args.painter.strokeLine(p.offsetBy(-r, -r), p.offsetBy(+r, +r));
+            break;
+        case 'Z':
+            args.painter.fillCircle(p, 5, "black");
+            break;
+        default:
+            throw new DetailedError('Unrecognized axis.', {axis});
+    }
+}
+
+/**
+ * @param {!GateDrawParams} args
+ * @param {!string} axis
+ */
+function drawDetectClearReset(args, axis) {
+    let fullRect = args.rect;
+    let detectorRect = fullRect.leftHalf();
+    let resetRect = fullRect.rightHalf();
+
+    // Draw background.
+    let clearWireRect = fullRect.rightHalf();
+    clearWireRect.y += clearWireRect.h / 2 - 2;
+    clearWireRect.h = 5;
+    args.painter.fillRect(clearWireRect, 'white');
+    drawHighlight(args);
+
+    // Draw text elements.
+    args.painter.printLine('|0⟩', resetRect, 1, undefined, undefined, undefined, 0.5);
+
+    // Draw detector.
+    args.rect = detectorRect;
+    drawWedge(args, axis);
+
+    args.rect = fullRect;
+    drawControlBulb(args, axis);
+    args.rect = detectorRect;
+    drawClick(args, undefined);
+
+    args.rect = fullRect;
+}
+
+/**
+ * @param {!GateDrawParams} args
+ */
+function redrawControlWires(args) {
+    if (args.positionInCircuit === undefined || args.isHighlighted) {
+        return;
+    }
+    let painter = args.painter;
+    let columnIndex = args.positionInCircuit.col;
+    let x = Math.round(args.rect.center().x - 0.5) + 0.5;
+
+    // Dashed line indicates effects from non-unitary gates may affect, or appear to affect, other wires.
+    let circuit = args.stats.circuitDefinition;
+    if (circuit.columns[columnIndex].hasGatesWithGlobalEffects()) {
+        painter.ctx.save();
+        painter.ctx.setLineDash([1, 4]);
+        painter.strokeLine(new Point(x, args.rect.y), new Point(x, args.rect.bottom()));
+        painter.ctx.restore();
+    }
+
+    let row = args.positionInCircuit.row;
+    for (let {first, last, measured} of circuit.controlLinesRanges(columnIndex)) {
+        if (first <= row && row <= last) {
+            let y1 = first === row ? args.rect.center().y : args.rect.y;
+            let y2 = last === row ? args.rect.center().y : args.rect.bottom();
+            if (measured) {
+                painter.strokeLine(new Point(x + 1, y1), new Point(x + 1, y2));
+                painter.strokeLine(new Point(x - 1, y1), new Point(x - 1, y2));
+            } else {
+                painter.strokeLine(new Point(x, y1), new Point(x, y2));
+            }
+        }
+    }
+}
+
+/**
+ * @param {!function(!CircuitEvalContext) : T} func
+ * @returns {!function(!CircuitEvalContext) : T}
+ * @template T
+ */
+function withClearedControls(func) {
+    return ctx => {
+        let controls = ctx.controls;
+        let texture = ctx.controlsTexture;
+        try {
+            ctx.controls = Controls.NONE;
+            ctx.controlsTexture = controlMaskTex(ctx, ctx.controls);
+            return func(ctx);
+        } finally {
+            ctx.controlsTexture.deallocByDepositingInPool('withClearedControls');
+            ctx.controlsTexture = texture;
+            ctx.controls = controls;
+        }
+    };
+}
+
+/**
+ * @param {!string} axis
+ * @returns {!Gate}
+ */
+function makeDetectControlClearGate(axis) {
+    let builder = new GateBuilder().
+        setSerializedIdAndSymbol(`${axis}DetectControlReset`).
+        setTitle(`${axis} Detect-Control-Reset`).
+        setBlurb(`Does a collapsing ${axis}-axis measurement.\nControls operations with the result.\nResets the target to |0⟩.`).
+        setDrawer(args => drawDetectClearReset(args, axis)).
+        markAsControlExpecting(true, true).
+        markAsReachingOtherWires().
+        setActualEffectToUpdateFunc(() => {}).
+        setStatTexturesMaker(withClearedControls(detectorStatTexture)).
+        setSetupCleanupEffectToUpdateFunc(
+            withClearedControls(ctx => {
+                switchToBasis(ctx, axis, false);
+                sampleMeasure(ctx);
+            }),
+            withClearedControls(ctx => {
+                GateShaders.applyMatrixOperation(ctx, Matrix.square(1, 1, 0, 0));
+            })).
+        setStatPixelDataPostProcessor((pixels, circuit, row, col) => pixels[0] > 0);
+    if (axis === 'Z') {
+        builder.promiseEffectIsDiagonal();
+    }
+    return builder.gate;
 }
 
-let Detector = new GateBuilder().
-    setSerializedIdAndSymbol('Detector').
-    setTitle('Detector').
-    setBlurb('Makes a *click* when the target qubit is ON and all controls are satisfied.\n' +
-             'Measures whether to click, samples the result, then post-selects on it.').
-    setDrawer(drawDetector).
-    promiseEffectIsDiagonal().
-    markAsReachingOtherWires().
-    setActualEffectToUpdateFunc(sampleMeasure).
-    setStatTexturesMaker(detectorStatTexture).
-    setStatPixelDataPostProcessor((pixels, circuit, row, col) => pixels[0] > 0).
-    gate;
-
-export {Detector}
+/**
+ * @param {!string} axis
+ * @returns {!Gate}
+ */
+function makeDetector(axis) {
+    let state = new Map([
+        ['X', '|0⟩-|1⟩'],
+        ['Y', '|0⟩+i|1⟩'],
+        ['Z', '|0⟩'],
+    ]).get(axis);
+    let builder = new GateBuilder().
+        setSerializedIdAndSymbol(`${axis}Detector`).
+        setTitle(`${axis} Axis Detector`).
+        setBlurb(
+            `Collapsing ${axis}-axis measurement.\n` +
+            `Shows *click* when the target qubit is ${state} and controls are satisfied.`).
+        setDrawer(args => drawDetector(args, axis)).
+        markAsReachingOtherWires().
+        setSetupCleanupEffectToUpdateFunc(
+            ctx => switchToBasis(ctx, axis, false),
+            ctx => switchToBasis(ctx, axis, true)).
+        setActualEffectToUpdateFunc(sampleMeasure).
+        setStatTexturesMaker(detectorStatTexture).
+        setStatPixelDataPostProcessor((pixels, circuit, row, col) => pixels[0] > 0);
+    if (axis === 'Z') {
+        builder.promiseEffectIsDiagonal();
+    }
+    return builder.gate;
+}
+
+let Detectors = {};
+
+Detectors.XDetector = makeDetector('X');
+Detectors.YDetector = makeDetector('Y');
+Detectors.ZDetector = makeDetector('Z');
+
+Detectors.XDetectControlClear = makeDetectControlClearGate('X');
+Detectors.YDetectControlClear = makeDetectControlClearGate('Y');
+Detectors.ZDetectControlClear = makeDetectControlClearGate('Z');
+
+Detectors.all = [
+    Detectors.XDetector,
+    Detectors.YDetector,
+    Detectors.ZDetector,
+    Detectors.XDetectControlClear,
+    Detectors.YDetectControlClear,
+    Detectors.ZDetectControlClear,
+];
+
+export {Detectors}
diff --git a/src/gates/Joke_ImaginaryGate.js b/src/gates/Joke_ImaginaryGate.js
new file mode 100644
index 00000000..b473c04b
--- /dev/null
+++ b/src/gates/Joke_ImaginaryGate.js
@@ -0,0 +1,31 @@
+// Copyright 2017 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import {GateBuilder} from "src/circuit/Gate.js"
+import {Matrix} from "src/math/Matrix.js"
+import {Complex} from "src/math/Complex.js"
+import {GatePainting} from "src/draw/GatePainting.js"
+
+const ImaginaryGate = new GateBuilder().
+    setSerializedIdAndSymbol("i").
+    setTitle("Imaginary Gate").
+    setBlurb("Phases everything by i.").
+    setDrawer(args => {
+        GatePainting.paintLocationIndependentFrame(args);
+        GatePainting.paintGateSymbol(args);
+    }).
+    setKnownEffectToMatrix(Matrix.square(Complex.I, 0, 0, Complex.I)).
+    gate;
+
+export {ImaginaryGate}
diff --git a/src/gates/Joke_ZeroGate.js b/src/gates/Joke_ZeroGate.js
index 5b099897..e5b47bb0 100644
--- a/src/gates/Joke_ZeroGate.js
+++ b/src/gates/Joke_ZeroGate.js
@@ -19,7 +19,7 @@ import {Matrix} from "src/math/Matrix.js"
 /** @type {!Gate} */
 const ZeroGate = new GateBuilder().
     setSerializedIdAndSymbol("0").
-    setTitle("Zero Gate").
+    setTitle("Nothing Gate").
     setBlurb("Destroys the universe.").
     setDrawer(GatePainting.makeLocationIndependentGateDrawer('#666')).
     setKnownEffectToMatrix(Matrix.square(0, 0, 0, 0)).
diff --git a/src/gates/ModularAdditionGates.js b/src/gates/ModularAdditionGates.js
index 18b84098..29248570 100644
--- a/src/gates/ModularAdditionGates.js
+++ b/src/gates/ModularAdditionGates.js
@@ -33,16 +33,8 @@ const MODULAR_ADDITION_SHADER = ketShaderPermute(
         }
         float d = read_input_A();
         d *= factor;
-        d = mod(d, r);
-        float result = mod(out_id + r - d, r);
-
-        // Despite sanity, I consistently get result=33 instead of result=0 when out_id=0, d=0, r=33.
-        // HACK: Fix it by hand.
-        if (result >= r) {
-            result -= r;
-        }
-
-        return result;
+        d = floor(mod(d + 0.5, r));
+        return floor(mod(out_id + r - d + 0.5, r));
     `);
 
 ModularAdditionGates.PlusAModRFamily = Gate.buildFamily(1, 16, (span, builder) => builder.
diff --git a/src/gates/ModularMultiplicationGates.js b/src/gates/ModularMultiplicationGates.js
index 239aeacc..8e40a068 100644
--- a/src/gates/ModularMultiplicationGates.js
+++ b/src/gates/ModularMultiplicationGates.js
@@ -50,7 +50,7 @@ const MODULAR_INVERSE_SHADER_CODE = `
         if (r.y != 1.0) {
             return -1.0;
         }
-        return mod(mod(s.y, modulus) + modulus, modulus);
+        return floor(mod(floor(mod(s.y + 0.5, modulus)) + modulus + 0.5, modulus));
     }
 `;
 
@@ -70,7 +70,7 @@ const POW_MOD_SHADER_CODE = `
 
         float f = 1.0;
         for (int k = 0; k < ${Config.MAX_WIRE_COUNT}; k++) {
-            if (mod(exponent, 2.0) == 1.0) {
+            if (floor(mod(exponent + 0.5, 2.0)) == 1.0) {
                 exponent -= 1.0;
                 f = big_mul_mod(f, base, modulus);
             }
@@ -169,7 +169,7 @@ const MODULAR_MULTIPLICATION_SHADER = ketShaderPermute(
     `
         float input_a = read_input_A();
         float modulus = read_input_R();
-        input_a = mod(input_a, modulus);
+        input_a = floor(mod(input_a + 0.5, modulus));
         float v = modular_multiplicative_inverse(input_a, modulus);
         if (v == -1.0 || out_id >= modulus) {
             return out_id;
@@ -186,7 +186,7 @@ const MODULAR_INVERSE_MULTIPLICATION_SHADER = ketShaderPermute(
     `
         float input_a = read_input_A();
         float modulus = read_input_R();
-        input_a = mod(input_a, modulus);
+        input_a = floor(mod(input_a + 0.5, modulus));
         if (modular_multiplicative_inverse(input_a, modulus) == -1.0 || out_id >= modulus) {
             return out_id;
         }
diff --git a/src/gates/ModularMultiplyAccumulateGates.js b/src/gates/ModularMultiplyAccumulateGates.js
index 9ea58fc6..0f2b36d8 100644
--- a/src/gates/ModularMultiplyAccumulateGates.js
+++ b/src/gates/ModularMultiplyAccumulateGates.js
@@ -36,7 +36,7 @@ const MODULAR_MULTIPLY_ACCUMULATE_SHADER = ketShaderPermute(
 
         float d = big_mul_mod(factor * a, b, r);
 
-        float in_id = mod(out_id - d, r);
+        float in_id = floor(mod(out_id - d + 0.5, r));
         if (in_id < 0.0) {
             in_id += r;
         }
diff --git a/src/gates/MultiplyAccumulateGates.js b/src/gates/MultiplyAccumulateGates.js
index 933739b1..5bb9c486 100644
--- a/src/gates/MultiplyAccumulateGates.js
+++ b/src/gates/MultiplyAccumulateGates.js
@@ -44,10 +44,10 @@ const BIG_MUL_MOD_SHADER_CODE = `
         float t = 0.0;
         float r;
         for (int k = 0; k < ${Math.ceil(Config.MAX_WIRE_COUNT/MUL_STEP)}; k++) {
-            r = mod(f, ${1<<MUL_STEP}.0);
+            r = floor(mod(f + 0.5, ${1<<MUL_STEP}.0));
             f -= r;
-            t = mod(t + b*r, modulus);
-            b = mod(b * ${1<<MUL_STEP}.0, modulus);
+            t = floor(mod(t + b*r + 0.5, modulus));
+            b = floor(mod(b * ${1<<MUL_STEP}.0 + 0.5, modulus));
             f /= ${1<<MUL_STEP}.0;
         }
         return t;
@@ -64,7 +64,7 @@ const MULTIPLY_ACCUMULATE_SHADER = ketShaderPermute(
     `
         float d1 = read_input_A();
         float d2 = read_input_B();
-        float d = mod(big_mul_mod(d1, d2, span)*factor, span);
+        float d = floor(mod(big_mul_mod(d1, d2, span)*factor + 0.5, span));
         return mod(out_id + span - d, span);`);
 
 MultiplyAccumulateGates.Legacy_MultiplyAddFamily = Gate.buildFamily(3, 16, (span, builder) => builder.
diff --git a/src/gates/ProbabilityDisplay.js b/src/gates/ProbabilityDisplay.js
index 35b7875a..3c15c11e 100644
--- a/src/gates/ProbabilityDisplay.js
+++ b/src/gates/ProbabilityDisplay.js
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import {Complex} from "src/math/Complex.js"
 import {Config} from "src/Config.js"
 import {Gate} from "src/circuit/Gate.js"
 import {GatePainting} from "src/draw/GatePainting.js"
@@ -20,6 +21,7 @@ import {MathPainter} from "src/draw/MathPainter.js"
 import {Matrix} from "src/math/Matrix.js"
 import {Point} from "src/math/Point.js"
 import {Rect} from "src/math/Rect.js"
+import {Seq} from "src/base/Seq.js"
 import {Shaders} from "src/webgl/Shaders.js"
 import {Util} from "src/base/Util.js"
 import {WglConfiguredShader} from "src/webgl/WglConfiguredShader.js"
@@ -98,6 +100,20 @@ function probabilityPixelsToColumnVector(pixels, span) {
     return new Matrix(1, n, buf);
 }
 
+/**
+ * @param {!Matrix} data
+ * @returns {!{probabilities: !float[]}}
+ */
+function probabilityDataToJson(data) {
+    return {
+        probabilities: Seq.range(data.height()).map(k => Complex.realPartOf(data.cell(0, k))).toArray()
+    };
+}
+
+/**
+ * @param {!GateDrawParams} args
+ * @private
+ */
 function _paintMultiProbabilityDisplay_grid(args) {
     let {painter, rect: {x, y, w, h}} = args;
     let n = 1 << args.gate.height;
@@ -258,6 +274,7 @@ function multiChanceGateMaker(span, builder) {
         setStatTexturesMaker(ctx =>
             probabilityStatTexture(ctx.stateTrader.currentTexture, ctx.controlsTexture, ctx.row, span)).
         setStatPixelDataPostProcessor(pixels => probabilityPixelsToColumnVector(pixels, span)).
+        setProcessedStatsToJsonFunc(probabilityDataToJson).
         setDrawer(GatePainting.makeDisplayDrawer(paintMultiProbabilityDisplay));
 }
 
@@ -288,5 +305,6 @@ export {
     ProbabilityDisplayFamily,
     probabilityStatTexture,
     probabilityPixelsToColumnVector,
-    amplitudesToProbabilities
+    amplitudesToProbabilities,
+    probabilityDataToJson,
 };
diff --git a/src/gates/QuarterTurnGates.js b/src/gates/QuarterTurnGates.js
index cf5b9119..b6aff93e 100644
--- a/src/gates/QuarterTurnGates.js
+++ b/src/gates/QuarterTurnGates.js
@@ -47,17 +47,19 @@ QuarterTurnGates.SqrtYBackward = Gate.fromKnownMatrix(
 
 /** @type {!Gate} */
 QuarterTurnGates.SqrtZForward = Gate.fromKnownMatrix(
-    "Z^½",
+    "S",
     Matrix.fromPauliRotation(0, 0, 0.25),
     "√Z Gate",
-    "Principle square root of Z.\nAlso known as the 'S' gate.");
+    "Principle square root of Z.\nAlso known as the 'S' gate.",
+    "Z^½");
 
 /** @type {!Gate} */
 QuarterTurnGates.SqrtZBackward = Gate.fromKnownMatrix(
-    "Z^-½",
+    "S^-1",
     Matrix.fromPauliRotation(0, 0, 0.75),
     "Z^-½ Gate",
-    "Adjoint square root of Z.");
+    "Adjoint square root of Z.",
+    "Z^-½");
 
 QuarterTurnGates.all = [
     QuarterTurnGates.SqrtXForward,
diff --git a/src/gates/SampleDisplay.js b/src/gates/SampleDisplay.js
index da2a86a5..8a961370 100644
--- a/src/gates/SampleDisplay.js
+++ b/src/gates/SampleDisplay.js
@@ -19,7 +19,11 @@ import {MathPainter} from "src/draw/MathPainter.js"
 import {Point} from "src/math/Point.js"
 import {Rect} from "src/math/Rect.js"
 import {Util} from "src/base/Util.js"
-import {probabilityStatTexture, probabilityPixelsToColumnVector} from "src/gates/ProbabilityDisplay.js"
+import {
+    probabilityStatTexture,
+    probabilityPixelsToColumnVector,
+    probabilityDataToJson
+} from "src/gates/ProbabilityDisplay.js"
 
 /**
  * @param {!GateDrawParams} args
@@ -106,6 +110,7 @@ let SampleDisplayFamily = Gate.buildFamily(1, 16, (span, builder) => builder.
         probabilityStatTexture(ctx.stateTrader.currentTexture, ctx.controlsTexture, ctx.row, span)).
     setStatPixelDataPostProcessor(e => probabilityPixelsToColumnVector(e, span)).
     promiseHasNoNetEffectOnStateVectorButStillRequiresDynamicRedraw().
+    setProcessedStatsToJsonFunc(probabilityDataToJson).
     setDrawer(GatePainting.makeDisplayDrawer(paintSampleDisplay)).
     setExtraDisableReasonFinder(args => args.isNested ? "can't\nnest\ndisplays\n(sorry)" : undefined));
 
diff --git a/src/gates/VariousZGates.js b/src/gates/VariousZGates.js
index 6ff37702..9163255c 100644
--- a/src/gates/VariousZGates.js
+++ b/src/gates/VariousZGates.js
@@ -28,15 +28,17 @@ VariousZGates.Z3i = Gate.fromKnownMatrix(
     "Z^-⅓ Gate",
     "Adjoint third root of Z.");
 VariousZGates.Z4 = Gate.fromKnownMatrix(
-    "Z^¼",
+    "T",
     Matrix.fromPauliRotation(0, 0, 1 / 8),
     "Z^¼ Gate",
-    "Principle fourth root of Z.\nAlso known as the 'T' gate.");
+    "Principle fourth root of Z.",
+    "Z^¼");
 VariousZGates.Z4i = Gate.fromKnownMatrix(
-    "Z^-¼",
+    "T^-1",
     Matrix.fromPauliRotation(0, 0, -1 / 8),
     "Z^-¼ Gate",
-    "Adjoint fourth root of Z.");
+    "Adjoint fourth root of Z.",
+    "Z^-¼");
 VariousZGates.Z8 = Gate.fromKnownMatrix(
     "Z^⅛",
     Matrix.fromPauliRotation(0, 0, 1 / 16),
diff --git a/src/main.js b/src/main.js
index bdb556d3..945f7b71 100644
--- a/src/main.js
+++ b/src/main.js
@@ -19,6 +19,7 @@ hookErrorHandler();
 import {doDetectIssues} from "src/issues.js"
 doDetectIssues();
 
+import {CircuitStats} from "src/circuit/CircuitStats.js"
 import {CooldownThrottle} from "src/base/CooldownThrottle.js"
 import {Config} from "src/Config.js"
 import {DisplayedInspector} from "src/ui/DisplayedInspector.js"
@@ -79,6 +80,7 @@ const inspectorDiv = document.getElementById("inspectorDiv");
 /** @type {ObservableValue.<!DisplayedInspector>} */
 const displayed = new ObservableValue(
     DisplayedInspector.empty(new Rect(0, 0, canvas.clientWidth, canvas.clientHeight)));
+const mostRecentStats = new ObservableValue(CircuitStats.EMPTY);
 /** @type {!Revision} */
 let revision = Revision.startingAt(displayed.get().snapshot());
 
@@ -132,6 +134,7 @@ const redrawNow = () => {
 
     let shown = syncArea(displayed.get()).previewDrop();
     let stats = simulate(shown.displayedCircuit.circuitDefinition);
+    mostRecentStats.set(stats);
 
     let size = desiredCanvasSizeFor(shown);
     canvas.width = size.w;
@@ -160,7 +163,7 @@ let clickDownGateButtonKey = undefined;
 canvasDiv.addEventListener('click', ev => {
     let pt = eventPosRelativeTo(ev, canvasDiv);
     let curInspector = displayed.get();
-    if (curInspector.isHandOverButtonKey() !== clickDownGateButtonKey) {
+    if (curInspector.tryGetHandOverButtonKey() !== clickDownGateButtonKey) {
         return;
     }
     let clicked = syncArea(curInspector.withHand(curInspector.hand.withPos(pt))).tryClick();
@@ -179,7 +182,7 @@ watchDrags(canvasDiv,
         let oldInspector = displayed.get();
         let newHand = oldInspector.hand.withPos(pt);
         let newInspector = syncArea(oldInspector.withHand(newHand));
-        clickDownGateButtonKey = newInspector.isHandOverButtonKey();
+        clickDownGateButtonKey = ev.ctrlKey ? undefined : newInspector.tryGetHandOverButtonKey();
         if (clickDownGateButtonKey !== undefined) {
             displayed.set(newInspector);
             return;
@@ -275,7 +278,7 @@ canvasDiv.addEventListener('mouseleave', () => {
 
 let obsIsAnyOverlayShowing = new ObservableSource();
 initUrlCircuitSync(revision);
-initExports(revision, obsIsAnyOverlayShowing.observable());
+initExports(revision, mostRecentStats, obsIsAnyOverlayShowing.observable());
 initForge(revision, obsIsAnyOverlayShowing.observable());
 initUndoRedo(revision, obsIsAnyOverlayShowing.observable());
 initClear(revision, obsIsAnyOverlayShowing.observable());
diff --git a/src/math/Matrix.js b/src/math/Matrix.js
index 9eefeac6..5e3812ca 100644
--- a/src/math/Matrix.js
+++ b/src/math/Matrix.js
@@ -70,6 +70,13 @@ class Matrix {
         return this._buffer;
     }
 
+    /**
+     * Encodes the matrix into JSON that could easily be read by humans or processed by external programs.
+     * @returns {*}
+     */
+    toReadableJson() {
+        return seq(this.rows()).map(complexVectorToReadableJson).toArray();
+    }
     /**
      * @returns {!Array.<!Array.<Complex>>}
      */
@@ -1343,13 +1350,15 @@ class Matrix {
         // Fix ordering, so that the singular values are ascending.
         let permutation = Seq.range(this._width).sortedBy(i => -S.cell(i, i).norm2()).toArray();
         for (let i = 0; i < S._width; i++) {
-            let j = permutation[i];
+            let j = permutation.indexOf(i);
             if (i !== j) {
                 U._inline_colMix_postMultiply(i, j, Matrix.PAULI_X);
                 V._inline_rowMix_preMultiply(i, j, Matrix.PAULI_X);
-                [S._buffer[i*2], S._buffer[j*2]] = [S._buffer[j*2], S._buffer[i*2]];
-                [S._buffer[i*2+1], S._buffer[j*2+1]] = [S._buffer[j*2+1], S._buffer[i*2+1]];
-                [permutation[j], permutation[i]] = [permutation[i], permutation[j]]
+                let si = i*(S._width + 1)*2;
+                let sj = j*(S._width + 1)*2;
+                [S._buffer[si], S._buffer[sj]] = [S._buffer[sj], S._buffer[si]];
+                [S._buffer[si+1], S._buffer[sj+1]] = [S._buffer[sj+1], S._buffer[si+1]];
+                [permutation[j], permutation[i]] = [permutation[i], permutation[j]];
             }
         }
 
@@ -1365,7 +1374,7 @@ class Matrix {
     }
 
     /**
-     * @param {!int} rowIndex
+     * @param {!int} colIndex
      * @returns {!Array.<!Complex>}
      */
     getColumn(colIndex) {
@@ -1424,4 +1433,22 @@ Matrix.PAULI_Z = Matrix.square(1, 0, 0, -1);
  */
 Matrix.HADAMARD = Matrix.square(1, 1, 1, -1).times(Math.sqrt(0.5));
 
-export {Matrix}
+/**
+ * Encodes a complex vector into JSON that could easily be read by humans or processed by external programs.
+ * @param {!Iterable.<!Complex>} vector
+ * @returns {*}
+ */
+function complexVectorToReadableJson(vector) {
+    return seq(vector).map(e => {return {r: Complex.realPartOf(e), i: Complex.imagPartOf(e)}; }).toArray();
+}
+
+/**
+ * Encodes a real vector into JSON that could easily be read by humans or processed by external programs.
+ * @param {!Iterable.<!Complex>} vector
+ * @returns {*}
+ */
+function realVectorToReadableJson(vector) {
+    return seq(vector).map(Complex.realPartOf).toArray();
+}
+
+export {Matrix, complexVectorToReadableJson, realVectorToReadableJson}
diff --git a/src/ui/DisplayedCircuit.js b/src/ui/DisplayedCircuit.js
index 33a623e0..aa61018d 100644
--- a/src/ui/DisplayedCircuit.js
+++ b/src/ui/DisplayedCircuit.js
@@ -103,6 +103,8 @@ class DisplayedCircuit {
     }
 
     /**
+     * The number of wires that were in the circuit before picking up a gate, or the number that will be in the circuit
+     * after dropping a gate; whichever is larger.
      * @returns {!int}
      * @private
      */
@@ -341,7 +343,7 @@ class DisplayedCircuit {
      */
     paint(painter, hand, stats, forTooltip=false, showWires=true) {
         if (showWires) {
-            this._drawWires(painter, !forTooltip);
+            this._drawWires(painter, !forTooltip, hand);
         }
 
         for (let col = 0; col < this.circuitDefinition.columns.length; col++) {
@@ -352,14 +354,17 @@ class DisplayedCircuit {
             this._drawOutputDisplays(painter, stats, hand);
             this._drawHintLabels(painter, stats);
         }
+
+        this._drawRowDragHighlight(painter);
     }
 
     /**
      * @param {!Painter} painter
      * @param {!boolean} showLabels
+     * @param {!Hand} hand
      * @private
      */
-    _drawWires(painter, showLabels) {
+    _drawWires(painter, showLabels, hand) {
         let drawnWireCount = Math.min(this.circuitDefinition.numWires, (this._extraWireStartIndex || Infinity) + 1);
 
         // Initial value labels
@@ -367,7 +372,16 @@ class DisplayedCircuit {
             for (let row = 0; row < drawnWireCount; row++) {
                 let wireRect = this.wireRect(row);
                 let y = wireRect.center().y;
-                painter.print('|0⟩', 20, y, 'right', 'middle', 'black', '14px sans-serif', 20, Config.WIRE_SPACING);
+                let v = this.circuitDefinition.customInitialValues.get(row);
+                if (v === undefined) {
+                    v = '0';
+                }
+                let rect = this._wireInitialStateClickableRect(row);
+                painter.noteTouchBlocker({rect, cursor: 'pointer'});
+                if (this._highlightedSlot === undefined && hand.pos !== undefined && rect.containsPoint(hand.pos)) {
+                    painter.fillRect(rect, Config.HIGHLIGHTED_GATE_FILL_COLOR);
+                }
+                painter.print(`|${v}⟩`, 20, y, 'right', 'middle', 'black', '14px sans-serif', 20, Config.WIRE_SPACING);
             }
         }
 
@@ -594,14 +608,31 @@ class DisplayedCircuit {
 
     _drawColumnDragHighlight(painter, col) {
         if (this._highlightedSlot !== undefined &&
-                this._highlightedSlot.col === col &&
-                this._highlightedSlot.row === undefined) {
+            this._highlightedSlot.col === col &&
+            this._highlightedSlot.row === undefined) {
             let rect = this.gateRect(0, col, 1, this._groundedWireCount()).paddedBy(3);
             painter.fillRect(rect, 'rgba(255, 196, 112, 0.7)');
             painter.strokeRect(rect, 'black');
         }
     }
 
+    /**
+     * @param {!Painter} painter
+     * @private
+     */
+    _drawRowDragHighlight(painter) {
+        if (this._highlightedSlot !== undefined &&
+                this._highlightedSlot.col === undefined &&
+                this._highlightedSlot.row !== undefined) {
+
+            let row = this._highlightedSlot.row;
+            let w = this.gateRect(row, this.clampedCircuitColCount() + 1).x;
+            let rect = this.wireRect(row).takeLeft(w);
+            painter.fillRect(rect, 'rgba(255, 196, 112, 0.7)');
+            painter.strokeRect(rect, 'black');
+        }
+    }
+
     /**
      * @param {!Painter} painter
      * @param {!int} columnIndex
@@ -637,11 +668,50 @@ class DisplayedCircuit {
      * @returns {!DisplayedCircuit}
      */
     previewDrop(hand) {
-        return hand.heldColumn !== undefined ? this._previewDropMovedGateColumn(hand) :
+        return hand.heldRow !== undefined ? this._previewDropMovedRow(hand) :
+            hand.heldColumn !== undefined ? this._previewDropMovedGateColumn(hand) :
             hand.heldGate !== undefined ? this._previewDropMovedGate(hand) :
             this._previewResizedGate(hand);
     }
 
+    /**
+     * @param {!Hand} hand
+     * @returns {!DisplayedCircuit}
+     * @private
+     */
+    _previewDropMovedRow(hand) {
+        if (hand.pos === undefined) {
+            return this;
+        }
+        let handWire = this.wireIndexAt(hand.pos.y);
+        if (handWire < 0 || handWire >= this.circuitDefinition.numWires) {
+            // Dragged the row out of the circuit.
+            return this;
+        }
+
+        let heldRowHeight = seq(hand.heldRow.gates).map(g => g === undefined ? 1 : g.height).max(1);
+        handWire = Math.min(handWire, this.circuitDefinition.numWires - heldRowHeight);
+
+        let newCols = [];
+        for (let c = 0; c < this.circuitDefinition.columns.length; c++) {
+            let gates = [...this.circuitDefinition.columns[c].gates];
+            gates.splice(handWire, 0, hand.heldRow.gates[c]);
+            gates.pop();
+            newCols.push(new GateColumn(gates));
+        }
+
+        let newInitialStates = seq(this.circuitDefinition.customInitialValues.entries()).
+            map(([k, v]) => [k + (k >= handWire ? 1 : 0), v]).
+            toMap(([k, _]) => k, ([_, v]) => v);
+        if (hand.heldRow.initialState !== undefined) {
+            newInitialStates.set(handWire, hand.heldRow.initialState);
+        }
+        let newCircuitDef = this.circuitDefinition.withColumns(newCols).withInitialStates(newInitialStates);
+
+        return this.withCircuit(newCircuitDef).
+            _withHighlightedSlot({row: handWire, col: undefined, resizeStyle: false});
+    }
+
     /**
      * @param {!Hand} hand
      * @returns {!DisplayedCircuit}
@@ -651,6 +721,13 @@ class DisplayedCircuit {
         if (hand.pos === undefined) {
             return this;
         }
+        let handWire = this.wireIndexAt(hand.pos.y);
+        if (handWire < 0 || handWire >= Config.MAX_WIRE_COUNT || hand.pos.x <= 1) {
+            // Dragged the gate column out of the circuit.
+            return this;
+        }
+
+
         let halfCol = this.findOpHalfColumnAt(new Point(hand.pos.x, this.top));
         let mustInsert = halfCol % 1 === 0 &&
             this.circuitDefinition.columns[halfCol] !== undefined &&
@@ -821,7 +898,7 @@ class DisplayedCircuit {
     }
 
     /**
-     * @param {undefined|!{col: !int, row: undefined|!int, resizeStyle: !boolean}} slot
+     * @param {undefined|!{col: undefined|!int, row: undefined|!int, resizeStyle: !boolean}} slot
      * @returns {!DisplayedCircuit}
      * @private
      */
@@ -921,15 +998,60 @@ class DisplayedCircuit {
         return {col: foundPt.col, row: foundPt.row, gate};
     }
 
+    /**
+     * @param {!int} wire
+     * @returns {!Rect}
+     * @private
+     */
+    _wireInitialStateClickableRect(wire) {
+        let r = this.wireRect(wire);
+        r.x = 0;
+        r.y += 5;
+        r.w = 30;
+        r.h -= 10;
+        return r;
+    }
+
+    /**
+     * @param {!Point} pt
+     * @returns {undefined|!int}
+     */
+    findWireWithInitialStateAreaContaining(pt) {
+        // Is it in the right vertical band; the one at the start of the circuit?
+        if (pt.x < 0 || pt.x > 30) {
+            return undefined;
+        }
+
+        // Which wire is it? Is it one that's actually in the circuit?
+        let wire = this.wireIndexAt(pt.y);
+        if (wire < 0 || wire >= this.circuitDefinition.numWires) {
+            return undefined;
+        }
+
+        // Is it inside the intended click area, instead of just off to the side?
+        let r = this._wireInitialStateClickableRect(wire);
+        if (!r.containsPoint(pt)) {
+            return undefined;
+        }
+
+        // Good to go.
+        return wire;
+    }
+
     /**
      * @param {!Hand} hand
      * @returns {undefined|!DisplayedCircuit}
      */
     tryClick(hand) {
-        if (hand.pos === undefined) {
+        if (hand.pos === undefined || hand.heldGate !== undefined) {
             return undefined;
         }
 
+        let clickedInitialStateWire = this.findWireWithInitialStateAreaContaining(hand.pos);
+        if (clickedInitialStateWire !== undefined) {
+            return this.withCircuit(this.circuitDefinition.withSwitchedInitialStateOn(clickedInitialStateWire))
+        }
+
         let found = this.findGateWithButtonContaining(hand.pos);
         if (found === undefined) {
             return undefined;
@@ -953,6 +1075,10 @@ class DisplayedCircuit {
      */
     tryGrab(hand, duplicate=false, wholeColumn=false, ignoreResizeTabs=false) {
         if (wholeColumn) {
+            let grabRowResult = this._tryGrabRow(hand);
+            if (grabRowResult !== undefined) {
+                return grabRowResult;
+            }
             return this._tryGrabWholeColumn(hand, duplicate) || {newCircuit: this, newHand: hand};
         }
 
@@ -969,6 +1095,61 @@ class DisplayedCircuit {
         return newCircuit._tryGrabGate(newHand, duplicate) || {newCircuit, newHand};
     }
 
+    /**
+     * @param {!Hand} hand
+     * @returns {undefined|!{newCircuit: !DisplayedCircuit, newHand: !Hand}}
+     */
+    _tryGrabRow(hand) {
+        if (hand.pos === undefined) {
+            return undefined;
+        }
+
+        // Which wire is it? Is it one that's actually in the circuit?
+        let wire = this.wireIndexAt(hand.pos.y);
+        if (wire < 0 || wire >= this.circuitDefinition.numWires) {
+            return undefined;
+        }
+
+        // Is it inside the intended click area, instead of just off to the side?
+        let r = this._wireInitialStateClickableRect(wire);
+        if (!r.containsPoint(hand.pos)) {
+            return undefined;
+        }
+
+        let {newCircuit, initialState, rowGates} = this._cutRow(wire);
+        let holdOffset = new Point(0, hand.pos.y - r.y);
+        return {
+            newCircuit: this.withCircuit(newCircuit),
+            newHand: hand.withHeldRow({initialState, gates: rowGates}, holdOffset)
+        };
+    }
+
+    /**
+     * @param {!int} row
+     * @returns {!{newCircuit: !CircuitDefinition, rowGates: !Array.<undefined|!Gate>, initialState: *}}
+     * @private
+     */
+    _cutRow(row) {
+        let row_gates = [];
+        let cols = [];
+        for (let i = 0; i < this.circuitDefinition.columns.length; i++) {
+            let col_gates = [...this.circuitDefinition.columns[i].gates];
+            row_gates.push(col_gates[row]);
+            col_gates.splice(row, 1);
+            col_gates.push(undefined);
+            cols.push(new GateColumn(col_gates));
+        }
+        let newInitialStates = seq(this.circuitDefinition.customInitialValues.entries()).
+            filter(([k, _]) => k !== row).
+            map(([k, v]) => [k - (k > row ? 1 : 0), v]).
+            toMap(([k, _]) => k, ([_, v]) => v);
+        return {
+            newCircuit: this.circuitDefinition.withColumns(cols).withInitialStates(newInitialStates),
+            rowGates: row_gates,
+            initialState: this.circuitDefinition.customInitialValues.get(row)
+        };
+    }
+
     /**
      * @param {!Hand} hand
      * @param {!boolean=} duplicate
@@ -1179,6 +1360,7 @@ class DisplayedCircuit {
 
         let [colWires, rowWires] = [Math.floor(numWire/2), Math.ceil(numWire/2)];
         let [colCount, rowCount] = [1 << colWires, 1 << rowWires];
+        //noinspection JSCheckFunctionSignatures
         return new Matrix(colCount, rowCount, buf);
     }
 
@@ -1436,7 +1618,9 @@ let _cachedRowLabelDrawer = new CachablePainting(
     (painter, numWire) => {
         let [colWires, rowWires] = [Math.floor(numWire/2), Math.ceil(numWire/2)];
         let rowCount = 1 << rowWires;
+        //noinspection JSCheckFunctionSignatures
         let suffix = colWires < 4 ? "_".repeat(colWires) : "_..";
+        //noinspection JSCheckFunctionSignatures
         _drawLabelsReasonablyFast(
             painter,
             painter.canvas.height / rowCount,
@@ -1463,7 +1647,9 @@ let _cachedColLabelDrawer = new CachablePainting(
 
         painter.ctx.translate(colCount*dw, 0);
         painter.ctx.rotate(Math.PI/2);
+        //noinspection JSCheckFunctionSignatures
         let prefix = rowWires < 4 ? "_".repeat(rowWires) : ".._";
+        //noinspection JSCheckFunctionSignatures
         _drawLabelsReasonablyFast(
             painter,
             dw,
diff --git a/src/ui/DisplayedInspector.js b/src/ui/DisplayedInspector.js
index 296166d8..5dde7dec 100644
--- a/src/ui/DisplayedInspector.js
+++ b/src/ui/DisplayedInspector.js
@@ -127,12 +127,19 @@ class DisplayedInspector {
     /**
      * @returns {undefined|!string}
      */
-    isHandOverButtonKey() {
+    tryGetHandOverButtonKey() {
         if (this.hand.pos === undefined) {
             return undefined;
         }
-        let pos = this.displayedCircuit.findGateWithButtonContaining(this.hand.pos);
-        return pos === undefined ? undefined : pos.col + ':' + pos.row;
+        let butBos = this.displayedCircuit.findGateWithButtonContaining(this.hand.pos);
+        if (butBos !== undefined) {
+            return `gate-button-${butBos.col}:${butBos.row}`;
+        }
+        let initPos = this.displayedCircuit.findWireWithInitialStateAreaContaining(this.hand.pos);
+        if (initPos !== undefined) {
+            return `wire-init-${initPos}`;
+        }
+        return undefined;
     }
 
     /**
@@ -306,6 +313,10 @@ class DisplayedInspector {
      * @private
      */
     _watchOutputsChangeVisibility() {
+        if (this.displayedCircuit.circuitDefinition.customInitialValues.size > 0) {
+            return 0;
+        }
+
         let gatesInCircuit = this.displayedCircuit.circuitDefinition.countGatesUpTo(2);
         let gatesInPlay = gatesInCircuit + (this.hand.isBusy() ? 1 : 0);
         if (gatesInCircuit >= 2 || gatesInPlay === 0) {
@@ -413,6 +424,10 @@ class DisplayedInspector {
         let gatesInCircuit = circ.countGatesUpTo(2);
         let gatesInPlay = gatesInCircuit + (this.hand.heldGate !== undefined ? 1 : 0);
 
+        if (circ.customInitialValues.size > 0) {
+            return 0;
+        }
+
         let gate = circ.gateInSlot(0, 0);
         if (circ.hasControls() || !circ.hasNonControlGates() || (gate !== undefined && gate.height > 1)) {
             return 0;
diff --git a/src/ui/DisplayedToolbox.js b/src/ui/DisplayedToolbox.js
index dce22dd7..a87ca07a 100644
--- a/src/ui/DisplayedToolbox.js
+++ b/src/ui/DisplayedToolbox.js
@@ -290,6 +290,7 @@ class DisplayedToolbox {
      */
     static _paintGate(painter, gate, rect, isHighlighted, stats) {
         let drawer = gate.customDrawer || GatePainting.DEFAULT_DRAWER;
+        painter.startIgnoringIncomingTouchBlockers();
         drawer(new GateDrawParams(
             painter,
             true, // inToolbox
@@ -302,6 +303,7 @@ class DisplayedToolbox {
             undefined, // positionInCircuit
             [], // focusPoints
             undefined)); // customStatsForCircuitPos
+        painter.stopIgnoringIncomingTouchBlockers();
     }
 
     /**
diff --git a/src/ui/Hand.js b/src/ui/Hand.js
index ecb38579..351d2937 100644
--- a/src/ui/Hand.js
+++ b/src/ui/Hand.js
@@ -25,26 +25,31 @@ class Hand {
      * @param {undefined|!Gate} heldGate
      * @param {undefined|!Point} holdOffset
      * @param {undefined|!GateColumn} heldColumn
+     * @param {undefined|!{initialState: *, gates: !Array.<undefined|!Gate>}} heldRow
      * @param {undefined|!Point} resizingGateSlot
      */
-    constructor(pos, heldGate, holdOffset, heldColumn, resizingGateSlot) {
+    constructor(pos, heldGate, holdOffset, heldColumn, heldRow, resizingGateSlot) {
+        let args = {pos, heldGate, holdOffset, heldColumn, heldRow, resizingGateSlot};
         if (pos !== undefined && !(pos instanceof Point)) {
-            throw new DetailedError("Bad pos", {pos, heldGate, holdOffset, heldColumn, resizingGateSlot});
+            throw new DetailedError("Bad pos", args);
         }
         if (heldGate !== undefined && !(heldGate instanceof Gate)) {
-            throw new DetailedError("Bad heldGate", {pos, heldGate, holdOffset, heldColumn, resizingGateSlot});
+            throw new DetailedError("Bad heldGate", args);
         }
         if (holdOffset !== undefined && !(holdOffset instanceof Point)) {
-            throw new DetailedError("Bad holdOffset", {pos, heldGate, holdOffset, heldColumn, resizingGateSlot});
+            throw new DetailedError("Bad holdOffset", args);
         }
         if (resizingGateSlot !== undefined && !(resizingGateSlot instanceof Point)) {
-            throw new DetailedError("Bad resizingGateSlot", {pos, heldGate, holdOffset, heldColumn, resizingGateSlot});
+            throw new DetailedError("Bad resizingGateSlot", args);
         }
         if (heldColumn !== undefined && !(heldColumn instanceof GateColumn)) {
-            throw new DetailedError("Bad heldColumn", {pos, heldGate, holdOffset, heldColumn, resizingGateSlot});
+            throw new DetailedError("Bad heldColumn", args);
+        }
+        if (heldRow !== undefined && !Array.isArray(heldRow.gates)) {
+            throw new DetailedError("Bad heldRow", args);
         }
         if (heldGate !== undefined && this.resizingGateSlot !== undefined) {
-            throw new DetailedError("Holding AND resizing", {pos, heldGate, holdOffset, heldColumn, resizingGateSlot});
+            throw new DetailedError("Holding AND resizing", args);
         }
 
         /** @type {undefined|!Point} */
@@ -55,6 +60,8 @@ class Hand {
         this.holdOffset = holdOffset;
         /** @type {undefined|!GateColumn} */
         this.heldColumn = heldColumn;
+        /** @type {undefined|!{initialState: *, gates: !Array.<undefined|!Gate>}} */
+        this.heldRow = heldRow;
         /** @type {undefined|!Point} */
         this.resizingGateSlot = resizingGateSlot;
     }
@@ -74,7 +81,10 @@ class Hand {
      * @returns {!boolean}
      */
     isBusy() {
-        return this.heldGate !== undefined || this.heldColumn !== undefined || this.resizingGateSlot !== undefined;
+        return (this.heldGate !== undefined ||
+            this.heldColumn !== undefined ||
+            this.resizingGateSlot !== undefined ||
+            this.heldRow !== undefined);
     }
 
     /**
@@ -97,6 +107,7 @@ class Hand {
             Util.CUSTOM_IS_EQUAL_TO_EQUALITY(this.holdOffset, other.holdOffset) &&
             Util.CUSTOM_IS_EQUAL_TO_EQUALITY(this.heldGate, other.heldGate) &&
             Util.CUSTOM_IS_EQUAL_TO_EQUALITY(this.heldColumn, other.heldColumn) &&
+            Util.CUSTOM_IS_EQUAL_TO_EQUALITY(this.heldRow, other.heldRow) &&
             Util.CUSTOM_IS_EQUAL_TO_EQUALITY(this.resizingGateSlot, other.resizingGateSlot);
     }
 
@@ -109,6 +120,7 @@ class Hand {
             heldGate: this.heldGate,
             holdOffset: this.holdOffset,
             heldColumn: this.heldColumn,
+            heldRow: this.heldRow,
             resizingGateSlot: this.resizingGateSlot
         })}`;
     }
@@ -118,14 +130,14 @@ class Hand {
      * @returns {!Hand}
      */
     withPos(newPos) {
-        return new Hand(newPos, this.heldGate, this.holdOffset, this.heldColumn, this.resizingGateSlot);
+        return new Hand(newPos, this.heldGate, this.holdOffset, this.heldColumn, this.heldRow, this.resizingGateSlot);
     }
 
     /**
      * @returns {!Hand}
      */
     withDrop() {
-        return new Hand(this.pos, undefined, undefined, undefined, undefined);
+        return new Hand(this.pos, undefined, undefined, undefined, undefined, undefined);
     }
 
     /**
@@ -134,7 +146,7 @@ class Hand {
      * @returns {!Hand}
      */
     withHeldGate(heldGate, heldGateOffset) {
-        return new Hand(this.pos, heldGate, heldGateOffset, undefined, undefined);
+        return new Hand(this.pos, heldGate, heldGateOffset, undefined, undefined, undefined);
     }
 
     /**
@@ -143,7 +155,16 @@ class Hand {
      * @returns {!Hand}
      */
     withHeldGateColumn(heldGateColumn, heldGateOffset) {
-        return new Hand(this.pos, undefined, heldGateOffset, heldGateColumn, undefined);
+        return new Hand(this.pos, undefined, heldGateOffset, heldGateColumn, undefined, undefined);
+    }
+
+    /**
+     * @param {!{initialState: *, gates: !Array.<undefined|!Gate>}} heldRow
+     * @param {!Point} heldGateOffset
+     * @returns {!Hand}
+     */
+    withHeldRow(heldRow, heldGateOffset) {
+        return new Hand(this.pos, undefined, heldGateOffset, undefined, heldRow, undefined);
     }
 
     /**
@@ -152,7 +173,7 @@ class Hand {
      * @returns {!Hand}
      */
     withResizeSlot(resizeSlot, resizeTabOffset) {
-        return new Hand(this.pos, undefined, resizeTabOffset, undefined, resizeSlot);
+        return new Hand(this.pos, undefined, resizeTabOffset, undefined, undefined, resizeSlot);
     }
 
     /**
@@ -161,10 +182,11 @@ class Hand {
     stableDuration() {
         return this.heldGate !== undefined ? this.heldGate.stableDuration() :
             this.heldColumn !== undefined ? this.heldColumn.stableDuration() :
+            this.heldRow !== undefined ? new GateColumn(this.heldRow.gates).stableDuration() :
             Infinity;
     }
 }
 
-Hand.EMPTY = new Hand(undefined, undefined, undefined, undefined, undefined);
+Hand.EMPTY = new Hand(undefined, undefined, undefined, undefined, undefined, undefined);
 
 export {Hand}
diff --git a/src/ui/exports.js b/src/ui/exports.js
index b0fbd63d..14b7bd78 100644
--- a/src/ui/exports.js
+++ b/src/ui/exports.js
@@ -14,6 +14,7 @@
 
 import {Config} from "src/Config.js"
 import {ObservableValue} from "src/base/Obs.js"
+import {Serializer} from "src/circuit/Serializer.js"
 import {selectAndCopyToClipboard} from "src/browser/Clipboard.js"
 import {fromJsonText_CircuitDefinition} from "src/circuit/Serializer.js"
 import {saveFile} from "src/browser/SaveFile.js"
@@ -23,9 +24,10 @@ const obsExportsIsShowing = exportsIsVisible.observable().whenDifferent();
 
 /**
  * @param {!Revision} revision
+ * @param {!ObservableValue.<!CircuitStats>} mostRecentStats
  * @param {!Observable.<!boolean>} obsIsAnyOverlayShowing
  */
-function initExports(revision, obsIsAnyOverlayShowing) {
+function initExports(revision, mostRecentStats, obsIsAnyOverlayShowing) {
     // Show/hide exports overlay.
     (() => {
         const exportButton = /** @type {!HTMLButtonElement} */ document.getElementById('export-button');
@@ -52,9 +54,14 @@ function initExports(revision, obsIsAnyOverlayShowing) {
      * @param {!HTMLButtonElement} button
      * @param {!HTMLElement} contentElement
      * @param {!HTMLElement} resultElement
+     * @param {undefined|!function(): !string} contentMaker
      */
-    const setupButtonElementCopyToClipboard = (button, contentElement, resultElement) =>
+    const setupButtonElementCopyToClipboard = (button, contentElement, resultElement, contentMaker=undefined) =>
         button.addEventListener('click', () => {
+            if (contentMaker !== undefined) {
+                contentElement.innerText = contentMaker();
+            }
+
             //noinspection UnusedCatchParameterJS,EmptyCatchBlockJS
             try {
                 selectAndCopyToClipboard(contentElement);
@@ -100,6 +107,25 @@ function initExports(revision, obsIsAnyOverlayShowing) {
         });
     })();
 
+    // Export final output.
+    (() => {
+        const outputTextElement = /** @type {HTMLPreElement} */ document.getElementById('export-amplitudes-pre');
+        const copyButton = /** @type {HTMLButtonElement} */ document.getElementById('export-amplitudes-button');
+        const copyResultElement = /** @type {HTMLElement} */ document.getElementById('export-amplitudes-result');
+        const excludeAmps = /** @type {HTMLInputElement} */ document.getElementById('export-amplitudes-use-amps');
+        obsIsAnyOverlayShowing.subscribe(_ => {
+            outputTextElement.innerText = '[not generated yet]';
+        });
+        setupButtonElementCopyToClipboard(
+            copyButton,
+            outputTextElement,
+            copyResultElement,
+            () => {
+                let raw = JSON.stringify(mostRecentStats.get().toReadableJson(!excludeAmps.checked), null, ' ');
+                return raw.replace(/{\s*"r": /g, '{"r":').replace(/,\s*"i":\s*([-e\d\.]+)\s*}/g, ',"i":$1}');
+            });
+    })();
+
     // Export offline copy.
     (() => {
         const downloadButton = /** @type {HTMLButtonElement} */ document.getElementById('download-offline-copy-button');
diff --git a/src/ui/menu.js b/src/ui/menu.js
index a6654855..c3646ccf 100644
--- a/src/ui/menu.js
+++ b/src/ui/menu.js
@@ -236,6 +236,38 @@ const shorLink = {
         {"id":"~out","name":"out:","matrix":"{{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}}"}
     ]
 };
+const distillLink = {
+    "cols":[
+        ["H","H","H","H","H"],
+        [1,"Z","Z","Z",1,"⊖"],
+        [1,"Z","Z",1,"Z",1,"⊖"],
+        [1,"Z",1,"Z","Z",1,1,"⊖"],
+        [1,1,"Z","Z","Z",1,1,1,"⊖"],
+        ["Z","Z","Z","Z","Z",1,1,1,1,"⊖"],
+        ["Z",1,1,"Z","Z",1,1,1,1,1,"⊖"],
+        ["Z",1,"Z",1,"Z",1,1,1,1,1,1,"⊖"],
+        ["Z","Z",1,1,"Z",1,1,1,1,1,1,1,"⊖"],
+        ["Z",1,"Z","Z",1,1,1,1,1,1,1,1,1,"⊖"],
+        ["Z","Z",1,"Z",1,1,1,1,1,1,1,1,1,1,"⊖"],
+        ["Z","Z","Z",1,1,1,1,1,1,1,1,1,1,1,1,"⊖"],
+        [1,"Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼","Z^¼"],
+        [1,"H","H","H","H","H","H","H","H","H","H","H","H","H","H","H"],
+        [1,"Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure","Measure"],
+        [1,"X","X","X",1,"•"],
+        [1,"X","X",1,"X",1,"•"],
+        [1,"X",1,"X","X",1,1,"•"],
+        [1,1,"X","X","X",1,1,1,"•"],
+        ["Z","X","X","X","X",1,1,1,1,"•"],
+        ["Z",1,1,"X","X",1,1,1,1,1,"•"],
+        ["Z",1,"X",1,"X",1,1,1,1,1,1,"•"],
+        ["Z","X",1,1,"X",1,1,1,1,1,1,1,"•"],
+        ["Z",1,"X","X",1,1,1,1,1,1,1,1,1,"•"],
+        ["Z","X",1,"X",1,1,1,1,1,1,1,1,1,1,"•"],
+        ["Z","X","X",1,1,1,1,1,1,1,1,1,1,1,1,"•"],
+        ["X","Chance4"],
+        ["Amps1","|0⟩⟨0|","|0⟩⟨0|","|0⟩⟨0|","|0⟩⟨0|"]
+    ]
+};
 
 /**
  * @param {!Revision} revision
@@ -275,6 +307,7 @@ function initMenu(revision, obsIsAnyOverlayShowing) {
     const chshTestAnchor = /** @type {!HTMLAnchorElement} */ document.getElementById('example-chsh-test');
     const qftAnchor = /** @type {!HTMLAnchorElement} */ document.getElementById('example-qft');
     const shorAnchor = /** @type {!HTMLAnchorElement} */ document.getElementById('example-anchor-shor');
+    const distillAnchor = /** @type {!HTMLAnchorElement} */ document.getElementById('example-anchor-distill');
 
     for (let [a, t] of [[groverAnchor, groverLink],
                         [shorAnchor, shorLink],
@@ -284,7 +317,8 @@ function initMenu(revision, obsIsAnyOverlayShowing) {
                         [superdenseCodeAnchor, superdenseCodingLink],
                         [symmetryBreakAnchor, symmetryBreakingLink],
                         [chshTestAnchor, chshTestLink],
-                        [qftAnchor, qftLink]]) {
+                        [qftAnchor, qftLink],
+                        [distillAnchor, distillLink]]) {
         let text = JSON.stringify(t);
         a.href = "#circuit=" + text;
         a.onclick = ev => {
diff --git a/src/webgl/ShaderCoders_Base.js b/src/webgl/ShaderCoders_Base.js
index 00fa8507..db9efd3c 100644
--- a/src/webgl/ShaderCoders_Base.js
+++ b/src/webgl/ShaderCoders_Base.js
@@ -84,7 +84,7 @@ class SingleTypeCoder {
      * @returns {!int}
      */
     arrayPowerSizeOfTexture(tex) {
-        return tex.sizePower() - this.powerSizeOverhead;
+        return Math.max(0, tex.sizePower() - this.powerSizeOverhead);
     }
 }
 
diff --git a/src/webgl/Shaders.js b/src/webgl/Shaders.js
index a8c0b6ae..1400f3a6 100644
--- a/src/webgl/Shaders.js
+++ b/src/webgl/Shaders.js
@@ -101,6 +101,13 @@ Shaders.data = rgbaData => new WglConfiguredShader(destinationTexture => {
     }
 });
 
+/**
+ * Returns a configured shader that overlays the destination texture with the given float data.
+ * @param {!Float32Array} floats
+ * @returns {!WglConfiguredShader}
+ */
+Shaders.floatData = floats => Shaders.data(currentShaderCoder().float.dataToPixels(floats));
+
 /**
  * Returns a configured shader that overlays the destination texture with the given vec2 data.
  * @param {!Float32Array} floats
@@ -151,6 +158,18 @@ Shaders.sumFoldFloat = makePseudoShaderWithInputsAndOutputAndCode(
          return read_input(k) + read_input(k + len_output());
      }`);
 
+/**
+ * Adds the odd half of its input to the even half of its input.
+ * @param {!WglTexture} inp
+ * @returns {!WglConfiguredShader}
+ */
+Shaders.sumFoldFloatAdjacents = makePseudoShaderWithInputsAndOutputAndCode(
+    [Inputs.float('input')],
+    Outputs.float(),
+    `float outputFor(float k) {
+         return read_input(k*2.0) + read_input(k*2.0 + 1.0);
+     }`);
+
 /**
  * Adds the second half of its input into the first half.
  * @param {!WglTexture} inp
@@ -163,6 +182,18 @@ Shaders.sumFoldVec2 = makePseudoShaderWithInputsAndOutputAndCode(
          return read_input(k) + read_input(k + len_output());
      }`);
 
+/**
+ * Adds the odd half of its input to the even half of its input.
+ * @param {!WglTexture} inp
+ * @returns {!WglConfiguredShader}
+ */
+Shaders.sumFoldVec2Adjacents = makePseudoShaderWithInputsAndOutputAndCode(
+    [Inputs.vec2('input')],
+    Outputs.vec2(),
+    `vec2 outputFor(float k) {
+         return read_input(k*2.0) + read_input(k*2.0 + 1.0);
+     }`);
+
 /**
  * Adds the second half of its input into the first half.
  * @param {!WglTexture} inp
diff --git a/src/webgl/WglShader.js b/src/webgl/WglShader.js
index 2ec57a19..4268ef4d 100644
--- a/src/webgl/WglShader.js
+++ b/src/webgl/WglShader.js
@@ -219,8 +219,16 @@ class WglCompiledShader {
 
         let info = gl.getShaderInfoLog(shader);
         if (info !== '') {
-            console.warn("WebGLShader: gl.getShaderInfoLog() wasn't empty: " + gl.getShaderInfoLog(shader));
-            console.warn("Source code was: " + sourceCode);
+            let ignored = false;
+            for (let term of Config.IGNORED_WEBGL_INFO_TERMS) {
+                if (info.indexOf(term)) {
+                    ignored = true;
+                }
+            }
+            if (!ignored) {
+                console.warn("WebGLShader: gl.getShaderInfoLog() wasn't empty: " + gl.getShaderInfoLog(shader));
+                console.warn("Source code was: " + sourceCode);
+            }
         }
 
         if (gl.getShaderParameter(shader, WebGLRenderingContext.COMPILE_STATUS) === false) {
diff --git a/test/KarmaTestRunner.test.js b/test/KarmaTestRunner.test.js
index 5be71271..d48f50e2 100644
--- a/test/KarmaTestRunner.test.js
+++ b/test/KarmaTestRunner.test.js
@@ -51,8 +51,8 @@ let promiseRunTest = (suite, name, method) => {
 
     return promise.then(() => {
         result.success = true;
-        if (status.warn_only) {
-            console.warn(`${suite.name}.${name} passed, but is set to warn_only (${status.warn_only})`)
+        if (status.warn_only && !status.ignore_warn_only_on_success) {
+            console.warn(`${suite.name}.${name} passed, but is set to warn_only (${status.warn_only})`);
         }
         return finish();
     }, ex => {
@@ -69,7 +69,18 @@ let promiseRunTest = (suite, name, method) => {
             result.log.push(stackMsg);
         }
         if (status.warn_only) {
-            console.warn(`${suite.name}.${name} FAILED, but is set to warn_only (${status.warn_only})`)
+            let msg = status.warn_failure_message !== undefined ?
+                status.warn_failure_message :
+                `${suite.name}.${name} FAILED, but is set to warn_only (${status.warn_only})`;
+            console.warn(msg);
+
+            if (status.warn_show_error) {
+                for (let logMsg of result.log) {
+                    for (let line of logMsg.split('\n')) {
+                        console.warn('(ignored) ' + line);
+                    }
+                }
+            }
         }
         result.success = status.warn_only;
         return finish();
diff --git a/test/TestUtil.js b/test/TestUtil.js
index 404e0054..898db329 100644
--- a/test/TestUtil.js
+++ b/test/TestUtil.js
@@ -90,6 +90,8 @@ function isApproximatelyEqualToHelper(subject, other, epsilon) {
         return true;
     } else if (subject instanceof Object && subject.toString() === "[object Object]") {
         return isApproximatelyEqualToHelperDestructured(subject, other, epsilon);
+    } else if (subject === other) {
+        return true;
     } else {
         fail('Expected ' + describe(subject) + ' to have an isApproximatelyEqualTo method');
         return false;
@@ -301,6 +303,8 @@ export function assertThrows(func, extraArgCatcher) {
 
 /** @type {boolean|undefined} */
 let __webGLSupportPresent = undefined;
+/** @type {boolean|undefined} */
+let __onlyPartialWebGLSupportPresent = undefined;
 function isWebGLSupportPresent() {
     if (__webGLSupportPresent === undefined) {
         __webGLSupportPresent = false;
@@ -308,6 +312,8 @@ function isWebGLSupportPresent() {
             let canvas = document.createElement('canvas');
             let ctx = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
             if (ctx instanceof WebGLRenderingContext) {
+                __webGLSupportPresent = true;
+
                 let shader = ctx.createShader(WebGLRenderingContext.VERTEX_SHADER);
                 ctx.shaderSource(shader, `
                     precision highp float;
@@ -318,8 +324,11 @@ function isWebGLSupportPresent() {
 
                 // HACK: tests on travis-ci give this warning when compiling shaders, and then give
                 // bad test results. Checking for it is a workaround to make the build pass.
-                if (ctx.getShaderInfoLog(shader).indexOf("extension `GL_ARB_gpu_shader5' unsupported") === -1) {
-                    __webGLSupportPresent = true;
+                let term = "extension `GL_ARB_gpu_shader5' unsupported";
+                __onlyPartialWebGLSupportPresent = ctx.getShaderInfoLog(shader).indexOf(term) !== -1;
+                if (__onlyPartialWebGLSupportPresent) {
+                    Config.IGNORED_WEBGL_INFO_TERMS.push(term);
+                    console.log('Only partial WebGL support is present. Some tests may fail and be ignored.')
                 }
             }
         }
@@ -327,6 +336,13 @@ function isWebGLSupportPresent() {
     return __webGLSupportPresent;
 }
 
+/**
+ * @returns {!boolean|undefined}
+ */
+function isOnlyPartialWebGLSupportPresent() {
+    return isWebGLSupportPresent() && __onlyPartialWebGLSupportPresent;
+}
+
 let promiseImageDataFromSrc = src => {
     let img = document.createElement('img');
     img.src = src;
@@ -409,6 +425,11 @@ export class Suite {
                 status.log.push(msg);
                 assertThat(undefined); // Cancel 'no assertion' warning.
                 return;
+            } else if (isOnlyPartialWebGLSupportPresent()) {
+                status.warn_only = true;
+                status.ignore_warn_only_on_success = true;
+                status.warn_failure_message = `Ignoring ${this.name}.${caseName} failure due to lack of WebGL support.`;
+                status.warn_show_error = true;
             }
 
             let preTexCount = WglTexturePool.getUnReturnedTextureCount();
diff --git a/test/circuit/CircuitDefinition.test.js b/test/circuit/CircuitDefinition.test.js
index 7a615c89..0b7d5cb6 100644
--- a/test/circuit/CircuitDefinition.test.js
+++ b/test/circuit/CircuitDefinition.test.js
@@ -401,7 +401,11 @@ suite.test("minimumRequiredColCount", () => {
 
 suite.test("colIsMeasuredMask", () => {
     let assertAbout = (diagram, ...extraGates) => {
-        let c = circuit(diagram, ['D', Gates.Detector], ...extraGates);
+        let c = circuit(
+            diagram,
+            ['D', Gates.Detectors.ZDetector],
+            ['R', Gates.Detectors.ZDetectControlClear],
+            ...extraGates);
         return assertThat(Seq.range(c.columns.length + 3).map(i => c.colIsMeasuredMask(i-1)).toArray());
     };
 
@@ -421,6 +425,10 @@ suite.test("colIsMeasuredMask", () => {
     assertAbout(`M!`).isEqualTo([0, 0, 1, 0, 0]);
     // Detector clears.
     assertAbout(`MD`).isEqualTo([0, 0, 1, 0, 0]);
+    // Detect-Control-Reset clears.
+    assertAbout(`MR`).isEqualTo([0, 0, 1, 0, 0]);
+    assertAbout(`MR
+                 -X`).isEqualTo([0, 0, 1, 0, 0]);
     // Controlled detector doesn't clear.
     assertAbout(`MD
                  -●`).isEqualTo([0, 0, 1, 1, 1]);
@@ -885,6 +893,80 @@ suite.test("gateAtLocIsDisabledReason", () => {
     bad(1, 1, `-●-
                M<-
                M/-`, ['<', Gates.CycleBitsGates.CycleBitsFamily]);
+
+    // Detectors.
+    bad(1, 0, `MD`, ['D', Gates.Detectors.XDetectControlClear]);
+    bad(1, 0, `MD`, ['D', Gates.Detectors.YDetectControlClear]);
+    good(1, 0, `MD`, ['D', Gates.Detectors.ZDetectControlClear]);
+    bad(1, 0, `MR`, ['R', Gates.Detectors.XDetectControlClear]);
+    bad(1, 0, `MR`, ['R', Gates.Detectors.YDetectControlClear]);
+    good(1, 0, `MR`, ['R', Gates.Detectors.ZDetectControlClear]);
+    good(3, 1, `---]-
+                -M-X-`, [']', Gates.Detectors.XDetectControlClear]);
+    good(3, 1, `---]-
+                -M-X-`, [']', Gates.Detectors.YDetectControlClear]);
+    good(3, 1, `---]-
+                -M-X-`, [']', Gates.Detectors.ZDetectControlClear]);
+
+    // Permutation sub-groups.
+    good(2, 0, `--P-
+                --/-
+                --/-
+                --/-
+                H-●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    good(2, 0, `-MP-
+                --/-
+                --/-
+                -M/-
+                H-●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    good(2, 0, `--P-
+                --/-
+                --/-
+                -M/-
+                HM●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    good(2, 0, `-MP-
+                --/-
+                --/-
+                -M/-
+                HM●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    good(2, 0, `--P-
+                -M/-
+                -M/-
+                --/-
+                HM●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    good(2, 0, `-MP-
+                -M/-
+                -M/-
+                -M/-
+                HM●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    bad(2, 0, `--P-
+               -M/-
+               -M/-
+               --/-
+               H-●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    bad(2, 0, `--P-
+               -M/-
+               --/-
+               --/-
+               HM●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+
+    // Non-trivial subgroup.
+    good(2, 0, `--P-
+                -M/-
+                -M/-
+                --/-
+                -M/-
+                --/-
+                --/-
+                HM●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
+    bad(2, 0, `--P-
+               -M/-
+               --/-
+               -M/-
+               -M/-
+               --/-
+               --/-
+               HM●-`, ['P', Gates.InterleaveBitsGates.InterleaveBitsGateFamily]);
 });
 
 suite.test("gateAtLocIsDisabledReason_controls", () => {
diff --git a/test/circuit/CircuitStats.test.js b/test/circuit/CircuitStats.test.js
index 4d46da26..d4f012c7 100644
--- a/test/circuit/CircuitStats.test.js
+++ b/test/circuit/CircuitStats.test.js
@@ -16,7 +16,6 @@ import {Suite, assertThat, assertTrue} from "test/TestUtil.js"
 import {CircuitStats} from "src/circuit/CircuitStats.js"
 
 import {CircuitDefinition} from "src/circuit/CircuitDefinition.js"
-import {Complex} from "src/math/Complex.js"
 import {GateColumn} from "src/circuit/GateColumn.js"
 import {Gates} from "src/gates/AllGates.js"
 import {Matrix} from "src/math/Matrix.js"
@@ -109,9 +108,10 @@ suite.testUsingWebGL('incoherent-amplitude-display', () => {
     assertThat(stats.qubitDensityMatrix(Infinity, 0)).isApproximatelyEqualTo(Matrix.square(0.5, 0, 0, 0.5));
     assertThat(stats.qubitDensityMatrix(Infinity, 1)).isApproximatelyEqualTo(Matrix.square(0.5, 0, 0, 0.5));
     assertThat(stats.customStatsForSlot(5, 0)).isApproximatelyEqualTo({
-        probabilities: Matrix.row(1, 1).times(Math.sqrt(0.5)),
-        superposition: undefined,
-        phaseLockIndex: undefined
+        quality: 0.5,
+        ket: Matrix.row(1, 0),
+        phaseLockIndex: 0,
+        incoherentKet: Matrix.row(Math.sqrt(0.5), Math.sqrt(0.5))
     });
 });
 
@@ -124,8 +124,9 @@ suite.testUsingWebGL('coherent-amplitude-display', () => {
     assertThat(stats.qubitDensityMatrix(Infinity, 1)).isApproximatelyEqualTo(Matrix.square(0.5, 0, 0, 0.5));
     assertThat(stats.qubitDensityMatrix(Infinity, 2)).isApproximatelyEqualTo(Matrix.square(0.5, 0.5, 0.5, 0.5));
     assertThat(stats.customStatsForSlot(5, 0)).isApproximatelyEqualTo({
-        probabilities: undefined,
-        superposition: Matrix.square(1, 0, 0, 1).times(Math.sqrt(0.5)),
+        quality: 1,
+        ket: Matrix.square(1, 0, 0, 1).times(Math.sqrt(0.5)),
+        incoherentKet: Matrix.square(1, 0, 0, 1).times(Math.sqrt(0.5)),
         phaseLockIndex: 0
     });
 });
@@ -288,7 +289,7 @@ suite.testUsingWebGL('dynamic-phase-gradient-keeps-qubits-coherent', () => {
     for (let i = 0; i < 16; i++) {
         let [x, y, z] = stats.qubitDensityMatrix(Infinity, i).qubitDensityMatrixToBlochVector();
         let r = x*x + y*y + z*z;
-        assertThat(r).withInfo({i, x, y, z}).isApproximatelyEqualTo(1);
+        assertThat(r).withInfo({i, x, y, z}).isApproximatelyEqualTo(1, 0.00001);
     }
 });
 
@@ -353,3 +354,82 @@ suite.testUsingWebGL('classical-bit-rotate-with-classical-control-does-fire', ()
     assertThat(stats.qubitDensityMatrix(Infinity, 1)).isEqualTo(Matrix.square(0, 0, 0, 1));
     assertThat(stats.qubitDensityMatrix(Infinity, 2)).isEqualTo(Matrix.square(0, 0, 0, 1));
 });
+
+suite.testUsingWebGL("initial_states", () => {
+    let circuit = Serializer.fromJson(CircuitDefinition, {
+        init: [0, 1, '+', '-', 'i', '-i'],
+        cols: [],
+    });
+    let stats = CircuitStats.fromCircuitAtTime(circuit, 0);
+    assertThat(stats.qubitDensityMatrix(9, 0).qubitDensityMatrixToBlochVector()).isApproximatelyEqualTo([0, 0, -1]);
+    assertThat(stats.qubitDensityMatrix(9, 1).qubitDensityMatrixToBlochVector()).isApproximatelyEqualTo([0, 0, +1]);
+    assertThat(stats.qubitDensityMatrix(9, 2).qubitDensityMatrixToBlochVector()).isApproximatelyEqualTo([-1, 0, 0]);
+    assertThat(stats.qubitDensityMatrix(9, 3).qubitDensityMatrixToBlochVector()).isApproximatelyEqualTo([+1, 0, 0]);
+    assertThat(stats.qubitDensityMatrix(9, 4).qubitDensityMatrixToBlochVector()).isApproximatelyEqualTo([0, +1, 0]);
+    assertThat(stats.qubitDensityMatrix(9, 5).qubitDensityMatrixToBlochVector()).isApproximatelyEqualTo([0, -1, 0]);
+});
+
+suite.testUsingWebGL("distillation", () => {
+    let c = circuit(
+        `
+        -X-X--X-X--X-X--X-X-------X-X--X-X-------X-X------------HTH-0-
+        -X-X--X-X--X-X-------X-X--X-X-------X-X-------X-X-------HTH-0-
+        -X-X--X-X-------X-X--X-X-------X-X--X-X------------X-X--HTH-0-
+        -X-X-------X-X--X-X--X-X-----------------X-X--X-X--X-X--HTH-0-
+        -X-X----------------------X-X--X-X--X-X--X-X--X-X--X-X--------
+        -#T]--#T]--#T]--#T]--#T]--#T]--#T]--#T]--#T]--#T]--#T]--------
+        `,
+        [']', Gates.Detectors.XDetectControlClear],
+        ['0', Gates.PostSelectionGates.PostSelectOff],
+        ['#', Gates.Controls.XControl],
+        ['T', Gates.OtherZ.Z4]);
+    for (let i = 0; i < 5; i++) {
+        let stats = CircuitStats.fromCircuitAtTime(c, 0);
+        assertThat(stats.qubitDensityMatrix(Infinity, 4).qubitDensityMatrixToBlochVector()).isApproximatelyEqualTo(
+            [0, Math.sqrt(0.5), -Math.sqrt(0.5)]);
+        assertThat(stats.survivalRate(Infinity)).isApproximatelyEqualTo(1, 0.001);
+    }
+});
+
+suite.testUsingWebGL("toReadableJson", () => {
+    let c = circuit(
+        `
+        --%D
+        H@/-
+        `,
+        ['%', Gates.Displays.ProbabilityDisplayFamily],
+        ['D', Gates.Detectors.ZDetector]
+    );
+    let stats = CircuitStats.fromCircuitAtTime(c, 0.5);
+    let json = stats.toReadableJson();
+    assertThat(json).isApproximatelyEqualTo({
+        circuit: Serializer.toJson(c),
+        output_amplitudes: [
+            {r: Math.sqrt(0.5), i: 0},
+            {r: 0, i: 0},
+            {r: Math.sqrt(0.5), i: 0},
+            {r: 0, i: 0},
+        ],
+        time_parameter: 0.5,
+        chance_of_surviving_to_each_column: [1, 1, 1, 1],
+        computed_bloch_vectors_by_column_then_wire: [
+            [null, null],
+            [null, {x: +1, y: 0, z: 0}],
+            [null, null],
+            [null, null],
+            [{x: 0, y: 0, z: +1}, {x: +1, y: 0, z: 0}],
+        ],
+        displays: [
+            {
+                location: {wire: 0, column: 2},
+                type: {serialized_id: "Chance2", name: "Probability Display"},
+                data: {probabilities: [0.5, 0, 0.5, 0]}
+            },
+            {
+                location: {wire: 0, column: 3},
+                type: {serialized_id: "ZDetector", name: "Z Axis Detector"},
+                data: false
+            }
+        ]
+    })
+});
diff --git a/test/circuit/Serializer.test.js b/test/circuit/Serializer.test.js
index 56a9a7e6..79577e9a 100644
--- a/test/circuit/Serializer.test.js
+++ b/test/circuit/Serializer.test.js
@@ -179,7 +179,9 @@ suite.test("roundTrip_circuitDefinition", () => {
 const IDS_THAT_SHOULD_BE_KNOWN = [
     "•", "◦", "⊕", "⊖", "⊗", "(/)",
     "|0⟩⟨0|", "|1⟩⟨1|", "|+⟩⟨+|", "|-⟩⟨-|", "|X⟩⟨X|", "|/⟩⟨/|",
-    "Measure", "Detector",
+    "Measure",
+    "XDetector", "YDetector", "ZDetector",
+    "XDetectControlReset", "YDetectControlReset", "ZDetectControlReset",
     "Swap",
     "…",
     "inputA1", "inputA2", "inputA3", "inputA4", "inputA5", "inputA6", "inputA7", "inputA8", "inputA9", "inputA10", "inputA11", "inputA12", "inputA13", "inputA14", "inputA15", "inputA16",
@@ -189,7 +191,7 @@ const IDS_THAT_SHOULD_BE_KNOWN = [
     "revinputA1", "revinputA2", "revinputA3", "revinputA4", "revinputA5", "revinputA6", "revinputA7", "revinputA8", "revinputA9", "revinputA10", "revinputA11", "revinputA12", "revinputA13", "revinputA14", "revinputA15", "revinputA16",
     "revinputB1", "revinputB2", "revinputB3", "revinputB4", "revinputB5", "revinputB6", "revinputB7", "revinputB8", "revinputB9", "revinputB10", "revinputB11", "revinputB12", "revinputB13", "revinputB14", "revinputB15", "revinputB16",
     "__error__",
-    "0", "NeGate",
+    "0", "NeGate", "i",
     "H",
     "X", "Y", "Z",
     "X^½", "X^⅓", "X^¼", "X^⅛", "X^⅟₁₆", "X^⅟₃₂",
diff --git a/test/gates/AllGates.test.js b/test/gates/AllGates.test.js
index b6a752ff..a59c45df 100644
--- a/test/gates/AllGates.test.js
+++ b/test/gates/AllGates.test.js
@@ -148,7 +148,7 @@ suite.testUsingWebGL("gatesActLikeTheirKnownPhasingFunction", () => {
     }
 });
 
-suite.testUsingWebGL("knownNonUnitaryGates", () => {
+suite.test("knownNonUnitaryGates", () => {
     let nonUnitaryGates = new Set(Gates.KnownToSerializer.
         filter(g => !g.isDefinitelyUnitary()).
         map(g => g.serializedId));
@@ -163,7 +163,14 @@ suite.testUsingWebGL("knownNonUnitaryGates", () => {
         '|-⟩⟨-|',
         '|X⟩⟨X|',
         '|/⟩⟨/|',
-        'Detector',
+        // Collapsing measurement isn't unitary.
+        'XDetector',
+        'YDetector',
+        'ZDetector',
+        // Especially if you reset the qubit afterwards.
+        'XDetectControlReset',
+        'YDetectControlReset',
+        'ZDetectControlReset',
     ]));
 });
 
@@ -226,6 +233,11 @@ suite.test("knownDynamicGateFamilies", () => {
         // Other.
         'grad^t1',
         'grad^-t1',
-        'Detector',
+        'XDetector',
+        'YDetector',
+        'ZDetector',
+        'XDetectControlReset',
+        'YDetectControlReset',
+        'ZDetectControlReset',
     ]));
 });
diff --git a/test/gates/AmplitudeDisplay.test.js b/test/gates/AmplitudeDisplay.test.js
index ca597e83..da0b773f 100644
--- a/test/gates/AmplitudeDisplay.test.js
+++ b/test/gates/AmplitudeDisplay.test.js
@@ -14,278 +14,218 @@
 
 import {Suite, assertThat} from "test/TestUtil.js"
 import {
-    amplitudesToPolarKets,
-    convertAwayFromPolar,
     amplitudeDisplayStatTextures,
-    reduceToLongestPolarKet,
-    foldConsistentRatios,
-    spreadLengthAcrossPolarKets,
-    signallingSumAll,
-    toRatiosVsRepresentative
+    AMPS_TO_SQUARED_MAGS_SHADER,
+    MAGS_TO_INDEXED_MAGS_SHADER,
+    FOLD_MAX_INDEXED_MAG_SHADER,
+    LOOKUP_KET_AT_INDEXED_MAG_SHADER,
+    POINTWISE_CMUL_CONJ_SHADER,
 } from "src/gates/AmplitudeDisplay.js"
 
 import {Complex} from "src/math/Complex.js"
 import {Controls} from "src/circuit/Controls.js"
+import {CircuitDefinition} from "src/circuit/CircuitDefinition.js"
+import {CircuitStats} from "src/circuit/CircuitStats.js"
+import {CircuitShaders} from "src/circuit/CircuitShaders.js"
+import {Serializer} from "src/circuit/Serializer.js"
 import {seq} from "src/base/Seq.js"
 import {Shaders} from "src/webgl/Shaders.js"
 import {currentShaderCoder} from "src/webgl/ShaderCoders.js"
 
 let suite = new Suite("AmplitudeDisplay");
 
-suite.testUsingWebGL("amplitudesToPolarKets", () => {
+suite.testUsingWebGL("AMPS_TO_SQUARED_MAGS_SHADER", () => {
     let input = Shaders.vec2Data(new Float32Array([
         1,0,
         3,4,
         -1,1,
         0,0.5
     ])).toVec2Texture(2);
-    assertThat(amplitudesToPolarKets(input).readVec4Outputs(2)).isApproximatelyEqualTo(new Float32Array([
-        1,0,1,0,
-        25,new Complex(3,4).phase(),25,0,
-        2,Math.PI*3/4,2,0,
-        0.25,Math.PI/2,0.25,0
-    ]), 0.0001);
+    assertThat(AMPS_TO_SQUARED_MAGS_SHADER(input).readVecFloatOutputs(2)).isApproximatelyEqualTo(new Float32Array([
+        1,
+        25,
+        2,
+        0.25,
+    ]), 0.001);
     input.deallocByDepositingInPool();
 });
 
-suite.testUsingWebGL("amplitudesToPolarKets_zero", () => {
-    let input = Shaders.vec2Data(new Float32Array([
-        0,0
-    ])).toVec2Texture(0);
-    assertThat(amplitudesToPolarKets(input).readVec4Outputs(0)).isEqualTo(new Float32Array([
-        0,0,0,0
-    ]));
+suite.testUsingWebGL("MAGS_TO_INDEXED_MAGS_SHADER", () => {
+    let input = Shaders.floatData(new Float32Array([
+        2,
+        3,
+        5,
+        7,
+    ])).toVecFloatTexture(2);
+    assertThat(MAGS_TO_INDEXED_MAGS_SHADER(input).readVec2Outputs(2)).isApproximatelyEqualTo(new Float32Array([
+        0, 2,
+        1, 3,
+        2, 5,
+        3, 7,
+    ]), 0.001);
     input.deallocByDepositingInPool();
 });
 
-suite.testUsingWebGL("spreadLengthAcrossPolarKets", () => {
-    let inp = Shaders.vec4Data(new Float32Array([
-         1, 2,100,0,
-         3, 4,200,0,
-         5, 6,400,0,
-         7, 8,800,0,
-         9,10,1600,0,
-        11,12,3200,0,
-        13,14,6400,0,
-        15,16,12800,0
-    ])).toVec4Texture(3);
-    let out = inp.tradeThrough(t => spreadLengthAcrossPolarKets(t, 1), true);
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-         1, 2,300,0,
-         3, 4,300,0,
-         5, 6,1200,0,
-         7, 8,1200,0,
-         9,10,4800,0,
-        11,12,4800,0,
-        13,14,19200,0,
-        15,16,19200,0
-    ]));
-    out.deallocByDepositingInPool();
-
-    out = inp.tradeThrough(t => spreadLengthAcrossPolarKets(t, 2), true);
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        1, 2,1500,0,
-        3, 4,1500,0,
-        5, 6,1500,0,
-        7, 8,1500,0,
-        9,10,24000,0,
-        11,12,24000,0,
-        13,14,24000,0,
-        15,16,24000,0
-    ]));
-    out.deallocByDepositingInPool();
-
-
-    out = inp.tradeThrough(t => spreadLengthAcrossPolarKets(t, 3));
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        1, 2,25500,0,
-        3, 4,25500,0,
-        5, 6,25500,0,
-        7, 8,25500,0,
-        9,10,25500,0,
-        11,12,25500,0,
-        13,14,25500,0,
-        15,16,25500,0
-    ]));
-    out.deallocByDepositingInPool();
-});
-
-suite.testUsingWebGL("reduceToLongestPolarKet", () => {
-    let inp = Shaders.vec4Data(new Float32Array([
-        1, 2,300,0,
-        3, 4,300,0,
-        5, 6,1200,0,
-        7, 8,1200,0,
-        9,10,4800,0,
-        11,12,4800,0,
-        13,14,19200,0,
-        15,16,19200,0
-    ])).toVec4Texture(3);
-    let out;
-
-    out = inp.tradeThrough(t => reduceToLongestPolarKet(t, 1));
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        1+5+9+13,14,25500,0,    3+7+11+15,16,25500,0
-    ]));
-    out.deallocByDepositingInPool();
-
-    inp = Shaders.vec4Data(new Float32Array([
-        1, 2,300,0,
-        3, 4,300,0,
-        55,6,120000,0,
-        7, 8,1200,0,
-        9,10,4800,0,
-        11,12,4800,0,
-        13,14,19200,0,
-        15,16,19200,0
-    ])).toVec4Texture(3);
-    out = inp.tradeThrough(t => reduceToLongestPolarKet(t, 1));
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        1+55+9+13,6,144300,0,
-        3+7+11+15,16,25500,0
-    ]));
-    out.deallocByDepositingInPool();
+suite.testUsingWebGL("FOLD_MAX_INDEXED_MAG_SHADER", () => {
+    let input = Shaders.vec2Data(new Float32Array([
+        0, 4.2,
+        8, 2.1,
+        13, 1.5,
+        23, 3.3,
+    ])).toVec2Texture(2);
+    assertThat(FOLD_MAX_INDEXED_MAG_SHADER(input).readVec2Outputs(1)).isApproximatelyEqualTo(new Float32Array([
+        0, 4.2,
+        23, 3.3,
+    ]), 0.001);
+    input.deallocByDepositingInPool();
 });
 
-suite.testUsingWebGL("convertAwayFromPolar", () => {
-    let input = Shaders.vec4Data(new Float32Array([
-        1,0,3,0,
-        25,new Complex(3,4).phase(),9,0,
-        2,Math.PI*3/4,10,0,
-        0.25,Math.PI/2,20,0
-    ])).toVec4Texture(2);
-    assertThat(convertAwayFromPolar(input).readVec4Outputs(2)).isApproximatelyEqualTo(new Float32Array([
-        1,0,3,0,
-        3,4,9,0,
-        -1,1,10,0,
-        0,0.5,20,0
-    ]), 0.0001);
-
+suite.testUsingWebGL("LOOKUP_KET_AT_INDEXED_MAG_SHADER", () => {
+    let input = Shaders.vec2Data(new Float32Array([
+        0, 1, 2, 3, 4, 5, 6, 7,
+        2, 3, 5, 7, 11, 13, 17, 19,
+        0, 1, 4, 9, 16, 25, 36, 49,
+        1, 2, 4, 8, 16, 32, 64, 128,
+    ])).toVec2Texture(4);
+    let index = Shaders.vec2Data(new Float32Array([
+        1, 5000.3,
+    ])).toVec2Texture(0);
+    assertThat(LOOKUP_KET_AT_INDEXED_MAG_SHADER(input, index).readVec2Outputs(2)).isApproximatelyEqualTo(new Float32Array([
+        2, 3, 5, 7, 11, 13, 17, 19,
+    ]), 0.001);
+    index.deallocByDepositingInPool();
     input.deallocByDepositingInPool();
 });
 
-suite.testUsingWebGL("toRatiosVsRepresentative", () => {
-    let c = (r, i=0) => new Complex(r, i);
-    let inp = Shaders.vec2Data(new Float32Array([
-        1,0,    1,0,    1,0,    1,0,
-        2,0,    3,0,    4,0,    5,0,
-        1,2,    3,4,    5,6,    7,8,
-        0,0,    0,-1,   0,-2,   0,0
+suite.testUsingWebGL("POINTWISE_CMUL_CONJ_SHADER", () => {
+    let small_input = Shaders.vec2Data(new Float32Array([
+        1, 2,
+    ])).toVec2Texture(0);
+    let large_input = Shaders.vec2Data(new Float32Array([
+        0, 1, 2, 3, 4, 5, 6, 7,
+        2, 3, 5, 7, 11, 13, 17, 19,
+        0, 1, 4, 9, 16, 25, 36, 49,
+        1, 2, 4, 8, 16, 32, 64, 128,
     ])).toVec2Texture(4);
-    let rep = Shaders.vec4Data(new Float32Array([
-        1,0,0,0,    3,4,0,0,    -0.5,0,0,0,    0,0.5,0,0
-    ])).toVec4Texture(2);
-    assertThat(toRatiosVsRepresentative(inp, rep).readVec4Outputs(4)).isApproximatelyEqualTo(seq([
-        c(1),c(1),   c(1),c(3,4),    c(1),c(-0.5),    c(1),c(0,0.5),
-        c(2),c(1),   c(3),c(3,4),    c(4),c(-0.5),    c(5),c(0,0.5),
-        c(1,2),c(1), c(3,4),c(3,4),  c(5,6),c(-0.5),  c(7,8),c(0,0.5),
-        c(0),c(1),   c(0,-1),c(3,4), c(0,-2),c(-0.5), c(0),c(0,0.5)
-    ]).flatMap(e => [e.real, e.imag]).toFloat32Array(), 0.0001);
-
-    inp.deallocByDepositingInPool();
-    rep.deallocByDepositingInPool();
+    assertThat(POINTWISE_CMUL_CONJ_SHADER(small_input, large_input).readVec2Outputs(4)).isApproximatelyEqualTo(new Float32Array([
+        2, 1, 8, -1, 14, -3, 20, -5,
+        8, -1, 19, -3, 37, -9, 55, -15,
+        2, 1, 22, 1, 66, -7, 134, -23,
+        5, 0, 20, 0, 80, 0, 320, 0
+    ]), 0.001);
+    small_input.deallocByDepositingInPool();
+    large_input.deallocByDepositingInPool();
 });
 
-suite.testUsingWebGL("foldConsistentRatios", () => {
-    let inp = Shaders.vec4Data(new Float32Array([
-        1,0,0,0,    2,0,0,0,
-        0,0,1,0,    0,0,2,3,
-        1,0,1,0,    2,0,2,0,
-        1,0,3,0,    2,0,6,0,
-        1,0,0,1,    0,-1,1,0,
-        1,2,3,4,    2,-1,4,-3,
-        1,2,3,4,    1,2,3,5,
-        1,0,2,0,    1,0,3,0
-    ])).toVec4Texture(4);
-    let out;
-
-    out = inp.tradeThrough(t => foldConsistentRatios(t, 1), true);
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        2,0,0,0,
-        0,0,2,3,
-        2,0,2,0,
-        2,0,6,0,
-        1,0,0,1,
-        1,2,3,4,
-        -666,-666,-666,-666,
-        -666,-666,-666,-666
+suite.testUsingWebGL("makeAmplitudeSpanPipeline_coherent", () => {
+    let inp = Shaders.vec2Data(new Float32Array([0.6,0.8, 0,0, 0,0, 0,0])).
+        toVec2Texture(2);
+    let controlTex = CircuitShaders.controlMask(Controls.NONE).toBoolTexture(2);
+    let [ketData, qualityData, incoherentKetData] = amplitudeDisplayStatTextures(inp, Controls.NONE, controlTex, 0, 2);
+    let ket = currentShaderCoder().vec4.pixelsToData(ketData.readPixels());
+    let quality = currentShaderCoder().float.pixelsToData(qualityData.readPixels());
+    let incoherentKet = currentShaderCoder().vec4.pixelsToData(incoherentKetData.readPixels());
+    assertThat(ket).isApproximatelyEqualTo(new Float32Array([
+        0.6,0.8,
+        0,0,
+        0,0,
+        0,0
     ]));
-    out.deallocByDepositingInPool();
-
-    out = inp.tradeThrough(t => foldConsistentRatios(t, 2));
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        -666,-666,-666,-666,
-        -666,-666,-666,-666,
-        -666,-666,-666,-666,
-        -666,-666,-666,-666
+    assertThat(incoherentKet).isApproximatelyEqualTo(new Float32Array([
+        1,
+        0,
+        0,
+        0,
     ]));
-    out.deallocByDepositingInPool();
+    assertThat(quality).isApproximatelyEqualTo(new Float32Array([1]));
 
-    inp = Shaders.vec4Data(new Float32Array([
-        1,0,0,0,    20,0,0,0,   0,0,0,0,  3,1,0,0,
-        1,0,0,0,    0,0,2,0,   0,0,0,0,  1,0,0,0,
-        0,0,0,0,    0,0,0,0,   0,0,0,0,  0,0,0,0,
-        -666,0,0,0,  0,0,0,0,   0,0,0,0,  0,0,0,0
-    ])).toVec4Texture(4);
-    out = inp.tradeThrough(t => foldConsistentRatios(t, 2));
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        20,0,0,0,
-        -666,-666,-666,-666,
-        0,0,0,0,
-        -666,-666,-666,-666
-    ]));
-    out.deallocByDepositingInPool();
+    inp.deallocByDepositingInPool();
+    controlTex.deallocByDepositingInPool();
+    ketData.deallocByDepositingInPool();
+    qualityData.deallocByDepositingInPool();
+    incoherentKetData.deallocByDepositingInPool();
 });
 
-suite.testUsingWebGL("pipelineToSumAll", () => {
-    let inp = Shaders.vec4Data(new Float32Array([
-        2,0,0,0,
-        0,0,2,3,
-        2,0,2,0,
-        2,0,6,0,
-        1,0,0,1,
-        1,2,3,4,
-        1,2,3,4,
-        1,2,3,4
-    ])).toVec4Texture(3);
-    let out;
+suite.testUsingWebGL("AmplitudesDisplayWithOtherQubit_Minus", () => {
+    let stats = CircuitStats.fromCircuitAtTime(
+        Serializer.fromJson(CircuitDefinition, {cols:[["Amps2"]],init:[0,0,"-"]}),
+        0);
+    let out = stats.toReadableJson();
+    assertThat(out.displays[0].data.ket).isApproximatelyEqualTo([
+        {r: 1, i: 0},
+        {r: 0, i: 0},
+        {r: 0, i: 0},
+        {r: 0, i: 0},
+    ]);
+    assertThat(out.displays[0].data.coherence_measure).isApproximatelyEqualTo(1);
+});
 
-    out = inp.tradeThrough(signallingSumAll);
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        10,6,19,16
-    ]));
-    out.deallocByDepositingInPool();
+suite.testUsingWebGL("AmplitudesDisplayWithOtherQubit_i", () => {
+    let stats = CircuitStats.fromCircuitAtTime(
+        Serializer.fromJson(CircuitDefinition, {cols:[["Amps2"]],init:[0,0,"i"]}),
+        0);
+    let out = stats.toReadableJson();
+    assertThat(out.displays[0].data.ket).isApproximatelyEqualTo([
+        {r: 1, i: 0},
+        {r: 0, i: 0},
+        {r: 0, i: 0},
+        {r: 0, i: 0},
+    ]);
+    assertThat(out.displays[0].data.coherence_measure).isApproximatelyEqualTo(1);
 });
 
-suite.testUsingWebGL("pipelineToSumAll_signal", () => {
-    let inp = Shaders.vec4Data(new Float32Array([
-        2,0,0,0,
-        0,0,2,3,
-        2,0,2,0,
-        -666.0,-666.0,-666.0,-666.0,
-        -666.0,-666.0,-666.0,-666.0,
-        1,2,3,4,
-        1,2,3,4,
-        1,2,3,4
-    ])).toVec4Texture(3);
-    let out;
+suite.testUsingWebGL("AmplitudesDisplayWithOtherQubit_postselect", () => {
+    let stats = CircuitStats.fromCircuitAtTime(
+        Serializer.fromJson(CircuitDefinition, {cols:[["Amps2",1,"|0⟩⟨0|"]],init:[0,0,"+"]}),
+        0);
+    let out = stats.toReadableJson();
+    assertThat(out.displays[0].data.ket).isApproximatelyEqualTo([
+        {r: 1, i: 0},
+        {r: 0, i: 0},
+        {r: 0, i: 0},
+        {r: 0, i: 0},
+    ]);
+    assertThat(out.displays[0].data.coherence_measure).isApproximatelyEqualTo(1);
+});
 
-    out = inp.tradeThrough(signallingSumAll);
-    assertThat(currentShaderCoder().vec4.pixelsToData(out.readPixels())).isEqualTo(new Float32Array([
-        -666.0,-666.0,-666.0,-666.0
-    ]));
-    out.deallocByDepositingInPool();
+suite.testUsingWebGL("AmplitudesDisplayWithOtherQubit_own_i", () => {
+    let stats = CircuitStats.fromCircuitAtTime(
+        Serializer.fromJson(CircuitDefinition, {cols:[["Amps2"]],init:["i",0,1]}),
+        0);
+    let out = stats.toReadableJson();
+    assertThat(out.displays[0].data.ket).isApproximatelyEqualTo([
+        {r: Math.sqrt(0.5), i: 0},
+        {r: 0, i: Math.sqrt(0.5)},
+        {r: 0, i: 0},
+        {r: 0, i: 0},
+    ]);
+    assertThat(out.displays[0].data.coherence_measure).isApproximatelyEqualTo(1);
 });
 
-suite.testUsingWebGL("makeAmplitudeSpanPipeline_OffOff", () => {
-    let inp = Shaders.vec2Data(new Float32Array([1,0, 0,0, 0,0, 0,0])).
-        toVec2Texture(2);
-    let [afterPolar, final] = amplitudeDisplayStatTextures(inp, Controls.NONE, 0, 2);
-    assertThat(currentShaderCoder().vec4.pixelsToData(afterPolar.readPixels())).isEqualTo(
-        new Float32Array([1,0,1,0, 0,0,1,0, 0,0,1,0, 0,0,1,0]));
-    assertThat(currentShaderCoder().vec4.pixelsToData(final.readPixels())).isEqualTo(new Float32Array([1,0,1,0]));
+suite.testUsingWebGL("AmplitudesDisplayIncoherent_sqrt_x", () => {
+    let stats = CircuitStats.fromCircuitAtTime(
+        Serializer.fromJson(CircuitDefinition, {cols:[[1,"•","X^½"], ["Amps2"]],init:[0,"+",1]}),
+        0);
+    let out = stats.toReadableJson();
+    assertThat(out.displays[0].data.incoherentKet).isApproximatelyEqualTo([
+        Math.sqrt(0.5),
+        0,
+        Math.sqrt(0.5),
+        0,
+    ]);
+    assertThat(out.displays[0].data.coherence_measure).isLessThan(0.85);
+});
 
-    inp.deallocByDepositingInPool();
-    afterPolar.deallocByDepositingInPool();
-    final.deallocByDepositingInPool();
+suite.testUsingWebGL("AmplitudesDisplayIncoherent_hadamard", () => {
+    let stats = CircuitStats.fromCircuitAtTime(
+        Serializer.fromJson(CircuitDefinition, {cols:[[1,"•","H"], ["Amps2"]],init:[0,"+",1]}),
+        0);
+    let out = stats.toReadableJson();
+    assertThat(out.displays[0].data.incoherentKet).isApproximatelyEqualTo([
+        Math.sqrt(0.5),
+        0,
+        Math.sqrt(0.5),
+        0,
+    ]);
+    assertThat(out.displays[0].data.coherence_measure).isLessThan(0.85);
 });
diff --git a/test/gates/Detector.test.js b/test/gates/Detector.test.js
index a16489bb..dda9fc1e 100644
--- a/test/gates/Detector.test.js
+++ b/test/gates/Detector.test.js
@@ -24,7 +24,7 @@ const circuit = (diagram, ...extras) => CircuitDefinition.fromTextDiagram(new Ma
     ...extras,
     ['-', undefined],
     ['●', Gates.Controls.Control],
-    ['D', Gates.Detector],
+    ['D', Gates.Detectors.ZDetector],
     ['X', Gates.HalfTurns.X],
     ['Z', Gates.HalfTurns.Z],
     ['H', Gates.HalfTurns.H],
@@ -88,3 +88,21 @@ suite.testUsingWebGL("collapsed-control-clicks", () => {
         }
     }
 });
+
+suite.testUsingWebGL("renormalizes", () => {
+    // Doesn't decrease survival probability.
+    let c = circuit(
+        '-]-D-]-D-]-D-]-',
+        [']', Gates.Detectors.XDetector],
+        ['0', Gates.PostSelectionGates.PostSelectOff]);
+    let stats = CircuitStats.fromCircuitAtTime(c, 0);
+    assertThat(stats.survivalRate(Infinity)).isApproximatelyEqualTo(1, 0.001);
+
+    // Renormalization doesn't increase survival probability.
+    let c2 = circuit(
+        '-]-0-D-]-D-]-D-]-',
+        [']', Gates.Detectors.XDetector],
+        ['0', Gates.PostSelectionGates.PostSelectOff]);
+    let stats2 = CircuitStats.fromCircuitAtTime(c2, 0);
+    assertThat(stats2.survivalRate(Infinity)).isApproximatelyEqualTo(0.5, 0.001);
+});
diff --git a/test/gates/ModularMultiplicationGates.test.js b/test/gates/ModularMultiplicationGates.test.js
index 03544fd8..a374670f 100644
--- a/test/gates/ModularMultiplicationGates.test.js
+++ b/test/gates/ModularMultiplicationGates.test.js
@@ -244,7 +244,7 @@ suite.testUsingWebGL('TimesBToTheAModRFamily', () => {
         ]),
     ]);
     let stats = CircuitStats.fromCircuitAtTime(circuit, 0);
-    assertThat(stats.finalState.rawBuffer().indexOf(1) / 2).isEqualTo(126);
+    assertThat([...stats.finalState.rawBuffer()].indexOf(1) / 2).isEqualTo(126);
 });
 
 suite.testUsingWebGL('TimesInverseBToTheAModRFamily', () => {
@@ -271,7 +271,7 @@ suite.testUsingWebGL('TimesInverseBToTheAModRFamily', () => {
         ]),
     ]);
     let stats = CircuitStats.fromCircuitAtTime(circuit, 0);
-    assertThat(stats.finalState.rawBuffer().indexOf(1) / 2).isEqualTo(245);
+    assertThat([...stats.finalState.rawBuffer()].indexOf(1) / 2).isEqualTo(245);
 });
 
 suite.testUsingWebGL('TimesBToTheAModRFamily_perm', () => {
diff --git a/test/math/Matrix.test.js b/test/math/Matrix.test.js
index 6f592428..0b1e5c82 100644
--- a/test/math/Matrix.test.js
+++ b/test/math/Matrix.test.js
@@ -628,6 +628,8 @@ suite.test("singularValueDecomposition", () => {
         new Complex(2, 3), new Complex(5, 7), new Complex(11, 13),
         new Complex(17, 19), new Complex(-23, 29), new Complex(31, 37),
         new Complex(41, -43), new Complex(47, -53), new Complex(59, 61)));
+
+    assertSvdDecompositionWorksFor(Matrix.generateDiagonal(4, k => Complex.polar(1, Math.PI*2/3*k)));
 });
 
 suite.test("singularValueDecomposition_randomized", () => {
@@ -637,7 +639,7 @@ suite.test("singularValueDecomposition_randomized", () => {
     }
 });
 
-suite.test("closestUnitary_2x2", () => {
+suite.test("closestUnitary", () => {
     let i = Complex.I;
     let ni = i.neg();
     assertThat(Matrix.square(0, 0, 0, 0).closestUnitary()).
@@ -646,7 +648,7 @@ suite.test("closestUnitary_2x2", () => {
         isApproximatelyEqualTo(Matrix.square(1, 0, 0, 1));
     assertThat(Matrix.square(0, 0.5, 0.0001, 0).closestUnitary()).
         isApproximatelyEqualTo(Matrix.square(0, 1, 1, 0));
-    assertThat(Matrix.square(1, i, -1, ni).closestUnitary()).
+    assertThat(Matrix.square(1.01, i, -1, ni).closestUnitary()).
         isApproximatelyEqualTo(Matrix.square(1, 0, 0, ni));
 
     let m = Matrix.square(
@@ -655,6 +657,9 @@ suite.test("closestUnitary_2x2", () => {
         1, -1,  1, -1,
         1, ni, -1,  i);
     assertThat(m.closestUnitary(0.001)).isApproximatelyEqualTo(m.times(0.5));
+
+    let m2 = Matrix.generateDiagonal(4, k => Complex.polar(1, Math.PI*2/3*k));
+    assertThat(m2.closestUnitary(0.001)).isApproximatelyEqualTo(m2);
 });
 
 suite.test("eigenDecomposition", () => {
diff --git a/test/webgl/ShaderCoders_Base.test.js b/test/webgl/ShaderCoders_Base.test.js
index b6ad48fc..fca8cb92 100644
--- a/test/webgl/ShaderCoders_Base.test.js
+++ b/test/webgl/ShaderCoders_Base.test.js
@@ -43,7 +43,7 @@ suite.testUsingWebGL("boolOutputs", () => {
     let output = BOOL_TYPE_CODER.outputPart;
     let shader = combinedShaderPartsWithCode([output], `
         bool outputFor(float k) {
-            return mod(k, 3.0) == 1.0;
+            return floor(mod(k + 0.5, 3.0)) == 1.0;
         }`);
 
     assertThat(shaderWithOutputPartAndArgs(shader, output, []).readBoolOutputs(3)).isEqualTo(new Uint8Array([
diff --git a/test/webgl/Shaders.test.js b/test/webgl/Shaders.test.js
index f2df3d28..9c5e6b45 100644
--- a/test/webgl/Shaders.test.js
+++ b/test/webgl/Shaders.test.js
@@ -90,6 +90,25 @@ suite.testUsingWebGL("data-bytes", () => {
 });
 
 suite.testUsingWebGL("sumFold", () => {
+    let raws = makePseudoShaderWithInputsAndOutputAndCode([], Outputs.float(), `
+        float outputFor(float k) {
+            return k*k;
+        }
+    `)().toVecFloatTexture(3);
+    assertThat(Shaders.sumFoldFloat(raws).readVecFloatOutputs(2)).isEqualTo(new Float32Array([
+        16,
+        1+25,
+        4+36,
+        9+49
+    ]));
+    assertThat(Shaders.sumFoldFloatAdjacents(raws).readVecFloatOutputs(2)).isEqualTo(new Float32Array([
+        1,
+        4+9,
+        16+25,
+        36+49
+    ]));
+    raws.deallocByDepositingInPool();
+
     let coords = makePseudoShaderWithInputsAndOutputAndCode([], Outputs.vec2(), `
         vec2 outputFor(float k) {
             return vec2(mod(k, 2.0), floor(k/2.0));
@@ -101,6 +120,12 @@ suite.testUsingWebGL("sumFold", () => {
         0,4,
         2,4
     ]));
+    assertThat(Shaders.sumFoldVec2Adjacents(coords).readVec2Outputs(2)).isEqualTo(new Float32Array([
+        1,0,
+        1,2,
+        1,4,
+        1,6,
+    ]));
     coords.deallocByDepositingInPool();
 
     let solid = makePseudoShaderWithInputsAndOutputAndCode([], Outputs.vec4(), `