Merge #269: Followups to #266 -- more Value optimizations

de20a3b value: inline single-use private from_bits function (Andrew Poelstra)
e025850 value: shortcut pruning when the types are the same (Andrew Poelstra)
843fb2b value: speed up zero (Andrew Poelstra)
c22b67d value: use `has_padding` to speed up `from_compact_bits` (Andrew Poelstra)
d807968 types: add `has_padding` marker to `Final` (Andrew Poelstra)
0072917 value: remove now-unused Padding trait (Andrew Poelstra)
09cdded value: implement padded bit decoding directly (Andrew Poelstra)
57da572 value: promote ValueRef to public type, use it for recursion (Andrew Poelstra)
4d4dce7 value: rename internal `as_value` function to `as_ref` (Andrew Poelstra)
dcb2e81 value: add benchmark for giant product of 2^512 x 2^256 (Andrew Poelstra)
b7a5ff9 rename POWERS_OF_TWO across the codebase to TWO_TWO_N (Andrew Poelstra)

Pull request description:

  This cleans up the `Value` API by making `ValueRef` public and using it in place of the slow and redundant `Value::to_*` methods.

  It also renames `Tmr::POWERS_OF_TWO` which was noticed as a confusing name.

  It adds a `types::Final::has_padding` accessor and uses it to dramatically speed up bit decoding for values.

  During pruning, it notices when there is nothing to do (when pruning a value to the type that it already has) and shortcuts.

  Unlike #266, this one leaves the API in better shape than it was before, and should be reasonably easy to review. It hsa a lot of commits but they are all pretty small.

  Fixes #268

ACKs for top commit:
  uncomputable:
    ACK de20a3b

Tree-SHA512: ee373e712e086ed5691fdb0c313b6ae4e2c39fc0ba5ebd1388537883734bd34674ede9ae669f291324ee42fff45a701e010a7fda4cb35c0feec57b7a1a85a8c4

Author: uncomputable

src/merkle/cmr.rs

@@ -121,7 +121,7 @@ impl Cmr {
         let imr_iv = Self::CONST_WORD_IV;
         let imr_pass1 = imr_iv.update_1(cmr_stack[0]);
         // 2. Add TMRs to get the pass-two IMR
-        let imr_pass2 = imr_pass1.update(Tmr::unit().into(), Tmr::POWERS_OF_TWO[w - 1].into());
+        let imr_pass2 = imr_pass1.update(Tmr::unit().into(), Tmr::TWO_TWO_N[w - 1].into());
         // 3. Convert to a jet CMR
         Cmr(bip340_iv(b"Simplicity\x1fJet")).update_with_weight(word.len() as u64, imr_pass2)
     }

src/merkle/tmr.rs

