Merge BlockstreamResearch#212: Typed value

e5afbb0 Bit Machine: Handle wrong input during execution (Christian Lewe)
f562d73 Bit Machine: Handle empty input (Christian Lewe)
93a83b1 Bit Machine: Check type of input (Christian Lewe)
df31202 Value: Check for emptiness (Christian Lewe)
e99cf03 Value: Test type checker (Christian Lewe)
d27b143 Value: Add type checker (Christian Lewe)
5e7616a Value: Add conversion methods (Christian Lewe)
fac715d Final: split_* -> as_* (Christian Lewe)

Pull request description:

  Add type checker to values and use it in the Bit Machine. This is particularly useful for running expressions with non-unit input types.

ACKs for top commit:
  apoelstra:
    ACK e5afbb0

Tree-SHA512: 4cea989243d25f2161941b97a98b39888e7ccb8821b7448e7f424321c78888b20932f1ef22738c79ff389b51183c791b876337d66d88becfdfda62e826e044d7

Author: apoelstra

src/bit_machine/mod.rs

@@ -16,6 +16,7 @@ use crate::analysis;
 use crate::dag::{DagLike, NoSharing};
 use crate::jet::{Jet, JetFailed};
 use crate::node::{self, RedeemNode};
+use crate::types::Final;
 use crate::{Cmr, FailEntropy, Value};
 use frame::Frame;
 
@@ -30,6 +31,8 @@ pub struct BitMachine {
     read: Vec<Frame>,
     /// Write frame stack
     write: Vec<Frame>,
+    /// Acceptable source type
+    source_ty: Arc<Final>,
 }
 
 impl BitMachine {
@@ -42,6 +45,7 @@ impl BitMachine {
             next_frame_start: 0,
             read: Vec::with_capacity(program.bounds().extra_frames + analysis::IO_EXTRA_FRAMES),
             write: Vec::with_capacity(program.bounds().extra_frames + analysis::IO_EXTRA_FRAMES),
+            source_ty: program.arrow().source.clone(),
         }
     }
 
