Circuit changes draft

.github/workflows/book.yml

@@ -12,7 +12,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly
+          toolchain: '1.76.0'
           override: true
 
       # - name: Setup mdBook
@@ -26,7 +26,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: install
-          args: mdbook --git https://github.com/HollowMan6/mdBook.git --rev 62e01b34c23b957579c04ee1b24b57814ed8a4d5
+          args: mdbook --git https://github.com/HollowMan6/mdBook.git --rev 5830c9555a4dc051675d17f1fcb04dd0920543e8
 
       - name: Install mdbook-katex and mdbook-pdf
         uses: actions-rs/cargo@v1
@@ -40,6 +40,11 @@ jobs:
       - name: Build halo2 book
         run: mdbook build book/
 
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly-2023-10-05
+          override: true
+
       - name: Build latest rustdocs
         uses: actions-rs/cargo@v1
         with:

.github/workflows/ci.yml

@@ -52,8 +52,10 @@ jobs:
         with:
           beta-features: ${{ matrix.stage == 'beta' }}
           nightly-features: ${{ matrix.stage == 'nightly' }}
+      - name: Update apt
+        run: sudo apt-get update
       - name: Install cross-platform support dependencies
-        run: sudo apt install gcc-multilib
+        run: sudo apt-get install gcc-multilib
       - run: rustup target add i686-unknown-linux-gnu
       - name: Run tests
         run: >
@@ -125,33 +127,33 @@ jobs:
       - name: Test halo2 book
         run: mdbook test -L target/debug/deps book/
 
-  codecov:
-    name: Code coverage
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-      # Use stable for this to ensure that cargo-tarpaulin can be built.
-      - id: prepare
-        uses: ./.github/actions/prepare
-        with:
-          toolchain: stable
-          nightly-features: true
-      - name: Install cargo-tarpaulin
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-tarpaulin
-      - name: Generate coverage report
-        uses: actions-rs/cargo@v1
-        with:
-          command: tarpaulin
-          args: >
-            ${{ steps.prepare.outputs.feature-flags }}
-            --timeout 600
-            --out Xml
-      - name: Upload coverage to Codecov
-        uses: codecov/[email protected]
+#   codecov:
+#     name: Code coverage
+#     runs-on: ubuntu-latest
+# 
+#     steps:
+#       - uses: actions/checkout@v3
+#       # Use stable for this to ensure that cargo-tarpaulin can be built.
+#       - id: prepare
+#         uses: ./.github/actions/prepare
+#         with:
+#           toolchain: stable
+#           nightly-features: true
+#       - name: Install cargo-tarpaulin
+#         uses: actions-rs/cargo@v1
+#         with:
+#           command: install
+#           args: cargo-tarpaulin
+#       - name: Generate coverage report
+#         uses: actions-rs/cargo@v1
+#         with:
+#           command: tarpaulin
+#           args: >
+#             ${{ steps.prepare.outputs.feature-flags }}
+#             --timeout 600
+#             --out Xml
+#       - name: Upload coverage to Codecov
+#         uses: codecov/[email protected]
 
   doc-links:
     name: Intra-doc links

book/book.toml

@@ -14,8 +14,6 @@ title = "The halo2 Book"
 macros = "macros.txt"
 renderers = ["html"]
 
-[output.katex]
-
 [output.html]
 
 [output.html.print]

book/src/SUMMARY.md

@@ -35,11 +35,14 @@
       - [Incomplete and complete addition](design/gadgets/ecc/addition.md)
       - [Fixed-base scalar multiplication](design/gadgets/ecc/fixed-base-scalar-mul.md)
       - [Variable-base scalar multiplication](design/gadgets/ecc/var-base-scalar-mul.md)
+      - [Variable-base sign-scalar multiplication](design/gadgets/ecc/var-base-sign-scalar-mul.md)
+    - [Decomposition](design/gadgets/decomposition.md)
     - [Sinsemilla](design/gadgets/sinsemilla.md)
+      - [Combined lookup table](design/gadgets/sinsemilla/combined_lookups.md)
       - [MerkleCRH](design/gadgets/sinsemilla/merkle-crh.md)
-    - [Decomposition](design/gadgets/decomposition.md)
     - [SHA-256](design/gadgets/sha256.md)
       - [16-bit table chip](design/gadgets/sha256/table16.md)
+    - [Conditional swap](design/gadgets/cond_swap.md)
 - [Background Material](background.md)
   - [Fields](background/fields.md)
   - [Polynomials](background/polynomials.md)

book/src/design/gadgets/cond_swap.md

