feat(policy): math notation for semantic::Policy (Display + Parser)

- Display: emit `(a ∧ b)`, `(a ∨ b)`, `#{...} = k` for and/or/thresh
- Parser: FromStr accepts math notation; legacy `and(...)`/`or(...)`/`thresh(...)` still parses
- Fuzz: roundtrip target asserts parse → display equality up to whitespace for math-form inputs

Author: febyeji

examples/htlc.rs

@@ -37,7 +37,7 @@ fn main() {
     // Lift the descriptor into an abstract policy.
     assert_eq!(
         format!("{}", htlc_descriptor.lift().unwrap()),
-        "or(and(pk(022222222222222222222222222222222222222222222222222222222222222222),sha256(1111111111111111111111111111111111111111111111111111111111111111)),and(pk(020202020202020202020202020202020202020202020202020202020202020202),older(4444)))"
+        "((pk(022222222222222222222222222222222222222222222222222222222222222222) ∧ sha256(1111111111111111111111111111111111111111111111111111111111111111)) ∨ (pk(020202020202020202020202020202020202020202020202020202020202020202) ∧ older(4444)))"
     );
 
     // Get the scriptPubkey for this Wsh descriptor.

fuzz/fuzz_targets/regression_descriptor_parse.rs

@@ -35,7 +35,7 @@ fn do_test(data: &[u8]) {
                 (Ok(new), Ok(old)) => {
                     assert_eq!(
                         old.to_string(),
-                        new.to_string(),
+                        new.to_policy_syntax_string(),
                         "lifted input {} (left is old, right is new)",
                         data_str
                     )

fuzz/fuzz_targets/roundtrip_semantic.rs

@@ -9,9 +9,17 @@ type Policy = policy::Semantic<String>;
 
 fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
+    let is_legacy = !data_str.starts_with('(')
+        && !data_str.contains('∧')
+        && !data_str.contains('∨')
+        && !data_str.contains("#{");
+    if is_legacy {
+        return;
+    }
     if let Ok(pol) = Policy::from_str(&data_str) {
         let output = pol.to_string();
-        assert_eq!(data_str.to_lowercase(), output.to_lowercase());
+        let strip_ws: fn(&str) -> String = |s| s.chars().filter(|c| !c.is_whitespace()).collect();
+        assert_eq!(strip_ws(&data_str), strip_ws(&output));
     }
 }
 

src/descriptor/mod.rs

@@ -2175,15 +2175,15 @@ pk(03f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8))";
         // Taproot structure is erased but key order preserved..
         let desc = Descriptor::<String>::from_str("tr(ROOT,{pk(A1),{pk(B1),pk(B2)}})").unwrap();
         let lift = desc.lift().unwrap();
-        assert_eq!(lift.to_string(), "or(pk(ROOT),or(pk(A1),pk(B1),pk(B2)))",);
+        assert_eq!(lift.to_string(), "(pk(ROOT) ∨ (pk(A1) ∨ pk(B1) ∨ pk(B2)))");
         let desc = Descriptor::<String>::from_str("tr(ROOT,{{pk(A1),pk(B1)},pk(B2)})").unwrap();
         let lift = desc.lift().unwrap();
-        assert_eq!(lift.to_string(), "or(pk(ROOT),or(pk(A1),pk(B1),pk(B2)))",);
+        assert_eq!(lift.to_string(), "(pk(ROOT) ∨ (pk(A1) ∨ pk(B1) ∨ pk(B2)))");
 
         // And normalization happens
         let desc = Descriptor::<String>::from_str("tr(ROOT,{0,{0,0}})").unwrap();
         let lift = desc.lift().unwrap();
-        assert_eq!(lift.to_string(), "or(pk(ROOT),UNSATISFIABLE)",);
+        assert_eq!(lift.to_string(), "(pk(ROOT) ∨ UNSATISFIABLE)");
     }
 
     #[test]

src/error.rs

@@ -29,6 +29,8 @@ pub enum ParseError {
     Num(crate::ParseNumError),
     /// Error parsing a string into an expression tree.
     Tree(crate::ParseTreeError),
+    /// Syntax error in the mathematical-notation form of a `policy::Semantic`.
+    Math(crate::MathSyntaxError),
 }
 
 impl ParseError {
@@ -54,6 +56,7 @@ impl fmt::Display for ParseError {
             ParseError::FromStr(ref e) => e.fmt(f),
             ParseError::Num(ref e) => e.fmt(f),
             ParseError::Tree(ref e) => e.fmt(f),
+            ParseError::Math(ref e) => e.fmt(f),
         }
     }
 }
@@ -67,6 +70,7 @@ impl error::Error for ParseError {
             ParseError::FromStr(..) => None,
             ParseError::Num(ref e) => Some(e),
             ParseError::Tree(ref e) => Some(e),
+            ParseError::Math(ref e) => Some(e),
         }
     }
 }

src/lib.rs

@@ -142,6 +142,7 @@ pub use crate::miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, S
 pub use crate::miniscript::decode::Terminal;
 pub use crate::miniscript::satisfy::{Preimage32, Satisfier};
 pub use crate::miniscript::{hash256, Miniscript};
+pub use crate::policy::semantic::MathSyntaxError;
 use crate::prelude::*;
 pub use crate::primitives::absolute_locktime::{AbsLockTime, AbsLockTimeError};
 pub use crate::primitives::relative_locktime::{RelLockTime, RelLockTimeError};

src/policy/mod.rs

@@ -280,8 +280,8 @@ mod tests {
         concrete_policy_rtt("and(pk(X),or(99@pk(Y),1@older(12960)))");
 
         semantic_policy_rtt("pk()");
-        semantic_policy_rtt("or(pk(X),pk(Y))");
-        semantic_policy_rtt("and(pk(X),pk(Y))");
+        semantic_policy_rtt("(pk(X) ∨ pk(Y))");
+        semantic_policy_rtt("(pk(X) ∧ pk(Y))");
 
         //fuzzer crashes
         assert!(ConcretePol::from_str("thresh()").is_err());