@@ -41,7 +41,7 @@ impl Tmr {
 
     /// The TMRs of the types TWO^(2^n) for small values of n
     #[rustfmt::skip]
-    pub const POWERS_OF_TWO: [Tmr; 32] = [
+    pub const TWO_TWO_N: [Tmr; 32] = [
         Tmr(Midstate([
             0x88, 0x5a, 0x22, 0xde, 0x3e, 0xdb, 0x3f, 0x40,
             0xdb, 0x06, 0x09, 0xc2, 0x40, 0x23, 0x30, 0x3f,
@@ -305,14 +305,14 @@ mod tests {
             assert_eq!(target, expected_tmrs[i], "mismatch on TMR for TWO^(2^{i})");
         }
 
-        let n = Tmr::POWERS_OF_TWO.len();
+        let n = Tmr::TWO_TWO_N.len();
         let tmrs = types::Type::powers_of_two(&types::Context::new(), n)
             .iter()
             .filter_map(types::Type::tmr)
             .collect::<Vec<Tmr>>();
         debug_assert_eq!(tmrs.len(), n);
         for i in 0..n {
-            check_pow(Tmr::POWERS_OF_TWO[i], i, &tmrs);
+            check_pow(Tmr::TWO_TWO_N[i], i, &tmrs);
         }
     }
 }

src/node/mod.rs

@@ -187,15 +187,17 @@ pub trait CoreConstructible: Sized {
     ///
     /// The expression is minimized by using as many word jets as possible.
     fn scribe(ctx: &types::Context, value: &Value) -> Self {
+        use crate::value::ValueRef;
+
         #[derive(Debug, Clone)]
-        enum Task {
-            Process(Value),
+        enum Task<'v> {
+            Process(ValueRef<'v>),
             MakeLeft,
             MakeRight,
             MakeProduct,
         }
 
-        let mut input = vec![Task::Process(value.shallow_clone())];
+        let mut input = vec![Task::Process(value.as_ref())];
         let mut output = vec![];
         while let Some(top) = input.pop() {
             match top {
@@ -204,13 +206,13 @@ pub trait CoreConstructible: Sized {
                         output.push(Self::unit(ctx));
                     } else if let Some(word) = value.to_word() {
                         output.push(Self::const_word(ctx, word));
-                    } else if let Some(left) = value.to_left() {
+                    } else if let Some(left) = value.as_left() {
                         input.push(Task::MakeLeft);
                         input.push(Task::Process(left));
-                    } else if let Some(right) = value.to_right() {
+                    } else if let Some(right) = value.as_right() {
                         input.push(Task::MakeRight);
                         input.push(Task::Process(right));
-                    } else if let Some((left, right)) = value.to_product() {
+                    } else if let Some((left, right)) = value.as_product() {
                         input.push(Task::MakeProduct);
                         input.push(Task::Process(right));
                         input.push(Task::Process(left));

src/types/final_data.rs

@@ -36,6 +36,10 @@ pub struct Final {
     bound: CompleteBound,
     /// Width of the type, in bits, in the bit machine
     bit_width: usize,
+    /// Whether the type's bit representation has any padding. If this is true,
+    /// then its "compact" witness-encoded bit-width may be lower than its "padded"
+    /// bit-machine bit-width.
+    has_padding: bool,
     /// TMR of the type
     tmr: Tmr,
 }
@@ -83,11 +87,11 @@ impl fmt::Display for Final {
                 }
                 continue;
             } else {
-                if data.node.tmr == Tmr::POWERS_OF_TWO[0] {
+                if data.node.tmr == Tmr::TWO_TWO_N[0] {
                     f.write_str("2")?;
                     skipping = Some(data.node.tmr);
                 }
-                for (n, tmr) in Tmr::POWERS_OF_TWO.iter().enumerate().skip(1) {
+                for (n, tmr) in Tmr::TWO_TWO_N.iter().enumerate().skip(1) {
                     if data.node.tmr == *tmr {
                         write!(f, "2^{}", 1 << n)?;
                         skipping = Some(data.node.tmr);
@@ -165,6 +169,7 @@ impl Final {
         Arc::new(Final {
             bound: CompleteBound::Unit,
             bit_width: 0,
+            has_padding: false,
             tmr: Tmr::unit(),
         })
     }
@@ -192,6 +197,7 @@ impl Final {
         Arc::new(Final {
             tmr: Tmr::sum(left.tmr, right.tmr),
             bit_width: 1 + cmp::max(left.bit_width, right.bit_width),
+            has_padding: left.has_padding || right.has_padding || left.bit_width != right.bit_width,
             bound: CompleteBound::Sum(left, right),
         })
     }
@@ -201,6 +207,7 @@ impl Final {
         Arc::new(Final {
             tmr: Tmr::product(left.tmr, right.tmr),
             bit_width: left.bit_width + right.bit_width,
+            has_padding: left.has_padding || right.has_padding,
             bound: CompleteBound::Product(left, right),
         })
     }
@@ -215,6 +222,14 @@ impl Final {
         self.bit_width
     }
 
+    /// Whether the type's bit representation has any padding.
+    ///
+    /// If this is true, then its "compact" witness-encoded bit-width may be lower
+    /// than its "padded" bit-machine bit-width.
+    pub fn has_padding(&self) -> bool {
+        self.has_padding
+    }
+
     /// Check if the type is a nested product of units.
     /// In this case, values contain no information.
     pub fn is_empty(&self) -> bool {
@@ -254,7 +269,7 @@ impl Final {
     /// 0 ≤ n < 32.
     pub fn as_word(&self) -> Option<u32> {
         (0..32u32).find(|&n| {
-            self.tmr == Tmr::POWERS_OF_TWO[n as usize] // cast safety: 32-bit machine or higher
+            self.tmr == Tmr::TWO_TWO_N[n as usize] // cast safety: 32-bit machine or higher
         })
     }
 

src/types/precomputed.rs

@@ -21,10 +21,10 @@ use std::convert::TryInto;
 use std::sync::Arc;
 
 // Directly use the size of the precomputed TMR table to make sure they're in sync.
-const N_POWERS: usize = Tmr::POWERS_OF_TWO.len();
+const N_POWERS: usize = Tmr::TWO_TWO_N.len();
 
 thread_local! {
-    static POWERS_OF_TWO: RefCell<Option<[Arc<Final>; N_POWERS]>> = const { RefCell::new(None) };
+    static TWO_TWO_N: RefCell<Option<[Arc<Final>; N_POWERS]>> = const { RefCell::new(None) };
 }
 
 fn initialize(write: &mut Option<[Arc<Final>; N_POWERS]>) {
@@ -49,9 +49,9 @@ fn initialize(write: &mut Option<[Arc<Final>; N_POWERS]>) {
 ///
 /// # Panics
 ///
-/// Panics if you request a number `n` greater than or equal to [`Tmr::POWERS_OF_TWO`].
+/// Panics if you request a number `n` greater than or equal to [`Tmr::TWO_TWO_N`].
 pub fn nth_power_of_2(n: usize) -> Arc<Final> {
-    POWERS_OF_TWO.with(|arr| {
+    TWO_TWO_N.with(|arr| {
         if arr.borrow().is_none() {
             initialize(&mut arr.borrow_mut());
         }