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

Use ∧/∨ operators and #{...} ≥ k syntax so the output cannot be
confused with compilable concrete policy. Remove serde roundtrip
since Display is intentionally no longer parseable.

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.

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,25 @@ 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 compile_invalid() {
         // Since the root Error does not support Eq type, we have to

src/policy/semantic.rs

@@ -261,12 +261,26 @@ impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
             Policy::Ripemd160(ref h) => write!(f, "ripemd160({})", h),
             Policy::Hash160(ref h) => write!(f, "hash160({})", h),
             Policy::Thresh(ref thresh) => {
+                let mut iter = thresh.iter();
+                let first = iter.next().expect("thresholds are never empty");
                 if thresh.k() == thresh.n() {
-                    thresh.display("and", false).fmt(f)
+                    write!(f, "({}", first)?;
+                    for sub in iter {
+                        write!(f, " ∧ {}", sub)?;
+                    }
+                    f.write_str(")")
                 } else if thresh.k() == 1 {
-                    thresh.display("or", false).fmt(f)
+                    write!(f, "({}", first)?;
+                    for sub in iter {
+                        write!(f, " ∨ {}", sub)?;
+                    }
+                    f.write_str(")")
                 } else {
-                    thresh.display("thresh", true).fmt(f)
+                    write!(f, "#{{{}",  first)?;
+                    for sub in iter {
+                        write!(f, ", {}", sub)?;
+                    }
+                    write!(f, "}} ≥ {}", thresh.k())
                 }
             }
         }
@@ -281,7 +295,6 @@ impl<Pk: FromStrKey> str::FromStr for Policy<Pk> {
     }
 }
 
-serde_string_impl_pk!(Policy, "a miniscript semantic policy");
 
 impl<Pk: FromStrKey> expression::FromTree for Policy<Pk> {
     fn from_tree(root: expression::TreeIterItem) -> Result<Policy<Pk>, Error> {