@@ -0,0 +1,137 @@
+# Conditional swap
+
+The conditional swap gadgets include two instructions: swap and multiplexer (mux).
+We use a multiplexer to compute differently for ZEC or for non-ZEC assets in Orchard protocol.
+The graph shows where each new gadget (hash from private initial point and MUX on non-identity points) will be used.
+
+![](https://imgur.com/kDQLoQQ.png)
+
+## Multiplexer
+
+Given a boolean flag $\textsf{choice}$, mux is used for selecting one of two values ($\textsf{left}$ and $\textsf{right}$) based on the boolean flag.
+If $\textsf{choice}$ is true, it returns $\textsf{right}$; otherwise, it returns $\textsf{left}$. This functionality is crucial for circuits that require conditional logic.
+
+
+## Chip instructions
+
+```rust,ignore,no_run
+pub trait CondSwapInstructions<F: Field>: UtilitiesInstructions<F> {
+    /// Given an input `(choice, left, right)` where `choice` is a boolean flag,
+    /// returns `left` if `choice` is not set and `right` if `choice` is set.
+    fn mux(
+        &self,
+        layouter: &mut impl Layouter<F>,
+        choice: Self::Var,
+        left: Self::Var,
+        right: Self::Var,
+    ) -> Result<Self::Var, Error>;
+}
+```
+
+## Implement chip traits
+
+```rust,ignore,no_run
+impl<F: PrimeField> CondSwapInstructions<F> for CondSwapChip<F> {
+    fn mux(
+        &self,
+        layouter: &mut impl Layouter<F>,
+        choice: Self::Var,
+        left: Self::Var,
+        right: Self::Var,
+    ) -> Result<Self::Var, Error> {
+        let config = self.config();
+
+        layouter.assign_region(
+            || "mux",
+            |mut region| {
+                // Enable `q_swap` selector
+                config.q_swap.enable(&mut region, 0)?;
+
+                // Copy in `a` value
+                let left = left.copy_advice(|| "copy left", &mut region, config.a, 0)?;
+
+                // Copy in `b` value
+                let right = right.copy_advice(|| "copy right", &mut region, config.b, 0)?;
+
+                // Copy `choice` value
+                let choice = choice.copy_advice(|| "copy choice", &mut region, config.swap, 0)?;
+
+                let a_swapped = left
+                    .value()
+                    .zip(right.value())
+                    .zip(choice.value())
+                    .map(|((left, right), choice)| {
+                        if *choice == F::from(0_u64) {
+                            left
+                        } else {
+                            right
+                        }
+                    })
+                    .cloned();
+                let b_swapped = left
+                    .value()
+                    .zip(right.value())
+                    .zip(choice.value())
+                    .map(|((left, right), choice)| {
+                        if *choice == F::from(0_u64) {
+                            right
+                        } else {
+                            left
+                        }
+                    })
+                    .cloned();
+
+                region.assign_advice(|| "out b_swap", self.config.b_swapped, 0, || b_swapped)?;
+                region.assign_advice(|| "out a_swap", self.config.a_swapped, 0, || a_swapped)
+            },
+        )
+    }
+}
+```
+
+## Multiplexer logic on ECC Points
+
+Mux can also be extended to work with elliptic curve points, facilitating operations like conditional selections between points. 
+Based on a boolean flag $\textsf{choice}$, it selects between two given points $\textsf{left}$ and $\textsf{right}$. 
+If $\textsf{choice}$ is true, it returns the point $\textsf{right}$; otherwise, it returns the point $\textsf{left}$. 
+
+```rust,ignore,no_run
+impl CondSwapChip<pallas::Base> {
+    /// Given an input `(choice, left, right)` where `choice` is a boolean flag and `left` and `right` are `EccPoint`,
+    /// returns `left` if `choice` is not set and `right` if `choice` is set.
+    pub fn mux_on_points(
+        &self,
+        mut layouter: impl Layouter<pallas::Base>,
+        choice: &AssignedCell<pallas::Base, pallas::Base>,
+        left: &EccPoint,
+        right: &EccPoint,
+    ) -> Result<EccPoint, plonk::Error> {
+        let x_cell = self.mux(&mut layouter, choice.clone(), left.x(), right.x())?;
+        let y_cell = self.mux(&mut layouter, choice.clone(), left.y(), right.y())?;
+        Ok(EccPoint::from_coordinates_unchecked(
+            x_cell.into(),
+            y_cell.into(),
+        ))
+    }
+
+    /// Given an input `(choice, left, right)` where `choice` is a boolean flag and `left` and `right` are
+    /// `NonIdentityEccPoint`, returns `left` if `choice` is not set and `right` if `choice` is set.
+    pub fn mux_on_non_identity_points(
+        &self,
+        mut layouter: impl Layouter<pallas::Base>,
+        choice: &AssignedCell<pallas::Base, pallas::Base>,
+        left: &NonIdentityEccPoint,
+        right: &NonIdentityEccPoint,
+    ) -> Result<NonIdentityEccPoint, plonk::Error> {
+        let x_cell = self.mux(&mut layouter, choice.clone(), left.x(), right.x())?;
+        let y_cell = self.mux(&mut layouter, choice.clone(), left.y(), right.y())?;
+        Ok(NonIdentityEccPoint::from_coordinates_unchecked(
+            x_cell.into(),
+            y_cell.into(),
+        ))
+    }
+}
+```
+
+
+