GabrielTofvesson/NFA2DFA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement DFA minimization

Browse Source
This commit is contained in:
Gabriel Tofvesson 2019-03-28 14:21:57 +01:00
parent 53402051aa
commit 712a7efdd1
4 changed files with 210 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/FiniteAutomata.kt
View File

@ -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)
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")
}

59
src/dev/w1zzrd/automata/Aliases.kt Normal file
View File

@ -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()

157
src/dev/w1zzrd/automata/Automaton.kt
View File

@ -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)
// 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

22
src/dev/w1zzrd/automata/State.kt
View File

@ -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()