From 712a7efdd1715165ca6664fe6fc69323d3f5f257 Mon Sep 17 00:00:00 2001 From: GabrielTofvesson Date: Thu, 28 Mar 2019 14:21:57 +0100 Subject: [PATCH] Implement DFA minimization --- src/FiniteAutomata.kt | 21 ++-- src/dev/w1zzrd/automata/Aliases.kt | 59 ++++++++++ src/dev/w1zzrd/automata/Automaton.kt | 157 ++++++++++++++++++++------- src/dev/w1zzrd/automata/State.kt | 22 ++++ 4 files changed, 210 insertions(+), 49 deletions(-) create mode 100644 src/dev/w1zzrd/automata/Aliases.kt diff --git a/src/FiniteAutomata.kt b/src/FiniteAutomata.kt index 9e83852..611cf73 100644 --- a/src/FiniteAutomata.kt +++ b/src/FiniteAutomata.kt @@ -1,5 +1,7 @@ import dev.w1zzrd.automata.* +private val testString = arrayOf(1, 0, 0, 1 ,0) + fun main(args: Array){ // Create a language with the set of elements {0, 1} val language = Language.makeLanguage(0, 1) @@ -15,7 +17,6 @@ fun main(args: Array){ 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){ // 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) - println("DFA simulation:") - println(dtraverser.currentState.toString()) - println("Accepts: ${dfa.accepts(1, 0, 0, 1, 0)}\n") + dtraverser.traverse(*testString) + println("\nDFA simulation:\n\t${dtraverser.currentState}\n\tAccepts: ${dfa.accepts(*testString)}\n") // Do the same as above but for the NFA val ntraverser = nfa.makeTraverser() - ntraverser.traverse(1, 0, 0, 1, 0) - println("NFA simulation:") - println(ntraverser.currentState.toString()) - println("Accepts: ${nfa.accepts(1, 0, 0, 1, 0)}") + ntraverser.traverse(*testString) + println("\nNFA simulation:\n\t${ntraverser.currentState}\n\tAccepts: ${nfa.accepts(*testString)}") + + // 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") } \ No newline at end of file diff --git a/src/dev/w1zzrd/automata/Aliases.kt b/src/dev/w1zzrd/automata/Aliases.kt new file mode 100644 index 0000000..2a168f6 --- /dev/null +++ b/src/dev/w1zzrd/automata/Aliases.kt @@ -0,0 +1,59 @@ +package dev.w1zzrd.automata + +internal typealias Partition = MutableList> +internal typealias PartitionSet = MutableList> + +/** + * Ensure that the partition set is valid. + */ +internal fun PartitionSet.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 PartitionSet.sharePartition(state1: State, state2: State) = + this.none { it.contains(state1) && !it.contains(state2) } + +/** + * Check if the contents of this set is functionally equivalent to another set + */ +internal fun PartitionSet.isEquivalentTo(other: PartitionSet) = + 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 PartitionSet.getAssociatedPartition(state: State) = + 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 PartitionSet.hasAssociatedSet(state: State) = getAssociatedPartition(state) != null + +/** + * Create a blank [PartitionSet]. + */ +internal fun makeBlankPartitionSet(): PartitionSet = ArrayList() \ No newline at end of file diff --git a/src/dev/w1zzrd/automata/Automaton.kt b/src/dev/w1zzrd/automata/Automaton.kt index 918b5c2..02ed028 100644 --- a/src/dev/w1zzrd/automata/Automaton.kt +++ b/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 Collection.contentsEquals(other: Collection) = + 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 MutableList>.isAcceptState() = firstOrNull { it.acceptState } != null + + +/** + * Create a [String] representation of the set of states. + */ +private fun Iterable>.toReadableString(): String { + val stringComparator = Comparator.naturalOrder() + 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(val language: Language, 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>.toReadableString(): String { - val stringComparator = Comparator.naturalOrder() - 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(val language: Language, 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 Collection.contentsEquals(other: Collection) = - 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>.isAcceptState() = firstOrNull { it.acceptState } != null + private fun makePartitionSet(): PartitionSet = + 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 { + // 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() + + // 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, State>() + + var startState: State? = 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(val language: Language, val deterministic: Boolean){ val nextState = ArrayList>() // Loop through all active states - for(state in currentState) - // Get all states that each state transitions to for the given element - for(traverseState in state.getConnective(verb)) - // Perform epsilon transitions for each newly discovered state - nextState.traverseEpsilon(traverseState) + currentState + // Get all states that each state transitions to for the given element + .flatMap { + it.getConnective(verb) + // Perform epsilon transitions for each newly discovered state + } + .forEach { nextState.traverseEpsilon(it) } // Update the state of the traverser currentState = nextState diff --git a/src/dev/w1zzrd/automata/State.kt b/src/dev/w1zzrd/automata/State.kt index 8eaef9e..0520085 100644 --- a/src/dev/w1zzrd/automata/State.kt +++ b/src/dev/w1zzrd/automata/State.kt @@ -87,6 +87,28 @@ class State( */ 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, partitions: PartitionSet): 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()