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/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()
+  }
+}

benchmark/multi-source/Monoids/Enumeration.swift

@@ -0,0 +1,167 @@
+/// This file implements algorithms for enumerating all monoid presentations
+/// up to a given length.
+
+func nextSymbol(_ s: inout Symbol, alphabet: Int) -> Bool {
+  precondition(alphabet > 0)
+  if s == alphabet - 1 {
+    s = 0
+    return true
+  }
+  s += 1
+  return false
+}
+
+func nextWord(_ word: inout Word, alphabet: Int) -> Bool {
+  var carry = true
+  for i in word.indices.reversed() {
+    carry = nextSymbol(&word[i], alphabet: alphabet)
+    if !carry { break }
+  }
+  return carry
+}
+
+func nextRule(_ rule: inout Rule, alphabet: Int) -> Bool {
+  if nextWord(&rule.rhs, alphabet: alphabet) {
+    rule.rhs = Word(repeating: 0, count: rule.rhs.count)
+    if nextWord(&rule.lhs, alphabet: alphabet) {
+      rule.lhs = Word(repeating: 0, count: rule.lhs.count)
+      return true
+    }
+  }
+  return false
+}
+
+func nextPresentation(_ p: inout Presentation, alphabet: Int) -> Bool {
+  precondition(!p.rules.isEmpty)
+  var carry = true
+  for i in p.rules.indices.reversed() {
+    carry = nextRule(&p.rules[i], alphabet: alphabet)
+    if !carry { break }
+  }
+  return carry
+}
+
+struct RuleShape {
+  var lhs: Int
+  var rhs: Int
+
+  var rule: Rule {
+    return Rule(lhs: Word(repeating: 0, count: lhs),
+                rhs: Word(repeating: 0, count: rhs))
+  }
+}
+
+struct PresentationShape {
+  var rules: [RuleShape]
+
+  var presentation: Presentation {
+    return Presentation(rules: rules.map { $0.rule })
+  }
+}
+
+func enumerateAll(alphabet: Int, shapes: [PresentationShape], output: Bool)
+    -> [Presentation] {
+  var filteredLHS = 0
+  var filteredRHS = 0
+  var filteredSymmetry = 0
+  var total = 0
+
+  var instances: [Presentation] = []
+  var unique: Set<Presentation> = []
+
+  let perms = allPermutations(alphabet)
+
+  for shape in shapes {
+    var p = shape.presentation
+    var done = false
+
+loop: while !done {
+      defer {
+        done = nextPresentation(&p, alphabet: alphabet)
+      }
+
+      total += 1
+
+      for n in 0 ..< p.rules.count - 1 {
+        if compare(p.rules[n].lhs, p.rules[n + 1].lhs, order: .shortlex) != .lessThan {
+          filteredLHS += 1
+          continue loop
+        }
+      }
+
+      for rule in p.rules {
+        if compare(rule.rhs, rule.lhs, order: .shortlex) != .lessThan {
+          filteredRHS += 1
+          continue loop
+        }
+      }
+
+      if unique.contains(p.sorted(order: .shortlex)) {
+        filteredSymmetry += 1
+        continue
+      }
+
+      for perm in perms {
+        let permuted = p.permuted(perm)
+        unique.insert(permuted.sorted(order: .shortlex))
+      }
+
+      precondition(p == p.sorted(order: .shortlex))
+      instances.append(p)
+    }
+  }
+
+  if output {
+    print("# Total \(total)")
+    print("# Discarded lhs:\(filteredLHS),rhs:\(filteredRHS),"
+          + "symmetry:\(filteredSymmetry)")
+  }
+
+  return instances
+}
+
+func ruleShapes(_ n: Int) -> [RuleShape] {
+  precondition(n > 0)
+  var result: [RuleShape] = []
+  for i in 0 ..< n {
+    let j = n - i
+
+    // Don't generate rules with shorter left-hand side.
+    if j < i { continue }
+
+    result.append(RuleShape(lhs: j, rhs: i))
+  }
+  return result
+}
+
+func presentationShapes(rules: Int, ofLength n: Int) -> [PresentationShape] {
+  precondition(n > 0)
+  precondition(rules > 0)
+
+  if rules == 1 {
+    return ruleShapes(n).map {
+      PresentationShape(rules: [$0])
+    }
+  }
+
+  var result: [PresentationShape] = []
+  for i in 1 ..< n {
+    let next = presentationShapes(rules: rules - 1, ofLength: i)
+    for x in ruleShapes(n - i) {
+      for y in next {
+        if x.lhs <= y.rules.first!.lhs {
+          result.append(PresentationShape(rules: [x] + y.rules))
+        }
+      }
+    }
+  }
+  return result
+}
+
+func presentationShapes(rules: Int, upToLength n: Int) -> [PresentationShape] {
+  var shapes: [PresentationShape] = []
+  for i in 1 ... n {
+    shapes.append(contentsOf: presentationShapes(rules: rules, ofLength: i))
+  }
+  return shapes
+}