public bool CanSim(GCPP GCPPobj, MDPState state1, MDPState state2)
{
if (!PropositionEquals(state1, state2))
{
return false;
}
//else if ()
//{
//}
return true;
}
public MDP ComputeGCPP(VerificationOutput VerificationOutput)
{
MDP toReturn = new MDP(Precision, MAX_DIFFERENCE);
//add Initial
MDPState Initial = new MDPState(InitState.ID);
toReturn.AddState(Initial);
toReturn.SetInit(Initial);
//add target
foreach (MDPState targetstate in this.TargetStates)
{
AddTargetStates(targetstate);
}
//note here remaining doesn't include the target states and initial states
HashSet<MDPState> remaining = new HashSet<MDPState>();
foreach (MDPState mdpState in States.Values)
{
if (!TargetStates.Contains(mdpState) && InitState != mdpState)
{
remaining.Add(mdpState);
}
}
//instantiate GCPP
GCPP gcpp = new GCPP();
Dictionary<string, int> table = new Dictionary<string, int>();
foreach (MDPState mdpState in remaining)
{
gcpp.MDPTable.Add(mdpState.ID, mdpState);
table.Add(mdpState.ID, 0);
}
int n = 0;
foreach (MDPState mdpState1 in remaining)
{
foreach (MDPState mdpState2 in remaining)
{
List<MDPState> list = new List<MDPState>();
if (mdpState1 != mdpState2 && table[mdpState1.ID] == table[mdpState2.ID] && PropositionEquals(mdpState1, mdpState2))
{
list.Add(mdpState1);
list.Add(mdpState2);
table[mdpState1.ID] = 1;
table[mdpState2.ID] = 1;
gcpp.PartOrder.Add(n, n);
gcpp.Partition.Add(n, list);
gcpp.PartitionGetKey.Add(list, n++);
}
}
}
gcpp.partition = null;
gcpp.partorder = null;
while (gcpp.Partition != gcpp.partition || gcpp.PartOrder != gcpp.partorder)
{
gcpp.partition = gcpp.Partition;
gcpp.partorder = gcpp.PartOrder;
foreach (List<MDPState> B in gcpp.partition.Values)
{
//GCPP item = new GCPP();
gcpp = Split(gcpp, B);
//∑:=∑\{B}∪{∑B}
gcpp.Partition.Remove(gcpp.PartitionGetKey[B]);
foreach (KeyValuePair<int, List<MDPState>> pair in gcpp.partition)
{
gcpp.Partition.Add(n, pair.Value);
gcpp.PartitionGetKey.Add(pair.Value, n);
}
//≤:=≤∪≤B
// ∪{(B',X)|X∈∑:B'∈∑B:(B,X)∈≤}
// ∪{(X,B')|X∈∑:B'∈∑B:(X,B)∈≤}
// \{(B,X),(X,B)|X∈∑:(X,B),(B,X)∈≤}
foreach (KeyValuePair<int, int> pair in gcpp.partorder)
{
gcpp.PartOrder.Add(pair.Key, pair.Value);
}
foreach (List<MDPState> X in gcpp.Partition.Values)
{
if (SamePartOrder(X, B, gcpp.PartOrder, gcpp.PartitionGetKey) && SamePartOrder(B, X, gcpp.PartOrder, gcpp.PartitionGetKey))
{
var query1 = from p in gcpp.PartOrder
where p.Key == gcpp.PartitionGetKey[B] && p.Value == gcpp.PartitionGetKey[X]
select p.Key;
gcpp.PartOrder.Remove(query1.FirstOrDefault());
var query2 = from p in gcpp.PartOrder
where p.Key == gcpp.PartitionGetKey[X] && p.Value == gcpp.PartitionGetKey[B]
select p.Key;
gcpp.PartOrder.Remove(query2.FirstOrDefault());
}
foreach (List<MDPState> B1 in gcpp.partition.Values)
{
if (SamePartOrder(B, X, gcpp.PartOrder, gcpp.PartitionGetKey))
{
gcpp.PartOrder.Add(gcpp.PartitionGetKey[B1], gcpp.PartitionGetKey[X]);
}
if (SamePartOrder(X, B, gcpp.PartOrder, gcpp.PartitionGetKey))
{
gcpp.PartOrder.Add(gcpp.PartitionGetKey[X], gcpp.PartitionGetKey[B1]);
}
}
}
}
}
return toReturn;
}
public GCPP Split(GCPP obj, List<MDPState> states)
{
Dictionary<int, List<MDPState>> PartitionB = new Dictionary<int, List<MDPState>>();
Dictionary<List<MDPState>, int> PartitionBGetKey = new Dictionary<List<MDPState>, int>();
Dictionary<int, int> PartOrderB = new Dictionary<int, int>();
Dictionary<int, List<MDPState>> partitionB = new Dictionary<int, List<MDPState>>();
Dictionary<int, int> partorderB = new Dictionary<int, int>();
int n = 0;
foreach (MDPState mdpState in states)
{
List<MDPState> set = new List<MDPState>();
set.Add(mdpState);
PartOrderB.Add(n, n);
PartitionB.Add(n, set);
PartitionBGetKey.Add(set, n++);
}
partitionB = null;
partorderB = null;
while (PartitionB != partitionB || PartOrderB != partorderB)
{
partitionB = PartitionB;
partorderB = PartOrderB;
foreach (List<MDPState> B1 in partitionB.Values)
{
foreach (List<MDPState> B2 in partitionB.Values)
{
if (B1 != B2)
{
if (CanSim(obj, B1[0], B2[0]) && CanSim(obj, B2[0], B1[0]))
{
//∑B:=∑B\{B1，B2}∪{B1∪B2}
PartitionB.Remove(PartitionBGetKey[B1]);
PartitionB.Remove(PartitionBGetKey[B1]);
List<MDPState> list = new List<MDPState>();
foreach (MDPState state in B1)
{
list.Add(state);
}
foreach (MDPState state in B2)
{
list.Add(state);
}
PartitionB.Add(n, list);
PartitionBGetKey.Add(list, n++);
//≤B:={≤B∪{X,B1∪B2}|X∈∑:(X,B1)∈≤B∨X∈∑:(X,B2)}
// ∪{(B1∪B2,X)|X∈∑:(X,B2)∈≤B∨X∈∑:(X,B1)
// \{(Bi,X),(X,Bi)|X∈∑:(Bi,X),(X,Bi)∈≤B∧i∈{1,2}}
foreach (List<MDPState> statelist in obj.partition.Values)
{
if (SamePartOrder(statelist, B1, PartOrderB, PartitionBGetKey) || SamePartOrder(statelist, B2, PartOrderB, PartitionBGetKey))
{
PartOrderB.Add(PartitionBGetKey[statelist], PartitionBGetKey[list]);
}
if (SamePartOrder(statelist, B2, PartOrderB, PartitionBGetKey) || SamePartOrder(statelist, B1, PartOrderB, PartitionBGetKey))
{
PartOrderB.Add(PartitionBGetKey[list], PartitionBGetKey[statelist]);
}
if (SamePartOrder(B1, statelist, PartOrderB, PartitionBGetKey) && SamePartOrder(statelist, B1, PartOrderB, PartitionBGetKey))
{
var query1 = from p in PartOrderB
where p.Key == PartitionBGetKey[B1] && p.Value == PartitionBGetKey[statelist]
select p.Key;
PartOrderB.Remove(query1.FirstOrDefault());
var query2 = from p in PartOrderB
where p.Value == PartitionBGetKey[statelist] && p.Key == PartitionBGetKey[B1]
select p.Key;
PartOrderB.Remove(query2.FirstOrDefault());
}
if (SamePartOrder(B2, statelist, PartOrderB, PartitionBGetKey) && SamePartOrder(statelist, B2, PartOrderB, PartitionBGetKey))
{
var query1 = from p in PartOrderB
where p.Key == PartitionBGetKey[B2] && p.Value == PartitionBGetKey[statelist]
select p.Key;
PartOrderB.Remove(query1.FirstOrDefault());
var query2 = from p in PartOrderB
where p.Value == PartitionBGetKey[statelist] && p.Key == PartitionBGetKey[B2]
select p.Key;
PartOrderB.Remove(query2.FirstOrDefault());
}
}
}
else if (CanSim(obj, B1[0], B2[0]))
{
PartOrderB.Add(PartitionBGetKey[B2], PartitionBGetKey[B1]);
}
else if (CanSim(obj, B2[0], B1[0]))
{
PartOrderB.Add(PartitionBGetKey[B1], PartitionBGetKey[B2]);
}
}
}
}
}
obj.partition = PartitionB;
obj.partorder = PartOrderB;
return obj;
}
