feat(policy): change semantic::Policy Display to mathematical notation

Use (∧, ∨, #{...} = k) for visual distinction from concrete::Policy.
FromStr is extended to accept the new form so Display round-trips.
Policy::to_policy_syntax_string() emits the function-call form for
cross-version comparison; the regression fuzz target uses it.

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

@@ -14,31 +14,38 @@ fn do_test(data: &[u8]) {
         (Ok(x), Err(e)) => panic!("new logic parses {} as {:?}, old fails with {}", data_str, x, e),
         (Err(e), Ok(x)) => panic!("old logic parses {} as {:?}, new fails with {}", data_str, x, e),
         (Ok(new), Ok(old)) => {
-            use miniscript::policy::Liftable as _;
-            use old_miniscript::policy::Liftable as _;
-
             assert_eq!(
                 old.to_string(),
                 new.to_string(),
                 "input {} (left is old, right is new)",
                 data_str
             );
 
-            match (new.lift(), old.lift()) {
-                (Err(_), Err(_)) => {}
-                (Ok(x), Err(e)) => {
-                    panic!("new logic lifts {} as {:?}, old fails with {}", data_str, x, e)
-                }
-                (Err(e), Ok(x)) => {
-                    panic!("old logic lifts {} as {:?}, new fails with {}", data_str, x, e)
-                }
-                (Ok(new), Ok(old)) => {
-                    assert_eq!(
-                        old.to_string(),
-                        new.to_string(),
-                        "lifted input {} (left is old, right is new)",
-                        data_str
-                    )
+            // The current crate's semantic::Policy Display was changed to
+            // mathematical notation, which does not match old_miniscript's
+            // function-call format. Use to_policy_syntax_string() to
+            // serialize in the policy-syntax form so we can still do a full
+            // structural comparison across crate versions.
+            {
+                use miniscript::policy::Liftable as _;
+                use old_miniscript::policy::Liftable as _;
+
+                match (new.lift(), old.lift()) {
+                    (Err(_), Err(_)) => {}
+                    (Ok(x), Err(e)) => {
+                        panic!("new logic lifts {} as {:?}, old fails with {}", data_str, x, e)
+                    }
+                    (Err(e), Ok(x)) => {
+                        panic!("old logic lifts {} as {:?}, new fails with {}", data_str, x, e)
+                    }
+                    (Ok(new_lift), Ok(old_lift)) => {
+                        assert_eq!(
+                            old_lift.to_string(),
+                            new_lift.to_policy_syntax_string(),
+                            "lifted semantic policy mismatch for input {} (left is old, right is new as policy-syntax string)",
+                            data_str
+                        );
+                    }
                 }
             }
         }

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/policy/mod.rs

@@ -251,12 +251,6 @@ mod tests {
         assert_eq!(s.to_lowercase(), output.to_lowercase());
     }
 
-    fn semantic_policy_rtt(s: &str) {
-        let sem = SemanticPol::from_str(s).unwrap();
-        let output = sem.normalized().to_string();
-        assert_eq!(s.to_lowercase(), output.to_lowercase());
-    }
-
     #[test]
     fn test_timelock_validity() {
         // only height
@@ -279,17 +273,53 @@ mod tests {
         concrete_policy_rtt("or(99@pk(X),1@pk(Y))");
         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))");
-
         //fuzzer crashes
         assert!(ConcretePol::from_str("thresh()").is_err());
         assert!(SemanticPol::from_str("thresh(0)").is_err());
         assert!(SemanticPol::from_str("thresh()").is_err());
         concrete_policy_rtt("ripemd160()");
     }
 
+    #[test]
+    fn semantic_display_uses_mathematical_notation() {
+        let pol = SemanticPol::from_str("and(pk(A),pk(B))").unwrap();
+        assert_eq!(pol.normalized().to_string(), "(pk(A) ∧ pk(B))");
+
+        let pol = SemanticPol::from_str("or(pk(A),pk(B))").unwrap();
+        assert_eq!(pol.normalized().to_string(), "(pk(A) ∨ pk(B))");
+
+        let pol = SemanticPol::from_str("thresh(2,pk(A),pk(B),pk(C))").unwrap();
+        assert_eq!(pol.normalized().to_string(), "#{pk(A), pk(B), pk(C)} = 2");
+    }
+
+    #[test]
+    fn semantic_display_roundtrips_via_from_str() {
+        // from_str must accept the mathematical Display output so that
+        // `Display` and `FromStr` round-trip (a property serde relies on).
+        for s in [
+            "pk(A)",
+            "and(pk(A),pk(B))",
+            "or(pk(A),pk(B))",
+            "thresh(2,pk(A),pk(B),pk(C))",
+            "and(pk(A),or(pk(B),pk(C)))",
+            "thresh(2,pk(A),and(pk(B),pk(C)),pk(D))",
+        ] {
+            let pol = SemanticPol::from_str(s).unwrap().normalized();
+            let displayed = pol.to_string();
+            let reparsed = SemanticPol::from_str(&displayed).unwrap().normalized();
+            assert_eq!(pol, reparsed, "round-trip failed for {}", s);
+        }
+
+        // Parser must also accept direct mathematical-form input.
+        let math = "(pk(A) ∧ (pk(B) ∨ pk(C)))";
+        let fncall = "and(pk(A),or(pk(B),pk(C)))";
+        assert_eq!(SemanticPol::from_str(math).unwrap(), SemanticPol::from_str(fncall).unwrap(),);
+
+        let math = "#{pk(A), pk(B), pk(C)} = 2";
+        let fncall = "thresh(2,pk(A),pk(B),pk(C))";
+        assert_eq!(SemanticPol::from_str(math).unwrap(), SemanticPol::from_str(fncall).unwrap(),);
+    }
+
     #[test]
     fn compile_invalid() {
         // Since the root Error does not support Eq type, we have to