private List <string> GetTapeLibrary()
{
List <string> lstRetVal = new List <string>();
if (m_lstTapeLibrary == null)
{
TuringMachine tm = this;
foreach (TransitionFunction tf in tm.TransitionFunctions)
{
foreach (string sz in tf.DomainHeadValues)
{
if (!lstRetVal.Contains(sz))
{
lstRetVal.Add(sz);
}
}
foreach (string sz in tf.RangeHeadWrite)
{
if (!lstRetVal.Contains(sz))
{
lstRetVal.Add(sz);
}
}
}
}
else
{
lstRetVal = m_lstTapeLibrary.ToList();
}
return(lstRetVal.Where(x => x != END_SYMBOL && x != RETURN_SYMBOL && x != NULL_SYMBOL).ToList());
}
private List <TransitionFunction> GetPossibleTFs(State state)
{
TuringMachine tm = TM;
List <TransitionFunction> lstRetVal = new List <TransitionFunction>();
foreach (TransitionFunction tf in tm.TransitionFunctions)
{
bool found = true;
int subsLength = 0;
foreach (string subscript in state.SubScripts)
{
subsLength += subscript.Length;
}
found &= tf.DomainState.Actual == state.Actual.Substring(0, state.Actual.Length - subsLength);
for (int i = 0; i < state.SubScripts.Count; i++)
{
found &= SymMap[tf.DomainHeadValues[i]] == state.SubScripts[i];
}
if (found)
{
lstRetVal.Add(tf);
}
}
return(lstRetVal);
}
/// <summary>
/// Iteration is the number of the virtual head.
/// If the flattening algorithm is being used for the first time,
/// the virtual heads should all be 1s (as in 1 level down).
/// Second Time -> 2s
/// etc.
/// </summary>
/// <param name="iter"></param>
public Flattener(TuringMachine tf, int iteration = 1)
{
ITERATION = iteration;
SymMap = new SampleCollection(ITERATION);
NUM_TAPES = tf.TransitionFunctions.First().DomainHeadValues.Count;
TM = tf;
}
private List <State> GetStates()
{
TuringMachine tm = TM;
List <State> states = new List <State>();
foreach (TransitionFunction tf in tm.TransitionFunctions)
{
bool add = true;
foreach (State state in states)
{
add &= state.Actual != tf.DomainState.Actual;
}
if (add)
{
states.Add(tf.DomainState);
}
bool addR = true;
foreach (State state in states)
{
addR &= state.Actual != tf.RangeState.Actual;
}
if (addR)
{
states.Add(tf.RangeState);
}
}
return(states);
}
// Methods
public TuringMachineThread(TuringMachine tm, UpdateUICallback updateUIFunction)
{
this.tm = tm;
this.UpdateUI = updateUIFunction;
TryUpdateUI();
Thread thread = new Thread(new ThreadStart(TMThread));
thread.IsBackground = true;
thread.Start();
}
static void Main(string[] args)
{
TuringMachine tm = new TuringMachine();
tm.GetInput("Input.txt");
string doc = "";
Flattener fl = new Flattener(tm);
fl.Flatten(ref doc);
tm.FinalizeOutput(ref doc);
File.WriteAllText("Output.txt", doc);
Console.WriteLine("Done");
Console.ReadLine();
}
/// <summary>
/// Generally, it takes each tape, puts them on a single tape separated by #s.
/// The head then sweeps right and determines what symbol each "Simulated Head"
/// lies on. Once each Simulated Head is determined, the head then sweeps left
/// again to perform the changes to each simulated head.
///
/// Each simulated head represents a head on another tape prior to flattenning.
///
/// THIS IS THE ALGORITHM FOR NON BIDIRECTIONAL TURING MACHINE FLATTENNER
///
/// Details:
/// Transition functions must be constructed for each process in the algorithm.
/// First thing that needs to be done is the sweep right to determine the
/// states of the "simulated heads". This is done so the flat machine can determine
/// which transition function to simulate from the original k-tape machine.
/// While sweeping right, the transition functions operate on "Undetermined States"
///
/// TODO: EXAMPLE HERE
///
/// Once all simulated heads are determined, the state of the flat machine can
/// be uniquely assigned to a transition function from the machine prior to
/// flattenning. The states with this ability are called the "Determined States"
/// The determined state transition functions sweep left until they reach a
/// simulated head. Once a simulated head is reached, the transition functions
/// move the simulated head, then perform the change to that "simulated tape"
/// The head then continues sweeping left for each simulated head.
/// The machine then goes back to undetermined states and the process repeats
/// until an accept or reject state is reached.
///
/// Summary:
/// 1: Create Transition Functions for sweeping right - undetermined states
/// a: Transition functions for going from no known simulated heads to the first.
/// - Sweep_Right_XthParm_MoveToNext
/// b: Transition functions for transitioning to the correct state that knows the
/// location of each head on the previous simulated tapes
/// - Sweep_Right_XthParm_FoundNextChangeToNextState
/// c: Transition functions for going from first to second.
/// - Sweep_Right_XthParm_MoveToNext
/// d: Transition functions for going from second to third... etc.
/// - Sweep_Right_XthParm_MoveToNext
/// e: Transition functions for going from the last head to a determined state.
/// - Sweep_Right_Complete_BeginActionStates
/// 2: Create Transition Functions for sweeping left - determined states
/// a: Transition functions for going left until the last simulated head.
/// - Sweep_Right_Complete_BeginActionStates
/// b: Transition functions for transtioning to states that perform changes on the simulated heads.
/// i: Transition functions for performing the change on the simulated tape.
/// CAVEAT: For each write operation that can possible write on a blank space "_"
/// include a transition function that can also write on "#". This is done
/// in ii.
/// - Sweep_Left_ActorState_N_FoundPreviousWriteThenChangeToMoveHeadState
/// ii: Transition functions for extending the simulated tape if a write was
/// performed on a blank space that was actually a tape end "#". See the
/// function for extending the tape.
/// iii: Transition functions for moving the simulated head and returning to the sweep left.
/// - Sweep_Left_ActorState_N_MoveHeadThenChangeToNLess1MoveToPrevious
/// c: Transition functions for moving the the previous (N less 1) simulated head.
/// - Sweep_Left_ActorState_N_MoveToPrevious
/// d: Transition functions for meving from the first simulated head to a completed state.
/// - Sweep_Left_Complete_ActorState_0F_ChangeToNext
/// 3: Create Transition functions for transition from determined states to undetermined states
/// that then perform another sweep right OR check for completion.
/// - Sweep_Left_Complete_ActorState_0F_ChangeToNext
///
///
/// </summary>
/// <param name="doc"></param>
/// <param name="leftSafety"></param>
public void Flatten(ref string doc, bool leftSafety = false)
{
#region Setup
TuringMachine tm = TM;
Push_Symbols(ref TM.TransitionFunctions);
int NUM_TAPES = tm.TransitionFunctions.First().DomainHeadValues.Count;
List <string> TapeLibrary = GetTapeLibrary();
TapeLibrary.Add("#");
List <string> NonHeaderLibrary = TapeLibrary.ToList();
List <string> HeaderLibrary = NonHeaderLibrary.Select(x => SymMap[x]).ToList();
TapeLibrary = TapeLibrary.Concat(HeaderLibrary).ToList();
HeaderLibrary.Add("B");
// Get the mkStates.
List <State> mkStates = GetStates();
// Record the Final States
IEnumerable <State> OutputStates = new List <State>();
// Record the Final Transition Functions
List <TransitionFunction> OutputTFs = new List <TransitionFunction>();
List <TransitionFunction> UnbranchedFinalizedList = null;
#endregion Setup
#region Iterate of States Of Multitape Machine Mk
foreach (State mkState in mkStates)
{
//Build the states... These are really just used for counting.
IEnumerable <TransitionFunction> TransitionFunction_State_ = Get_Domain_States(mkState, tm.TransitionFunctions);
IEnumerable <State> undeterminedStates = Construct_Undetermined_States(mkState, TransitionFunction_State_)
.Distinct();
IList <DeterminedState> determinedStates = Construct_Determined_States(mkState, TransitionFunction_State_).ToList();
IEnumerable <DeterminedState> determinedStates_ActorStates_N_Write =
Construct_Transition_States_Primary(determinedStates);
IEnumerable <DeterminedState> determinedStates_ActorStates_N_MoveHead =
Construct_Transition_States_Secondary(determinedStates_ActorStates_N_Write);
IEnumerable <DeterminedState> determinedStates_ActorStates_0F_Complete =
Construct_Transition_Complete_States(determinedStates);
//Build the transition functions.
IEnumerable <TransitionFunction> tmp = new List <TransitionFunction>();
IEnumerable <TransitionFunction> undeterminedStates_TransitionFunctions_XthParm_MoveToNextI =
Sweep_Right_XthParm_MoveToNext(undeterminedStates, NonHeaderLibrary);
tmp = tmp.Concat(undeterminedStates_TransitionFunctions_XthParm_MoveToNextI).ToList();
IEnumerable <TransitionFunction> undeterminedStates_TransitionFunction_XthParm_FoundNextChangeToNextI =
Sweep_Right_XthParm_FoundNextChangeToNextState(undeterminedStates);
tmp = tmp.Concat(undeterminedStates_TransitionFunction_XthParm_FoundNextChangeToNextI);
IEnumerable <TransitionFunction> determinedStates_TransitionFunction_ChangeToActionStates =
Sweep_Right_Complete_BeginActionStates(determinedStates, NonHeaderLibrary);
tmp = tmp.Concat(determinedStates_TransitionFunction_ChangeToActionStates);
IEnumerable <TransitionFunction> determinedStates_TransitionFunction_ActorState_N_MoveToPreviousAndWrite =
Sweep_Left_ActorState_N_MoveToPrevious(
determinedStates_ActorStates_N_Write,
NonHeaderLibrary);
tmp = tmp.Concat(determinedStates_TransitionFunction_ActorState_N_MoveToPreviousAndWrite);
IEnumerable <TransitionFunction> determinedState_TransitionFunction_ActorState_N_FoundPreviousWriteThenChangeToMoveHeadState =
Sweep_Left_ActorState_N_FoundPreviousWriteThenChangeToMoveHeadState(
determinedStates);
tmp = tmp.Concat(determinedState_TransitionFunction_ActorState_N_FoundPreviousWriteThenChangeToMoveHeadState);
IEnumerable <TransitionFunction> determinedState_TransitionFunction_ActorState_N_MoveHeadThenChangeToNLess1MoveToPrevious =
Sweep_Left_ActorState_N_MoveHeadThenChangeToNLess1MoveToPrevious(
determinedStates,
NonHeaderLibrary);
tmp = tmp.Concat(determinedState_TransitionFunction_ActorState_N_MoveHeadThenChangeToNLess1MoveToPrevious);
IEnumerable <TransitionFunction> determinedState_TransitionFunction_ActorState_0F_MoveToBeginning =
Sweep_Left_Complete_ActorState_0F_ChangeToNext(
determinedStates_ActorStates_0F_Complete,
TapeLibrary);
tmp = tmp.Concat(determinedState_TransitionFunction_ActorState_0F_MoveToBeginning);
OutputTFs = OutputTFs.Concat(tmp).ToList();
//UniqueAdd(ref OutputTFs, tmp.ToList());
Console.WriteLine("Presafety");
}
Console.WriteLine(OutputTFs.Count());
List <TransitionFunction> withBranches = Include_Shift_Right_Safety(
ref OutputTFs,
TapeLibrary).ToList();
Console.WriteLine("RightSafety");
List <TransitionFunction> withBranchesRH;
if (leftSafety)
{
withBranchesRH = Include_Shift_Left_Safety_RightHanded(
ref OutputTFs,
TapeLibrary).ToList();
Console.WriteLine("LeftSafety");
Console.WriteLine(withBranchesRH.Count());
}
else
{
withBranchesRH = new List <TransitionFunction>();
}
//UniqueAdd(ref withBranchesRH, withBranches);
//UnbranchedFinalizedList = OutputTFs.Concat(withBranchesRH).ToList();
UnbranchedFinalizedList = Unique(OutputTFs.Concat(withBranchesRH).Concat(withBranches).ToList());
Console.WriteLine(UnbranchedFinalizedList.Count());
for (int i = 0; i < UnbranchedFinalizedList.Count(); i++)
{
doc += UnbranchedFinalizedList[i].ToString();
if (i % 100 == 0)
{
Console.WriteLine(i + "/" + UnbranchedFinalizedList.Count());
}
}
#endregion Iterate of States Of Multitape Machine Mk
}
