public void UseEqualityComparer()
{
IEqualityComparer <HasEquivalence> ec = Equivalence.GetEqualityComparer <HasEquivalence>();
HasEquivalence one = new HasEquivalence {
Value = 1
};
HasEquivalence oneClone = new HasEquivalence {
Value = 1
};
HasEquivalence two = new HasEquivalence {
Value = 2
};
Assert.AreEqual(ec.Equals(null, null), true);
Assert.AreEqual(ec.Equals(one, null), false);
Assert.AreEqual(ec.Equals(null, one), false);
Assert.AreEqual(ec.Equals(one, one), true);
Assert.AreEqual(ec.Equals(one, oneClone), true);
Assert.AreEqual(ec.Equals(one, two), false);
Assert.AreEqual(ec.Equals(oneClone, one), true);
Assert.AreEqual(ec.Equals(oneClone, oneClone), true);
Assert.AreEqual(ec.Equals(oneClone, two), false);
Assert.AreEqual(ec.Equals(two, one), false);
Assert.AreEqual(ec.Equals(two, oneClone), false);
Assert.AreEqual(ec.Equals(two, two), true);
}
public void AreEquivalentTests()
{
HasEquivalence one = new HasEquivalence {
Value = 1
};
HasEquivalence oneClone = new HasEquivalence {
Value = 1
};
HasEquivalence two = new HasEquivalence {
Value = 2
};
Assert.AreEqual(Equivalence.AreEquivalent <HasEquivalence>(null, null), true);
Assert.AreEqual(Equivalence.AreEquivalent(one, null), false);
Assert.AreEqual(Equivalence.AreEquivalent(null, one), false);
Assert.AreEqual(Equivalence.AreEquivalent(one, one), true);
Assert.AreEqual(Equivalence.AreEquivalent(one, oneClone), true);
Assert.AreEqual(Equivalence.AreEquivalent(one, two), false);
Assert.AreEqual(Equivalence.AreEquivalent(oneClone, one), true);
Assert.AreEqual(Equivalence.AreEquivalent(oneClone, oneClone), true);
Assert.AreEqual(Equivalence.AreEquivalent(oneClone, two), false);
Assert.AreEqual(two.IsEquivalentTo(one), false);
Assert.AreEqual(two.IsEquivalentTo(oneClone), false);
Assert.AreEqual(two.IsEquivalentTo(two), true);
}
public void UseEqualityComparerWithoutEquivalence()
{
var ec = Equivalence.GetEqualityComparerOrFallback <HasNotEquivalence>();
var one = new HasNotEquivalence {
Value = 1
};
var oneClone = new HasNotEquivalence {
Value = 1
};
var two = new HasNotEquivalence {
Value = 2
};
Assert.AreEqual(ec.Equals(null !, null !), true);
Assert.AreEqual(ec.Equals(one, null !), false);
Assert.AreEqual(ec.Equals(null !, one), false);
Assert.AreEqual(ec.Equals(one, one), true);
Assert.AreEqual(ec.Equals(one, oneClone), false);
Assert.AreEqual(ec.Equals(one, two), false);
Assert.AreEqual(ec.Equals(oneClone, one), false);
Assert.AreEqual(ec.Equals(oneClone, oneClone), true);
Assert.AreEqual(ec.Equals(oneClone, two), false);
Assert.AreEqual(ec.Equals(two, one), false);
Assert.AreEqual(ec.Equals(two, oneClone), false);
Assert.AreEqual(ec.Equals(two, two), true);
}
public object Visit(Equivalence e)
{
if (e.modality != Statement.Modality.IS)
{
return(CreateNull());
}
// forall X,Y in e.Equivalence return X[=Y & Y[=X
return(INTERSECT_SYMETRIC_FUN(e.Equivalents, SUBS));
}
private bool AreDistinguishable(ThreeAutomaton <S> fa, Equivalence E, Tuple <int, int> pq, IBooleanAlgebraPositive <S> solver)
{
foreach (Move <S> from_p in fa.GetMovesFrom(pq.Item1))
{
foreach (Move <S> from_q in fa.GetMovesFrom(pq.Item2))
{
if (from_p.TargetState != from_q.TargetState &&
!E.AreEquiv(from_p.TargetState, from_q.TargetState))
{
if (solver.IsSatisfiable(solver.MkAnd(from_p.Label, from_q.Label)))
{
return(true);
}
}
}
}
return(false);
}
static void Main(string[] args)
{
Boolean a = true;
Boolean b = false;
Boolean c = true;
Vertex logicA = new LogicValue(a);
Vertex logicB = new LogicValue(b);
Vertex logicC = new LogicValue(c);
Vertex disjuction = new Disjunction(logicA, logicB);
Vertex consecution = new Consecution(disjuction, logicC);
Vertex equivalence = new Equivalence(consecution, logicA);
Console.WriteLine(equivalence.GetResult());
Console.ReadKey();
}
public void AreSequencesEquivalentTests()
{
HasEquivalence one = new HasEquivalence {
Value = 1
};
HasEquivalence oneClone = new HasEquivalence {
Value = 1
};
HasEquivalence two = new HasEquivalence {
Value = 2
};
Assert.AreEqual(Equivalence.AreSequencesEquivalent <HasEquivalence>(null, null), true);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(new HasEquivalence[0], null), false);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(null, new HasEquivalence[0]), false);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(new HasEquivalence[0], new HasEquivalence[0]), true);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(new[] { one }, null), false);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(null, new[] { one }), false);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(new[] { one }, new[] { oneClone }), true);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(new[] { one, two }, new[] { one, two }), true);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(new[] { one, two }, new[] { one, two, one }), false);
Assert.AreEqual(Equivalence.AreSequencesEquivalent(new[] { one, two }, new[] { two, one }), false);
}
/// <summary>
/// Extension of standard minimization of FAs, use timeout.
/// </summary>
ThreeAutomaton <S> MinimizeClassical(IBooleanAlgebra <S> solver, int timeout)
{
var fa = this.MakeTotal();
Equivalence E = new Equivalence();
//initialize E, all nonfinal states are equivalent
//and all final states are equivalent and all dontcare are equivalent
List <int> stateList = new List <int>(fa.States);
for (int i = 0; i < stateList.Count; i++)
{
//E.Add(stateList[i], stateList[i]);
for (int j = 0; j < stateList.Count; j++)
{
int p = stateList[i];
int q = stateList[j];
bool pIsFinal = fa.IsFinalState(p);
bool qIsFinal = fa.IsFinalState(q);
if (pIsFinal == qIsFinal)
{
if (pIsFinal)
{
E.Add(p, q);
}
else
{
bool pIsRej = fa.IsRejectingState(p);
bool qIsRej = fa.IsRejectingState(q);
if (pIsRej == qIsRej)
{
E.Add(p, q);
}
}
}
}
}
//refine E
bool continueRefinement = true;
List <int> statesList = new List <int>(fa.States);
while (continueRefinement)
{
continueRefinement = false;
for (int i = 0; i < statesList.Count; i++)
{
for (int j = 0; j < statesList.Count; j++)
{
Tuple <int, int> pq = new Tuple <int, int>(statesList[i], statesList[j]);
if (E.Contains(pq))
{
if (pq.Item1 != pq.Item2 && AreDistinguishable(fa, E, pq, solver))
{
E.Remove(pq);
continueRefinement = true;
}
}
}
}
}
//create id's for equivalence classes
Dictionary <int, int> equivIdMap = new Dictionary <int, int>();
List <int> mfaStates = new List <int>();
foreach (Tuple <int, int> pq in E)
{
int equivId;
if (equivIdMap.TryGetValue(pq.Item1, out equivId))
{
equivIdMap[pq.Item2] = equivId;
}
else if (equivIdMap.TryGetValue(pq.Item2, out equivId))
{
equivIdMap[pq.Item1] = equivId;
}
else
{
equivIdMap[pq.Item1] = pq.Item1;
equivIdMap[pq.Item2] = pq.Item1;
mfaStates.Add(pq.Item1);
}
}
//remaining states map to themselves
foreach (int state in fa.States)
{
if (!equivIdMap.ContainsKey(state))
{
equivIdMap[state] = state;
mfaStates.Add(state);
}
}
int mfaInitialState = equivIdMap[fa.InitialState];
//group together transition conditions for transitions on equivalent states
Dictionary <Tuple <int, int>, S> combinedConditionMap = new Dictionary <Tuple <int, int>, S>();
foreach (int state in fa.States)
{
int fromStateId = equivIdMap[state];
foreach (Move <S> trans in fa.GetMovesFrom(state))
{
int toStateId = equivIdMap[trans.TargetState];
S cond;
var p = new Tuple <int, int>(fromStateId, toStateId);
if (combinedConditionMap.TryGetValue(p, out cond))
{
combinedConditionMap[p] = solver.MkOr(cond, trans.Label);
}
else
{
combinedConditionMap[p] = trans.Label;
}
}
}
//form the transitions of the mfa
List <Move <S> > mfaTransitions = new List <Move <S> >();
foreach (var kv in combinedConditionMap)
{
mfaTransitions.Add(Move <S> .Create(kv.Key.Item1, kv.Key.Item2, kv.Value));
}
//accepting states and rejecting
HashSet <int> mfaAccStates = new HashSet <int>();
HashSet <int> mfaRejStates = new HashSet <int>();
foreach (int state in acceptingStateSet)
{
mfaAccStates.Add(equivIdMap[state]);
}
foreach (int state in rejectingStateSet)
{
mfaRejStates.Add(equivIdMap[state]);
}
return(ThreeAutomaton <S> .Create(algebra, mfaInitialState, mfaRejStates, mfaAccStates, mfaTransitions));
}