@@ -193,11 +197,17 @@ impl BitMachine {
 
     /// Add a read frame with some given value in it, as input to the
     /// program
-    pub fn input(&mut self, input: &Value) {
-        // FIXME typecheck this
-        self.new_frame(input.len());
-        self.write_value(input);
-        self.move_frame();
+    pub fn input(&mut self, input: &Value) -> Result<(), ExecutionError> {
+        if !input.is_of_type(&self.source_ty) {
+            return Err(ExecutionError::InputWrongType(self.source_ty.clone()));
+        }
+        // Unit value doesn't need extra frame
+        if !input.is_empty() {
+            self.new_frame(input.len());
+            self.write_value(input);
+            self.move_frame();
+        }
+        Ok(())
     }
 
     /// Execute the given program on the Bit Machine, using the given environment.
@@ -229,16 +239,14 @@ impl BitMachine {
             }
         }
 
+        if self.read.is_empty() != self.source_ty.is_empty() {
+            return Err(ExecutionError::InputWrongType(self.source_ty.clone()));
+        }
+
         let mut ip = program;
         let mut call_stack = vec![];
         let mut iterations = 0u64;
 
-        let input_width = ip.arrow().source.bit_width();
-        // TODO: convert into crate::Error
-        assert!(
-            self.read.is_empty() || input_width > 0,
-            "Program requires a non-empty input to execute",
-        );
         let output_width = ip.arrow().target.bit_width();
         if output_width > 0 {
             self.new_frame(output_width);
@@ -257,14 +265,14 @@ impl BitMachine {
                     self.copy(size_a);
                 }
                 node::Inner::InjL(left) => {
-                    let (b, _c) = ip.arrow().target.split_sum().unwrap();
+                    let (b, _c) = ip.arrow().target.as_sum().unwrap();
                     let padl_b_c = ip.arrow().target.bit_width() - b.bit_width() - 1;
                     self.write_bit(false);
                     self.skip(padl_b_c);
                     call_stack.push(CallStack::Goto(left));
                 }
                 node::Inner::InjR(left) => {
-                    let (_b, c) = ip.arrow().target.split_sum().unwrap();
+                    let (_b, c) = ip.arrow().target.as_sum().unwrap();
                     let padr_b_c = ip.arrow().target.bit_width() - c.bit_width() - 1;
                     self.write_bit(true);
                     self.skip(padr_b_c);
@@ -305,16 +313,16 @@ impl BitMachine {
                 }
                 node::Inner::Take(left) => call_stack.push(CallStack::Goto(left)),
                 node::Inner::Drop(left) => {
-                    let size_a = ip.arrow().source.split_product().unwrap().0.bit_width();
+                    let size_a = ip.arrow().source.as_product().unwrap().0.bit_width();
                     self.fwd(size_a);
                     call_stack.push(CallStack::Back(size_a));
                     call_stack.push(CallStack::Goto(left));
                 }
                 node::Inner::Case(..) | node::Inner::AssertL(..) | node::Inner::AssertR(..) => {
                     let choice_bit = self.read[self.read.len() - 1].peek_bit(&self.data);
 
-                    let (sum_a_b, _c) = ip.arrow().source.split_product().unwrap();
-                    let (a, b) = sum_a_b.split_sum().unwrap();
+                    let (sum_a_b, _c) = ip.arrow().source.as_product().unwrap();
+                    let (a, b) = sum_a_b.as_sum().unwrap();
                     let size_a = a.bit_width();
                     let size_b = b.bit_width();
 
@@ -484,6 +492,8 @@ impl BitMachine {
 /// Errors related to simplicity Execution
 #[derive(Debug)]
 pub enum ExecutionError {
+    /// Provided input is of wrong type
+    InputWrongType(Arc<Final>),
     /// Reached a fail node
     ReachedFailNode(FailEntropy),
     /// Reached a pruned branch
@@ -495,6 +505,9 @@ pub enum ExecutionError {
 impl fmt::Display for ExecutionError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            ExecutionError::InputWrongType(expected_ty) => {
+                write!(f, "Expected input of type: {expected_ty}")
+            }
             ExecutionError::ReachedFailNode(entropy) => {
                 write!(f, "Execution reached a fail node: {}", entropy)
             }

src/merkle/amr.rs

@@ -48,7 +48,7 @@ impl Amr {
     /// Produce a CMR for an injl combinator
     pub fn injl(ty: &FinalArrow, child: Amr) -> Self {
         let a = &ty.source;
-        let (b, c) = ty.target.split_sum().unwrap();
+        let (b, c) = ty.target.as_sum().unwrap();
         Self::INJL_IV
             .update(a.tmr().into(), b.tmr().into())
             .update(c.tmr().into(), child)
@@ -57,15 +57,15 @@ impl Amr {
     /// Produce a CMR for an injr combinator
     pub fn injr(ty: &FinalArrow, child: Amr) -> Self {
         let a = &ty.source;
-        let (b, c) = ty.target.split_sum().unwrap();
+        let (b, c) = ty.target.as_sum().unwrap();
         Self::INJR_IV
             .update(a.tmr().into(), b.tmr().into())
             .update(c.tmr().into(), child)
     }
 
     /// Produce a CMR for a take combinator
     pub fn take(ty: &FinalArrow, child: Amr) -> Self {
-        let (a, b) = ty.source.split_product().unwrap();
+        let (a, b) = ty.source.as_sum().unwrap();
         let c = &ty.target;
         Self::TAKE_IV
             .update(a.tmr().into(), b.tmr().into())
@@ -74,7 +74,7 @@ impl Amr {
 
     /// Produce a CMR for a drop combinator
     pub fn drop(ty: &FinalArrow, child: Amr) -> Self {
-        let (a, b) = ty.source.split_product().unwrap();
+        let (a, b) = ty.source.as_product().unwrap();
         let c = &ty.target;
         Self::DROP_IV
             .update(a.tmr().into(), b.tmr().into())
@@ -93,8 +93,8 @@ impl Amr {
     }
 
     fn case_helper(iv: Amr, ty: &FinalArrow, left: Amr, right: Amr) -> Self {
-        let (sum_a_b, c) = ty.source.split_product().unwrap();
-        let (a, b) = sum_a_b.split_sum().unwrap();
+        let (sum_a_b, c) = ty.source.as_product().unwrap();
+        let (a, b) = sum_a_b.as_sum().unwrap();
         let d = &ty.target;
         iv.update(a.tmr().into(), b.tmr().into())
             .update(c.tmr().into(), d.tmr().into())
@@ -136,7 +136,7 @@ impl Amr {
     /// Produce a CMR for a disconnect combinator
     pub fn disconnect(ty: &FinalArrow, right_arrow: &FinalArrow, left: Amr, right: Amr) -> Self {
         let a = &ty.source;
-        let (b, d) = ty.target.split_product().unwrap();
+        let (b, d) = ty.target.as_product().unwrap();
         let c = &right_arrow.source;
         Self::DISCONNECT_IV
             .update(a.tmr().into(), b.tmr().into())

src/types/final_data.rs

@@ -191,28 +191,34 @@ impl Final {
         self.bit_width
     }
 
+    /// Check if the type is a nested product of units.
+    /// In this case, values contain no information.
+    pub fn is_empty(&self) -> bool {
+        self.bit_width() == 0
+    }
+
     /// Accessor for the type bound
     pub fn bound(&self) -> &CompleteBound {
         &self.bound
     }
 
-    /// Returns whether this is the unit type
+    /// Check if the type is a unit.
     pub fn is_unit(&self) -> bool {
         self.bound == CompleteBound::Unit
     }
 
-    /// Return both children, if the type is a sum type
-    pub fn split_sum(&self) -> Option<(Arc<Self>, Arc<Self>)> {
+    /// Access the inner types of a sum type.
+    pub fn as_sum(&self) -> Option<(&Self, &Self)> {
         match &self.bound {
-            CompleteBound::Sum(left, right) => Some((left.clone(), right.clone())),
+            CompleteBound::Sum(left, right) => Some((left.as_ref(), right.as_ref())),
             _ => None,
         }
     }
 
-    /// Return both children, if the type is a product type
-    pub fn split_product(&self) -> Option<(Arc<Self>, Arc<Self>)> {
+    /// Access the inner types of a product type.
+    pub fn as_product(&self) -> Option<(&Self, &Self)> {
         match &self.bound {
-            CompleteBound::Product(left, right) => Some((left.clone(), right.clone())),
+            CompleteBound::Product(left, right) => Some((left.as_ref(), right.as_ref())),
             _ => None,
         }
     }

src/value.rs

@@ -6,6 +6,7 @@
 //! i.e., inputs, intermediate results and outputs.
 
 use crate::dag::{Dag, DagLike, NoSharing};
+use crate::types::Final;
 
 use std::collections::VecDeque;
 use std::convert::TryInto;
@@ -83,14 +84,48 @@ impl Value {
         Arc::new(Value::Prod(left, right))
     }
 
-    #[allow(clippy::len_without_is_empty)]
     /// The length, in bits, of the value when encoded in the Bit Machine
     pub fn len(&self) -> usize {
         self.pre_order_iter::<NoSharing>()
             .filter(|inner| matches!(inner, Value::SumL(_) | Value::SumR(_)))
             .count()
     }
 
+    /// Check if the value is a nested product of units.
+    /// In this case, the value contains no information.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Check if the value is a unit.
+    pub fn is_unit(&self) -> bool {
+        matches!(self, Value::Unit)
+    }
+
+    /// Access the inner value of a left sum value.
+    pub fn as_left(&self) -> Option<&Self> {
+        match self {
+            Value::SumL(inner) => Some(inner.as_ref()),
+            _ => None,
+        }
+    }
+
+    /// Access the inner value of a right sum value.
+    pub fn as_right(&self) -> Option<&Self> {
+        match self {
+            Value::SumR(inner) => Some(inner.as_ref()),
+            _ => None,
+        }
+    }
+
+    /// Access the inner values of a product value.
+    pub fn as_product(&self) -> Option<(&Self, &Self)> {
+        match self {
+            Value::Prod(left, right) => Some((left.as_ref(), right.as_ref())),
+            _ => None,
+        }
+    }
+
     /// Encode a single bit as a value. Will panic if the input is out of range
     pub fn u1(n: u8) -> Arc<Self> {
         match n {
@@ -264,6 +299,36 @@ impl Value {
 
         (bytes, bit_length)
     }
+
+    /// Check if the value is of the given type.
+    pub fn is_of_type(&self, ty: &Final) -> bool {
+        let mut stack = vec![(self, ty)];
+
+        while let Some((value, ty)) = stack.pop() {
+            if ty.is_unit() {
+                if !value.is_unit() {
+                    return false;
+                }
+            } else if let Some((ty_l, ty_r)) = ty.as_sum() {
+                if let Some(value_l) = value.as_left() {
+                    stack.push((value_l, ty_l));
+                } else if let Some(value_r) = value.as_right() {
+                    stack.push((value_r, ty_r));
+                } else {
+                    return false;
+                }
+            } else if let Some((ty_l, ty_r)) = ty.as_product() {
+                if let Some((value_l, value_r)) = value.as_product() {
+                    stack.push((value_r, ty_r));
+                    stack.push((value_l, ty_l));
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        true
+    }
 }
 
 impl fmt::Debug for Value {
@@ -308,6 +373,7 @@ impl fmt::Display for Value {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::jet::type_name::TypeName;
 
     #[test]
     fn value_display() {
@@ -317,4 +383,23 @@ mod tests {
         assert_eq!(Value::u1(1).to_string(), "1",);
         assert_eq!(Value::u4(6).to_string(), "((0,1),(1,0))",);
     }
+
+    #[test]
+    fn is_of_type() {
+        let value_typename = [
+            (Value::unit(), TypeName(b"1")),
+            (Value::sum_l(Value::unit()), TypeName(b"+11")),
+            (Value::sum_r(Value::unit()), TypeName(b"+11")),
+            (Value::sum_l(Value::unit()), TypeName(b"+1h")),
+            (Value::sum_r(Value::unit()), TypeName(b"+h1")),
+            (Value::prod(Value::unit(), Value::unit()), TypeName(b"*11")),
+            (Value::u8(u8::MAX), TypeName(b"c")),
+            (Value::u64(u64::MAX), TypeName(b"l")),
+        ];
+
+        for (value, typename) in value_typename {
+            let ty = typename.to_final();
+            assert!(value.is_of_type(ty.as_ref()));
+        }
+    }
 }