Merge pull request #83214 from slavapestov/monoids

New "Monoids" benchmark

Author: slavapestov

benchmark/CMakeLists.txt

@@ -220,12 +220,24 @@ set(SWIFT_BENCH_MODULES
 
 set(SWIFT_MULTISOURCE_SWIFT_BENCHES
   multi-source/PrimsSplit
+  multi-source/Monoids
 )
 
 set(PrimsSplit_sources
     multi-source/PrimsSplit/Prims.swift
     multi-source/PrimsSplit/Prims_main.swift)
 
+set(Monoids_sources
+    multi-source/Monoids/Automaton.swift
+    multi-source/Monoids/Benchmark.swift
+    multi-source/Monoids/Enumeration.swift
+    multi-source/Monoids/Monoids.swift
+    multi-source/Monoids/Presentation.swift
+    multi-source/Monoids/RewritingSystem.swift
+    multi-source/Monoids/Solver.swift
+    multi-source/Monoids/Strategy.swift
+    multi-source/Monoids/Trie.swift)
+
 set(BENCH_DRIVER_LIBRARY_FLAGS)
 if (SWIFT_RUNTIME_ENABLE_LEAK_CHECKER)
   set(BENCH_DRIVER_LIBRARY_FLAGS -DSWIFT_RUNTIME_ENABLE_LEAK_CHECKER)

benchmark/Package.swift

@@ -178,17 +178,22 @@ targets += multiSourceLibraries.map { lib in
     dependencies: [
       .target(name: "TestsUtils")
     ],
-    path: lib.parentSubDir)
+    path: "\(lib.parentSubDir)/\(lib.name)")
 }
 
 //===---
 // Top Level Definition
 //
 
-let p = Package(
+var p = Package(
   name: "swiftbench",
   products: products,
   targets: targets,
   swiftLanguageVersions: [.v4],
   cxxLanguageStandard: .cxx20
 )
+
+// Let's build for Swift 5.5-aligned runtimes.
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+p.platforms = [.macOS(.v12), .iOS(.v15), .watchOS(.v8), .tvOS(.v15)]
+#endif

benchmark/multi-source/Monoids/Automaton.swift

@@ -0,0 +1,169 @@
+/// This file implements an algorithm to compute the number of elements in a
+/// monoid (or determine it is infinite), given a complete presentation.
+
+/// A finite state automaton, given by a set of vertices and edges.
+struct Automaton {
+  var states: [Word] = []
+  var transitions: [(Word, Symbol, Word)] = []
+}
+
+extension Automaton {
+  var hasStar: Bool {
+    for state in states {
+      var visited = Set<Word>()
+
+      func rec(_ state: Word) -> Bool {
+        for (from, _, to) in transitions {
+          if from == state {
+            if visited.contains(to) {
+              return true
+            } else {
+              visited.insert(to)
+              if rec(to) { return true }
+              visited.remove(to)
+            }
+          }
+        }
+
+        return false
+      }
+
+      visited.insert(state)
+      if rec(state) { return true }
+      visited.remove(state)
+    }
+
+    return false
+  }
+
+  /// If this automaton is star-free, count the number of unique words accepted.
+  var countWords: Int {
+    func R(_ q: Word) -> [Word] {
+      var result: [Word] = []
+
+      for (from, _, to) in transitions {
+        if to == q {
+          result.append(from)
+        }
+      }
+
+      return result
+    }
+
+    func T(_ q: Word, _ p: Word) -> Int {
+      var letters = Set<Symbol>()
+      for (from, x, to) in transitions {
+        if from == q && to == p {
+          letters.insert(x)
+        }
+      }
+      return letters.count
+    }
+
+    func N(_ q: Word) -> Int {
+      if q == [] {
+        return 1
+      }
+
+      var result = 0
+      for p in R(q) {
+        result += N(p) * T(p, q)
+      }
+      return result
+    }
+
+    var result = 0
+
+    for q in states {
+      result += N(q)
+    }
+
+    return result
+  }
+}
+
+/// Constructs an automaton to recognize the complement of this regular set:
+///
+///   .*(x1|x2|...).*
+///
+/// where 'words' is [x1, x2, ...].
+///
+/// This is Lemma 2.1.3 in:
+///
+/// String Rewriting Systems, R.V. Book, F. Otto 1993. Springer New York.
+func buildAutomaton(_ words: [Word], _ alphabet: Int) -> Automaton {
+  // Proper prefixes of each word.
+  var prefixes = Set<Word>()
+
+  var result = Automaton()
+
+  func isIrreducible(_ word: Word) -> Bool {
+    for i in 0 ..< word.count {
+      for other in words {
+        if i + other.count <= word.count {
+          if Word(word[i ..< (i + other.count)]) == other {
+            return false
+          }
+        }
+      }
+    }
+
+    return true
+  }
+
+  prefixes.insert([])
+  for word in words {
+    for i in 0 ..< word.count {
+      let prefix = Word(word[0 ..< i])
+      prefixes.insert(prefix)
+    }
+  }
+
+  result.states = prefixes.sorted { compare($0, $1, order: .shortlex) == .lessThan }
+
+  for prefix in prefixes {
+    for x in 0 ..< UInt8(alphabet) {
+      let word = prefix + [x]
+
+      if prefixes.contains(word) {
+        result.transitions.append((prefix, x, word))
+        continue
+      }
+
+      if !isIrreducible(word) {
+        continue
+      }
+
+      for i in 1 ... word.count {
+        let suffix = Word(word[i...])
+
+        if prefixes.contains(suffix) {
+          result.transitions.append((prefix, x, suffix))
+          break
+        }
+      }
+    }
+  }
+
+  return result
+}
+
+extension Presentation {
+  /// The Irr(R) automaton.
+  func automaton(alphabet: Int) -> Automaton {
+    return buildAutomaton(rules.map { $0.lhs }, alphabet)
+  }
+
+  /// Returns the number of irreducible words in this monoid presentation, or
+  /// nil if this set is infinite.
+  ///
+  /// If the presentation is complete, this is the cardinality of the
+  /// presented monoid. Otherwise, it is an upper bound.
+  func cardinality(alphabet: Int) -> Int? {
+    let automaton = automaton(alphabet: alphabet)
+    if automaton.hasStar {
+      return nil
+    }
+    return automaton.countWords
+  }
+}

benchmark/multi-source/Monoids/Benchmark.swift

@@ -0,0 +1,20 @@
+import TestsUtils
+import Dispatch
+
+public let benchmarks = [
+  BenchmarkInfo(
+    name: "Monoids",
+    runFunction: run_Monoids,
+    tags: [.algorithm])
+]
+
+func run_Monoids(_ n: Int) {
+  let semaphore = DispatchSemaphore(value: 0)
+  for _ in 0 ... n {
+    Task {
+      await run(output: false)
+      semaphore.signal()
+    }
+    semaphore.wait()
+  }
+}