Implement DFA minimization

src/FiniteAutomata.kt

@@ -1,5 +1,7 @@
 import dev.w1zzrd.automata.*
 
+private val testString = arrayOf(1, 0, 0, 1 ,0)
+
 fun main(args: Array<String>){
     // Create a language with the set of elements {0, 1}
     val language = Language.makeLanguage(0, 1)
@@ -15,7 +17,6 @@ fun main(args: Array<String>){
     val stateD = nfa.makeState("d")
     val stateE = nfa.makeState("e", true)
 
-
     stateS.addEpsilon(stateA, stateC)
 
     stateA.addConnective(1, stateB)
@@ -35,18 +36,20 @@ fun main(args: Array<String>){
 
     // Convert the NFA into an equivalent DFA
     val dfa = nfa.toDeterministicAutomaton(true)
+    val minimal = dfa.toMinimalDFA()
 
     // Get a traverser for the DFA and manually traverse the string "1100", then print the resulting state
     val dtraverser = dfa.makeTraverser()
-    dtraverser.traverse(1, 0, 0, 1, 0)
+    dtraverser.traverse(*testString)
-    println("DFA simulation:")
+    println("\nDFA simulation:\n\t${dtraverser.currentState}\n\tAccepts: ${dfa.accepts(*testString)}\n")
-    println(dtraverser.currentState.toString())
-    println("Accepts: ${dfa.accepts(1, 0, 0, 1, 0)}\n")
 
     // Do the same as above but for the NFA
     val ntraverser = nfa.makeTraverser()
-    ntraverser.traverse(1, 0, 0, 1, 0)
+    ntraverser.traverse(*testString)
-    println("NFA simulation:")
+    println("\nNFA simulation:\n\t${ntraverser.currentState}\n\tAccepts: ${nfa.accepts(*testString)}")
-    println(ntraverser.currentState.toString())
+
-    println("Accepts: ${nfa.accepts(1, 0, 0, 1, 0)}")
+    // Do the same as above but for the minimal DFA
+    val mtraverser = minimal.makeTraverser()
+    mtraverser.traverse(*testString)
+    println("\nminimal DFA simulation:\n\t${mtraverser.currentState}\n\tAccepts: ${minimal.accepts(*testString)}\n")
 }

src/dev/w1zzrd/automata/Aliases.kt

@@ -0,0 +1,59 @@
+package dev.w1zzrd.automata
+
+internal typealias Partition<T> = MutableList<State<T>>
+internal typealias PartitionSet<T> = MutableList<Partition<T>>
+
+/**
+ * Ensure that the partition set is valid.
+ */
+internal fun <T> PartitionSet<T>.ensureCorrectness(){
+    for(set in this){
+        for(element in set){
+            this
+                    .filter { it != set && it.contains(element) }
+                    .forEach { throw IllegalStateException("Two partitions cannot share a state!") }
+        }
+    }
+}
+
+/**
+ * Check if two states share he same partition
+ *
+ * @param state1 The first state to compare against
+ * @param state2 The second state to compare against
+ *
+ * @return True if [state1] and [state2] are contained within the same partition in the set
+ */
+internal fun <T> PartitionSet<T>.sharePartition(state1: State<T>, state2: State<T>) =
+        this.none { it.contains(state1) && !it.contains(state2) }
+
+/**
+ * Check if the contents of this set is functionally equivalent to another set
+ */
+internal fun <T> PartitionSet<T>.isEquivalentTo(other: PartitionSet<T>) =
+        size == other.size &&
+                firstOrNull { other.firstOrNull { otherIt -> it.contentsEquals(otherIt) } == null } == null
+
+/**
+ * Find a [Partition] containing a given state
+ *
+ * @param state Which state to find the owning partition for
+ *
+ * @return A corresponding partition if there is one that contains the given state, if no such partition exists, null.
+ */
+internal fun <T> PartitionSet<T>.getAssociatedPartition(state: State<T>) =
+        firstOrNull { it.firstOrNull { checkState -> checkState == state } != null }
+
+/**
+ * Check if this [PartitionSet] contains a [Partition] which in turn contains the given [state].
+ *
+ * @param state The state to search for.
+ *
+ * @return True if there is a [Partition] which contains the given [state], else false.
+ */
+internal fun <T> PartitionSet<T>.hasAssociatedSet(state: State<T>) = getAssociatedPartition(state) != null
+
+/**
+ * Create a blank [PartitionSet].
+ */
+internal fun <T> makeBlankPartitionSet(): PartitionSet<T> = ArrayList()

src/dev/w1zzrd/automata/Automaton.kt

@@ -1,5 +1,48 @@
 package dev.w1zzrd.automata
 
+
+/**
+ * check if the contents of two collections is equal.
+ *
+ * @param other The other collection to compare against
+ *
+ * @return True if the length of the two collections is equal, and each element in one collection has an equivalent
+ * element in the other
+ */
+internal infix fun <V> Collection<V>.contentsEquals(other: Collection<V>) =
+        size == other.size &&
+        firstOrNull { other.firstOrNull { check -> check == it } == null } == null
+
+/**
+ * Whether or not the given set of states is an accept-state-set.
+ *
+ * @return True if one or more of the states in the list is an accept state, otherwise false.
+ */
+internal fun <T> MutableList<State<T>>.isAcceptState() = firstOrNull { it.acceptState } != null
+
+
+/**
+ * Create a [String] representation of the set of states.
+ */
+private fun Iterable<State<*>>.toReadableString(): String {
+    val stringComparator = Comparator.naturalOrder<String>()
+    val sorted = sortedWith(Comparator{ state1, state2 -> stringComparator.compare(state1.name, state2.name) })
+
+    // If the set is empty, return the empty set ;)
+    if(sorted.isEmpty()) return "∅"
+
+    // A non-empty set starts with a '{'
+    val builder = StringBuilder("{")
+
+    // Append the name of each state, followed by a comma
+    for(state in sorted) builder.append(state.name).append(',')
+
+    // The last character should be a '}', not a comma, so replace the above appended comma accordingly
+    builder.setCharAt(builder.length - 1, '}')
+
+    return builder.toString()
+}
+
 /**
  * A finite automaton that accepts elements from the given language and
  * which is either deterministic or nondeterministic
@@ -172,27 +215,6 @@ class Automaton<T>(val language: Language<T>, val deterministic: Boolean){
             return if(result == null) null else result to find!!
         }
 
-        // Simple function for converting states to a corresponding string
-        // The corresponding string will describe a set of the included states
-        fun Iterable<State<T>>.toReadableString(): String {
-            val stringComparator = Comparator.naturalOrder<String>()
-            val sorted = sortedWith(Comparator{ state1, state2 -> stringComparator.compare(state1.name, state2.name) })
-
-            // If the set is empty, return the empty set ;)
-            if(sorted.isEmpty()) return "∅"
-
-            // A non-empty set starts with a '{'
-            val builder = StringBuilder("{")
-
-            // Append the name of each state, followed by a comma
-            for(state in sorted) builder.append(state.name).append(',')
-
-            // The last character should be a '}', not a comma, so replace the above appended comma accordingly
-            builder.setCharAt(builder.length - 1, '}')
-
-            return builder.toString()
-        }
-
         // Create a traverser object for this automaton and get the initial state of it
         val traverser = StateTraverser(entryPoint!!)
         val startingState = traverser.currentState
@@ -256,24 +278,77 @@ class Automaton<T>(val language: Language<T>, val deterministic: Boolean){
         return dfa
     }
 
-    /**
-     * check if the contents of two collections is equal.
-     *
-     * @param other The other collection to compare against
-     *
-     * @return True if the length of the two collections is equal, and each element in one collection has an equivalent
-     * element in the other
-     */
-    private infix fun <V> Collection<V>.contentsEquals(other: Collection<V>) =
-            size == other.size &&
-            firstOrNull { other.firstOrNull { check -> check == it } == null } == null
 
     /**
-     * Whether or not the given set of states is an accept-state-set.
+     * Create a fresh (partially unsorted) partition set from this automaton
      *
-     * @return True if one or more of the states in the list is an accept state, otherwise false.
+     * @return A [PartitionSet] containing two [Partition]s: one containing accept-states and one containing reject-states.
      */
-    private fun MutableList<State<T>>.isAcceptState() = firstOrNull { it.acceptState } != null
+    private fun makePartitionSet(): PartitionSet<T> =
+            mutableListOf(states.filter { it.acceptState }.toMutableList(), states.filter { !it.acceptState }.toMutableList())
+
+    /**
+     * Converts this automaton into its minimal form using partitioning.
+     *
+     * @return The minimal DFA
+     *
+     * @exception IllegalStateException If the [entryPoint] is null.
+     */
+    fun toMinimalDFA(): Automaton<T> {
+        // The DFA to minimize
+        val toMinimize = if(deterministic) this else toDeterministicAutomaton()
+
+        // Ensure a proper entry point
+        if(toMinimize.entryPoint == null)
+            throw IllegalStateException("Entry point must be defined in order to minimize DFA!")
+
+        // The current partition set
+        var partitionSet = toMinimize.makePartitionSet()
+
+        // Loop until there is no change
+        while(true){
+            val newPartitionSet = makeBlankPartitionSet<T>()
+
+            // Re-partition all current partitions in case two states in a partition are distinguishable
+            for(partition in partitionSet) {
+                for (state in partition) {
+                    // Create a new partition if it doesn't already exist
+                    val addTo = newPartitionSet.getAssociatedPartition(state) ?: ArrayList()
+                    if(!newPartitionSet.contains(addTo)) newPartitionSet.add(addTo)
+
+                    // Add all indistinguishable states (from the currently analysed state) to the partition being created
+                    partition.filterNotTo(addTo) { addTo.contains(it) || state.isDistinguishableFrom(it, partitionSet) }
+                }
+            }
+
+            // If there was no change to the set of partitions or their contents, we are done
+            if(partitionSet.isEquivalentTo(newPartitionSet)) break
+            else partitionSet = newPartitionSet
+        }
+
+        // Now to actually create the new automaton
+        val minimalAutomaton = Automaton(language, true)
+
+        // Map generated partitions to new DFA states
+        val newOldStateMap = HashMap<Partition<T>, State<T>>()
+
+        var startState: State<T>? = null
+        for(partition in partitionSet){
+            // Create a state from a partition
+            val state = minimalAutomaton.makeState(partition.toReadableString(), partition[0].acceptState)
+            if(partition.firstOrNull { it == toMinimize.entryPoint } != null) startState = state
+            newOldStateMap[partition] = state
+        }
+
+        // Apply proper connectives to the DFA according to the connectives in the states in each of the partitions
+        for(partition in partitionSet)
+            for(verb in language.elements)
+                newOldStateMap[partition]!!.addConnective(verb, newOldStateMap[partitionSet.getAssociatedPartition(partition[0].getConnective(verb)[0])]!!)
+
+        minimalAutomaton.entryPoint = startState!!
+
+        return minimalAutomaton
+    }
 
     /**
      * Create a [StateTraverser] for this automaton.
@@ -333,11 +408,13 @@ class Automaton<T>(val language: Language<T>, val deterministic: Boolean){
             val nextState = ArrayList<State<T>>()
 
             // Loop through all active states
-            for(state in currentState)
+            currentState
-                // Get all states that each state transitions to for the given element
+                    // Get all states that each state transitions to for the given element
-                for(traverseState in state.getConnective(verb))
+                    .flatMap {
-                    // Perform epsilon transitions for each newly discovered state
+                        it.getConnective(verb)
-                    nextState.traverseEpsilon(traverseState)
+                        // Perform epsilon transitions for each newly discovered state
+                    }
+                    .forEach { nextState.traverseEpsilon(it) }
 
             // Update the state of the traverser
             currentState = nextState

src/dev/w1zzrd/automata/State.kt

@@ -87,6 +87,28 @@ class State<T>(
      */
     fun getEpsilon() = ArrayList(epsilon)
 
+    /**
+     * Determines whether or not this state is functionally distinguishable from another state.
+     *
+     * @param state The state to compare with
+     *
+     * @return True if there is no input that results in a distinguishable change in state of an automaton, else false.
+     *
+     * @see PartitionSet
+     */
+    fun isDistinguishableFrom(state: State<T>, partitions: PartitionSet<T>): Boolean {
+        partitions.ensureCorrectness()
+        return !isDeterministic ||
+                language.elements.firstOrNull{
+                    val myConnective = getConnective(it)
+                    val otherConnective = state.getConnective(it)
+                    if(myConnective.size != 1 || otherConnective.size != 1)
+                        throw IllegalStateException("Incomplete connective for state!")
+
+                    !partitions.sharePartition(myConnective[0], otherConnective[0])
+                } != null
+    }
+
     override fun equals(other: Any?) = other is State<*> && other.name == name
     override fun hashCode(): Int {
         return name.hashCode()