diff --git a/src/main/java/de/learnlib/ralib/automata/guards/AtomicGuardExpression.java b/src/main/java/de/learnlib/ralib/automata/guards/AtomicGuardExpression.java index 2a97887b..3705ff73 100644 --- a/src/main/java/de/learnlib/ralib/automata/guards/AtomicGuardExpression.java +++ b/src/main/java/de/learnlib/ralib/automata/guards/AtomicGuardExpression.java @@ -61,6 +61,8 @@ public boolean isSatisfied(Mapping> val) { return !lv.equals(rv); case BIGGER: case SMALLER: + case BIGGER_OR_EQUAL: + case SMALLER_OR_EQUAL: return numCompare(lv, rv, relation); default: @@ -116,8 +118,12 @@ private boolean numCompare(DataValue l, DataValue r, Relation relation) { switch (relation) { case SMALLER: return result < 0; + case SMALLER_OR_EQUAL: + return result < 0 || result == 0; case BIGGER: return result > 0; + case BIGGER_OR_EQUAL: + return result > 0 || result == 0; default: throw new UnsupportedOperationException( diff --git a/src/main/java/de/learnlib/ralib/automata/guards/Relation.java b/src/main/java/de/learnlib/ralib/automata/guards/Relation.java index 46f807eb..bee6f73c 100644 --- a/src/main/java/de/learnlib/ralib/automata/guards/Relation.java +++ b/src/main/java/de/learnlib/ralib/automata/guards/Relation.java @@ -19,7 +19,9 @@ public enum Relation { SMALLER("<"), + SMALLER_OR_EQUAL("<="), BIGGER(">"), + BIGGER_OR_EQUAL(">="), EQUALS("=="), NOT_EQUALS("!="); diff --git a/src/main/java/de/learnlib/ralib/automata/xml/ExpressionParser.java b/src/main/java/de/learnlib/ralib/automata/xml/ExpressionParser.java index 31d43216..6c2a112e 100644 --- a/src/main/java/de/learnlib/ralib/automata/xml/ExpressionParser.java +++ b/src/main/java/de/learnlib/ralib/automata/xml/ExpressionParser.java @@ -96,10 +96,18 @@ else if (pred.contains("!!")) { related = pred.split("!!"); relation = Relation.NOT_EQUALS; } + else if (pred.contains("<=")) { + related = pred.split("<="); + relation = Relation.SMALLER_OR_EQUAL; + } else if (pred.contains("<")) { related = pred.split("<"); relation = Relation.SMALLER; } + else if (pred.contains(">=")) { + related = pred.split(">="); + relation = Relation.BIGGER_OR_EQUAL; + } else if (pred.contains(">")) { related = pred.split(">"); relation = Relation.BIGGER; diff --git a/src/main/java/de/learnlib/ralib/ceanalysis/PrefixFinder.java b/src/main/java/de/learnlib/ralib/ceanalysis/PrefixFinder.java index 78222e8b..e21cdbf2 100644 --- a/src/main/java/de/learnlib/ralib/ceanalysis/PrefixFinder.java +++ b/src/main/java/de/learnlib/ralib/ceanalysis/PrefixFinder.java @@ -30,6 +30,8 @@ import de.learnlib.ralib.oracles.SDTLogicOracle; import de.learnlib.ralib.oracles.TreeOracle; import de.learnlib.ralib.oracles.TreeQueryResult; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; import de.learnlib.ralib.words.DataWords; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; @@ -45,6 +47,7 @@ public class PrefixFinder { private final SDTLogicOracle sdtOracle; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; //private Map, LocationComponent> components; private final Constants consts; @@ -67,6 +70,11 @@ public PrefixFinder(TreeOracle sulOracle, TreeOracle hypOracle, this.sdtOracle = sdtOracle; //this.components = components; this.consts = consts; + if (sulOracle instanceof MultiTheoryTreeOracle) { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, ((MultiTheoryTreeOracle)sulOracle).getTeachers()); + } else { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); + } } public CEAnalysisResult analyzeCounterexample(Word ce) { @@ -102,7 +110,7 @@ private int findIndex(Word ce) { // check for location counterexample ... // Word suffix = ce.suffix(ce.length() - nextPrefix.length()); - SymbolicSuffix symSuffix = new SymbolicSuffix(nextPrefix, suffix, consts); + SymbolicSuffix symSuffix = new SymbolicSuffix(nextPrefix, suffix, restrictionBuilder); LOC_CHECK: for (Word u : hypothesis.possibleAccessSequences(prefix)) { Word uAlpha = hypothesis.transformTransitionSequence(nextPrefix, u); TreeQueryResult uAlphaResult = sulOracle.treeQuery(uAlpha, symSuffix); @@ -179,7 +187,7 @@ private boolean transitionHasCE(Word ce, int idx) { Word prefix = ce.prefix(idx+1); Word suffix = ce.suffix(ce.length() - (idx+1)); - SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, consts); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, restrictionBuilder); Set> locations = hypothesis.possibleAccessSequences(prefix); for (Word location : locations) { @@ -217,7 +225,7 @@ private void storeCandidateCEs(Word ce, int idx) { Word prefix = ce.prefix(idx+1); Word suffix = ce.suffix(ce.length() - (idx+1)); - SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, consts); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, restrictionBuilder); Set> locations = hypothesis.possibleAccessSequences(prefix); for (Word location : locations) { @@ -264,7 +272,7 @@ private SymbolicWord candidate(Word prefix, if (exprR.isSatisfied(vals)) { candidate = path.prefix(prefix.length() + 1); - SymbolicSuffix suffix = new SymbolicSuffix(candidate, ce.suffix(symSuffix.length() - 1), consts); + SymbolicSuffix suffix = new SymbolicSuffix(candidate, ce.suffix(symSuffix.length() - 1), restrictionBuilder); return new SymbolicWord(candidate, suffix); } } diff --git a/src/main/java/de/learnlib/ralib/dt/DT.java b/src/main/java/de/learnlib/ralib/dt/DT.java index 840d05fc..65fc33ca 100644 --- a/src/main/java/de/learnlib/ralib/dt/DT.java +++ b/src/main/java/de/learnlib/ralib/dt/DT.java @@ -25,9 +25,11 @@ import de.learnlib.ralib.learning.ralambda.RaLambda; import de.learnlib.ralib.oracles.TreeOracle; import de.learnlib.ralib.oracles.TreeQueryResult; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; import de.learnlib.ralib.oracles.mto.OptimizedSymbolicSuffixBuilder; import de.learnlib.ralib.oracles.mto.SDT; import de.learnlib.ralib.oracles.mto.SDTLeaf; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; import de.learnlib.ralib.theory.SDTGuard; import de.learnlib.ralib.theory.SDTTrueGuard; import de.learnlib.ralib.words.OutputSymbol; @@ -48,12 +50,17 @@ public class DT implements DiscriminationTree { private boolean ioMode; private final Constants consts; private DTLeaf sink = null; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; public DT(TreeOracle oracle, boolean ioMode, Constants consts, ParameterizedSymbol... inputs) { this.oracle = oracle; this.ioMode = ioMode; this.inputs = inputs; this.consts = consts; + if (oracle instanceof MultiTheoryTreeOracle) + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, ((MultiTheoryTreeOracle)oracle).getTeachers()); + else + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); Word epsilon = Word.epsilon(); SymbolicSuffix suffEps = new SymbolicSuffix(epsilon, epsilon); @@ -67,6 +74,10 @@ public DT(DTInnerNode root, TreeOracle oracle, boolean ioMode, Constants consts, this.ioMode = ioMode; this.inputs = inputs; this.consts = consts; + if (oracle instanceof MultiTheoryTreeOracle) + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, ((MultiTheoryTreeOracle)oracle).getTeachers()); + else + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); } public DT(DT dt) { @@ -74,6 +85,7 @@ public DT(DT dt) { this.oracle = dt.oracle; this.ioMode = dt.ioMode; this.consts = dt.consts; + this.restrictionBuilder = dt.restrictionBuilder; root = new DTInnerNode(dt.root); } @@ -247,7 +259,7 @@ public void addSuffix(SymbolicSuffix suffix, DTLeaf leaf) { public boolean addLocation(Word target, DTLeaf src_c, DTLeaf dest_c, DTLeaf target_c) { Word prefix = target.prefix(target.length() - 1); - SymbolicSuffix suff1 = new SymbolicSuffix(prefix, target.suffix(1), consts); + SymbolicSuffix suff1 = new SymbolicSuffix(prefix, target.suffix(1), restrictionBuilder); SymbolicSuffix suff2 = findLCA(dest_c, target_c).getSuffix(); SymbolicSuffix suffix = suff1.concat(suff2); diff --git a/src/main/java/de/learnlib/ralib/dt/DTLeaf.java b/src/main/java/de/learnlib/ralib/dt/DTLeaf.java index 6ec9e9ac..c466ebdd 100644 --- a/src/main/java/de/learnlib/ralib/dt/DTLeaf.java +++ b/src/main/java/de/learnlib/ralib/dt/DTLeaf.java @@ -487,8 +487,10 @@ private boolean checkVariableConsistency(MappedPrefix mp, DT dt, Constants const for (SymbolicSuffix suffix : suffixes) { TreeQueryResult suffixTQR = mp.getTQRs().get(suffix); SymbolicDecisionTree sdt = suffixTQR.getSdt(); + // suffixBuilder == null ==> suffix.isOptimizedGeneric() + assert suffixBuilder != null || suffix.isOptimizationGeneric() : "Optimized with restriction builder, but no restriction builder provided"; SymbolicSuffix newSuffix = suffixBuilder != null && sdt instanceof SDT ? - suffixBuilder.extendSuffix(mp.getPrefix(), (SDT)sdt, suffixTQR.getPiv(), suffix) : + suffixBuilder.extendSuffix(mp.getPrefix(), (SDT)sdt, suffixTQR.getPiv(), suffix, suffixTQR.getPiv().get(p)) : new SymbolicSuffix(mp.getPrefix(), suffix, consts); if (prefixSuffixes.contains(newSuffix)) continue; diff --git a/src/main/java/de/learnlib/ralib/learning/CounterexampleAnalysis.java b/src/main/java/de/learnlib/ralib/learning/CounterexampleAnalysis.java index cf04ca58..8131f898 100644 --- a/src/main/java/de/learnlib/ralib/learning/CounterexampleAnalysis.java +++ b/src/main/java/de/learnlib/ralib/learning/CounterexampleAnalysis.java @@ -30,6 +30,8 @@ import de.learnlib.ralib.oracles.SDTLogicOracle; import de.learnlib.ralib.oracles.TreeOracle; import de.learnlib.ralib.oracles.TreeQueryResult; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; import net.automatalib.word.Word; @@ -50,6 +52,8 @@ public class CounterexampleAnalysis { private final SDTLogicOracle sdtOracle; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; + private final Map, LocationComponent> components; private final Constants consts; @@ -68,6 +72,11 @@ public CounterexampleAnalysis(TreeOracle sulOracle, TreeOracle hypOracle, this.sdtOracle = sdtOracle; this.components = components; this.consts = consts; + if (sulOracle instanceof MultiTheoryTreeOracle) { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, ((MultiTheoryTreeOracle)sulOracle).getTeachers()); + } else { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); + } } public CEAnalysisResult analyzeCounterexample(Word ce) { @@ -77,7 +86,7 @@ public CEAnalysisResult analyzeCounterexample(Word ce) { Word prefix = ce.prefix(idx); Word suffix = ce.suffix(ce.length() -idx); - SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, consts); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, restrictionBuilder); return new CEAnalysisResult(prefix, symSuffix); } @@ -91,7 +100,7 @@ private IndexResult computeIndex(Word ce, int idx) { ce.prefix(idx+1)); Word suffix = ce.suffix(ce.length() -idx); - SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, consts); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, restrictionBuilder); TreeQueryResult resHyp = hypOracle.treeQuery(location, symSuffix); TreeQueryResult resSul = sulOracle.treeQuery(location, symSuffix); diff --git a/src/main/java/de/learnlib/ralib/learning/MeasuringOracle.java b/src/main/java/de/learnlib/ralib/learning/MeasuringOracle.java index 9de7083d..a78e86a1 100644 --- a/src/main/java/de/learnlib/ralib/learning/MeasuringOracle.java +++ b/src/main/java/de/learnlib/ralib/learning/MeasuringOracle.java @@ -2,23 +2,32 @@ import java.util.Map; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; import de.learnlib.ralib.data.PIV; import de.learnlib.ralib.oracles.Branching; -import de.learnlib.ralib.oracles.TreeOracle; +import de.learnlib.ralib.oracles.DataWordOracle; import de.learnlib.ralib.oracles.TreeQueryResult; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; +import de.learnlib.ralib.solver.ConstraintSolver; +import de.learnlib.ralib.theory.Theory; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; import net.automatalib.word.Word; -public class MeasuringOracle implements TreeOracle { - - private final TreeOracle oracle; +public class MeasuringOracle extends MultiTheoryTreeOracle { private final Measurements result; - public MeasuringOracle(TreeOracle oracle, Measurements m) { - this.oracle = oracle; - this.result = m; + public MeasuringOracle(DataWordOracle oracle, Map teachers, Constants constants, + ConstraintSolver solver, Measurements m) { + super(oracle, teachers, constants, solver); + result = m; + } + + public MeasuringOracle(MultiTheoryTreeOracle mto, Measurements m) { + super(mto); + result = m; } @Override @@ -29,24 +38,24 @@ public TreeQueryResult treeQuery(Word prefix, SymbolicSuffix su result.treeQueryWords.put(key, result.treeQueryWords.get(key) + 1); else result.treeQueryWords.put(key, 1); - return oracle.treeQuery(prefix, suffix); + return super.treeQuery(prefix, suffix); } @Override public Branching getInitialBranching(Word prefix, ParameterizedSymbol ps, PIV piv, SymbolicDecisionTree... sdts) { - return oracle.getInitialBranching(prefix, ps, piv, sdts); + return super.getInitialBranching(prefix, ps, piv, sdts); } @Override public Branching updateBranching(Word prefix, ParameterizedSymbol ps, Branching current, PIV piv, SymbolicDecisionTree... sdts) { - return oracle.updateBranching(prefix, ps, current, piv, sdts); + return super.updateBranching(prefix, ps, current, piv, sdts); } @Override public Map, Boolean> instantiate(Word prefix, SymbolicSuffix suffix, SymbolicDecisionTree sdt, PIV piv) { - return oracle.instantiate(prefix, suffix, sdt, piv); + return super.instantiate(prefix, suffix, sdt, piv); } } diff --git a/src/main/java/de/learnlib/ralib/learning/SymbolicSuffix.java b/src/main/java/de/learnlib/ralib/learning/SymbolicSuffix.java index 648a2684..f01f2f6c 100644 --- a/src/main/java/de/learnlib/ralib/learning/SymbolicSuffix.java +++ b/src/main/java/de/learnlib/ralib/learning/SymbolicSuffix.java @@ -17,7 +17,6 @@ package de.learnlib.ralib.learning; import java.util.Arrays; -import java.util.Collection; import java.util.Comparator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; @@ -29,6 +28,11 @@ import de.learnlib.ralib.data.DataValue; import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; +import de.learnlib.ralib.theory.FreshSuffixValue; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; +import de.learnlib.ralib.theory.equality.EqualRestriction; import de.learnlib.ralib.words.DataWords; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; @@ -43,19 +47,19 @@ public class SymbolicSuffix { /** - * symbolic values that may connect to a prefix + * actions */ - private final Set freeValues; + private final Word actions; /** - * Map of positions to data values + * restrictions on suffix values */ - private final Map dataValues; + private final Map restrictions; /** - * actions + * are generic suffix optimizations (fresh, equal to prior suffix value or unrestricted) used */ - private final Word actions; + private boolean genericOptimizations = true; public SymbolicSuffix(Word prefix, Word suffix) { @@ -63,14 +67,12 @@ public SymbolicSuffix(Word prefix, } public SymbolicSuffix(SymbolicSuffix s) { - freeValues = new LinkedHashSet<>(); - dataValues = new LinkedHashMap<>(); + genericOptimizations = s.genericOptimizations; actions = Word.fromWords(s.actions); + restrictions = new LinkedHashMap<>(); - for (SuffixValue sv : s.freeValues) - freeValues.add(sv.copy()); - for (Map.Entry dv : s.dataValues.entrySet()) - dataValues.put(dv.getKey(), dv.getValue().copy()); + for (Map.Entry r : s.restrictions.entrySet()) + restrictions.put(r.getKey(), r.getValue()); } /** @@ -89,48 +91,35 @@ public SymbolicSuffix(SymbolicSuffix s) { public SymbolicSuffix(Word prefix, Word suffix, Constants consts) { -// log.trace(prefix.toString() + "\n" + suffix.toString()); - this.actions = DataWords.actsOf(suffix); - this.dataValues = new LinkedHashMap<>(); - this.freeValues = new LinkedHashSet<>(); - - Map groups = new LinkedHashMap<>(); - Set> valsetPrefix = DataWords.valSet(prefix); - int idx = 1; + this.restrictions = new LinkedHashMap<>(); - SuffixValueGenerator valgen = new SuffixValueGenerator(); - - int arityFirst = 0; - if (this.actions.length() > 0) { - ParameterizedSymbol first = this.actions.firstSymbol(); - arityFirst = first.getArity(); + SuffixValueGenerator svgen = new SuffixValueGenerator(); + for (DataValue dv : DataWords.valsOf(suffix)) { + SuffixValue sv = svgen.next(dv.getType()); + SuffixValueRestriction restriction = SuffixValueRestriction.genericRestriction(sv, prefix, suffix, consts); + restrictions.put(sv, restriction); } + } - for (DataValue d : DataWords.valsOf(suffix)) { - if (valsetPrefix.contains(d) || consts.containsValue(d) || - // TODO: this changes with essentialized suffixes (!) - // we know that equalities are essential - (groups.containsKey(d) && idx <= arityFirst)) { - //if (valsetPrefix.contains(d) || consts.containsValue(d)) { - SuffixValue sym = valgen.next(d.getType()); - this.freeValues.add(sym); - this.dataValues.put(idx, sym); -// log.trace("adding " + sym.toString() + " at " + idx); - - } else { - SuffixValue ref = groups.get(d); - if (ref == null) { - ref = valgen.next(d.getType()); - groups.put(d, ref); - } - this.dataValues.put(idx, ref); - } - idx++; - } + /** + * creates a symbolic suffix from a prefix and a suffix + * data word. + * Relations between data values will be optimized + * according to theory + * + * @param prefix + * @param suffix + * @param restrictionBuilder - assigns restrictions on suffix values according to the theory + */ + public SymbolicSuffix(Word prefix, Word suffix, SymbolicSuffixRestrictionBuilder restrictionBuilder) { + this.genericOptimizations = false; + this.actions = DataWords.actsOf(suffix); + this.restrictions = restrictionBuilder.restrictSuffix(prefix, suffix); } + public SymbolicSuffix(ParameterizedSymbol ps) { this(Word.fromSymbols(ps)); } @@ -138,16 +127,14 @@ public SymbolicSuffix(ParameterizedSymbol ps) { public SymbolicSuffix(Word actions) { this.actions = actions; - this.dataValues = new LinkedHashMap<>(); - this.freeValues = new LinkedHashSet<>(); + this.restrictions = new LinkedHashMap<>(); SuffixValueGenerator valgen = new SuffixValueGenerator(); int idx = 1; for (ParameterizedSymbol ps : actions) { for (DataType t : ps.getPtypes()) { SuffixValue sv = valgen.next(t); - this.freeValues.add(sv); - this.dataValues.put(idx++, sv); + restrictions.put(sv, new UnrestrictedSuffixValue(sv)); } } } @@ -163,79 +150,111 @@ public SymbolicSuffix(Word prefix, this.actions = symSuffix.actions.prepend( DataWords.actsOf(prefix).lastSymbol()); - this.dataValues = new LinkedHashMap<>(); - this.freeValues = new LinkedHashSet<>(); + this.restrictions = new LinkedHashMap<>(); Word suffix = prefix.suffix(1); prefix = prefix.prefix(prefix.length() - 1); - Map groups = new LinkedHashMap<>(); - Set> valsetPrefix = DataWords.valSet(prefix); - int idx = 1; - - SuffixValueGenerator valgen = new SuffixValueGenerator(); - - for (DataValue d : DataWords.valsOf(suffix)) { - if (valsetPrefix.contains(d) || consts.containsValue(d)) { - SuffixValue sym = valgen.next(d.getType()); - this.freeValues.add(sym); - this.dataValues.put(idx, sym); -// log.trace("adding " + sym.toString() + " at " + idx); - - } else { - SuffixValue ref = groups.get(d); - if (ref == null) { - ref = valgen.next(d.getType()); - groups.put(d, ref); - } - this.dataValues.put(idx, ref); - } - idx++; + SuffixValueGenerator svgen = new SuffixValueGenerator(); + for (DataValue dv : DataWords.valsOf(suffix)) { + SuffixValue sv = svgen.next(dv.getType()); + SuffixValueRestriction restriction = SuffixValueRestriction.genericRestriction(sv, prefix, suffix, consts); + restrictions.put(sv, restriction); } - Map symValues = new LinkedHashMap<>(); - for (int i=1; i<=DataWords.paramLength(symSuffix.actions); i++) { - SuffixValue symValue = symSuffix.getDataValue(i); - SuffixValue shifted = symValues.get(symValue); - if (shifted == null) { - shifted = valgen.next(symValue.getType()); - symValues.put(symValue, shifted); - } - this.dataValues.put(idx++, shifted); - if (symSuffix.freeValues.contains(symValue)) { - this.freeValues.add(shifted); - } + int actionArity = suffix.firstSymbol().getBaseSymbol().getArity(); + for (Map.Entry e : symSuffix.restrictions.entrySet()) { + SuffixValue sv = e.getKey(); + SuffixValueRestriction restriction = e.getValue(); + SuffixValue s = new SuffixValue(sv.getType(), sv.getId()+actionArity); + restrictions.put(s, restriction.shift(actionArity)); } } + public SymbolicSuffix(Word prefix, SymbolicSuffix symSuffix, SymbolicSuffixRestrictionBuilder restrictionBuilder) { + + this.genericOptimizations = false; + this.actions = symSuffix.actions.prepend( + DataWords.actsOf(prefix).lastSymbol()); + + Word suffix = prefix.suffix(1); + prefix = prefix.prefix(prefix.length() - 1); + this.restrictions = restrictionBuilder.restrictSuffix(prefix, suffix); + + int actionArity = suffix.firstSymbol().getBaseSymbol().getArity(); + for (Map.Entry e : symSuffix.restrictions.entrySet()) { + SuffixValue sv = e.getKey(); + SuffixValueRestriction restriction = e.getValue(); + SuffixValue s = new SuffixValue(sv.getType(), sv.getId()+actionArity); + restrictions.put(s, restriction.shift(actionArity)); + } + } public SymbolicSuffix(Word actions, Map dataValues, Set freeValues) { this.actions = actions; - this.dataValues = dataValues; - this.freeValues = freeValues; + this.restrictions = new LinkedHashMap<>(); + + Set seen = new LinkedHashSet<>(); + for (Map.Entry e : dataValues.entrySet()) { + SuffixValue sv = e.getValue(); + SuffixValue suffixValue = new SuffixValue(sv.getType(), e.getKey()); + if (freeValues.contains(sv)) { + restrictions.put(suffixValue, new UnrestrictedSuffixValue(suffixValue)); + seen.add(sv); + } else if (seen.contains(sv)) { + int id = dataValues.entrySet() + .stream().filter((a) -> (a.getValue().equals(sv))) + .sorted(Map.Entry.comparingByKey(Comparator.naturalOrder())) + .findFirst() + .get() + .getKey(); + SuffixValue equalSV = new SuffixValue(suffixValue.getType(), id); + restrictions.put(suffixValue, new EqualRestriction(suffixValue, equalSV)); + } else { + restrictions.put(suffixValue, new FreshSuffixValue(suffixValue)); + seen.add(sv); + } + } } - public SymbolicSuffix(SymbolicSuffix suffix, Set freeValues) { - this.actions = suffix.actions; - this.dataValues = suffix.dataValues; - this.freeValues = freeValues; + public SymbolicSuffix(Word actions, Map restrictions) { + this.genericOptimizations = false; + this.actions = actions; + this.restrictions = restrictions; + } + + public SuffixValueRestriction getRestriction(SuffixValue sv) { + return restrictions.get(sv); + } + + public SuffixValue getSuffixValue(int i) { + for (SuffixValue sv : restrictions.keySet()) { + if (sv.getId() == i) + return sv; + } + return null; } public SuffixValue getDataValue(int i) { - return this.dataValues.get(i); + return (SuffixValue)restrictions.keySet().toArray()[i-1]; } - public Collection getDataValues() { - return this.dataValues.values(); + public Set getDataValues() { + return restrictions.keySet(); } public Set getFreeValues() { - return this.freeValues; + Set freeValues = new LinkedHashSet<>(); + for (Map.Entry restr : restrictions.entrySet()) { + if (restr.getValue() instanceof UnrestrictedSuffixValue) + freeValues.add(restr.getKey()); + } + return freeValues; } public Set getValues() { - LinkedHashSet suffixValues = new LinkedHashSet<>(dataValues.values()); + LinkedHashSet suffixValues = new LinkedHashSet<>(restrictions.keySet()); return suffixValues; } @@ -243,59 +262,33 @@ public Word getActions() { return actions; } - public int getSuffixValueIndex(SuffixValue sv) { - if (!dataValues.values().contains(sv)) - return -1; - return dataValues.entrySet() - .stream().filter((a) -> (a.getValue().equals(sv))) - .sorted(Map.Entry.comparingByKey(Comparator.naturalOrder())) - .findFirst() - .get() - .getKey(); - } - public SymbolicSuffix concat(SymbolicSuffix other) { - Word actions = this.getActions().concat(other.actions); - Map dataValues = new LinkedHashMap<>(this.dataValues); - Set freeValues = new LinkedHashSet<>(this.getFreeValues()); - int offset = this.dataValues.size(); - - for (Map.Entry entry : other.dataValues.entrySet()) { - SuffixValue sv = new SuffixValue(entry.getValue().getType(), entry.getValue().getId() + offset); - dataValues.put(entry.getKey() + offset, sv); - if (other.getFreeValues().contains(entry.getValue())) { - freeValues.add(sv); - } - } - - SymbolicSuffix concatenatedSuffix = new SymbolicSuffix(actions, dataValues, freeValues); - return concatenatedSuffix; - } - public int optimizationValue() { - int score = dataValues.size() - freeValues.size(); - int index = 2; - for (int i = 1; i < dataValues.size(); i++) { - SuffixValue sv = dataValues.get(i+1); - if (sv.getId().intValue() == index) - index++; - else - score++; + Word actions = this.getActions().concat(other.actions); + Map concatRestr = new LinkedHashMap<>(); + int arity = restrictions.size(); + concatRestr.putAll(restrictions); + for (Map.Entry e : other.restrictions.entrySet()) { + SuffixValue sv = new SuffixValue(e.getKey().getType(), e.getKey().getId()+arity); + SuffixValueRestriction restr = e.getValue().shift(arity); + concatRestr.put(sv, restr); } - return score; + return new SymbolicSuffix(actions, concatRestr); } public int length() { return actions.length(); } + public boolean isOptimizationGeneric() { + return genericOptimizations; + } + @Override public String toString() { Word dw = - DataWords.instantiate(actions, dataValues); - - return Arrays.toString(freeValues.toArray()) + - "((" + dw.toString() + "))"; + DataWords.instantiate(actions, restrictions.keySet()); + return "((" + dw.toString() + "))" + Arrays.toString(restrictions.values().toArray()); } @Override @@ -307,11 +300,8 @@ public boolean equals(Object obj) { return false; } final SymbolicSuffix other = (SymbolicSuffix) obj; - if (this.freeValues != other.freeValues && (this.freeValues == null || !this.freeValues.equals(other.freeValues))) { - return false; - } - if (this.dataValues != other.dataValues && (this.dataValues == null || !this.dataValues.equals(other.dataValues))) { - return false; + if (this.restrictions != other.restrictions && (this.restrictions == null || !this.restrictions.equals(other.restrictions))) { + return false; } if (this.actions != other.actions && (this.actions == null || !this.actions.equals(other.actions))) { return false; @@ -322,8 +312,7 @@ public boolean equals(Object obj) { @Override public int hashCode() { int hash = 7; - hash = 37 * hash + (this.freeValues != null ? this.freeValues.hashCode() : 0); - hash = 37 * hash + (this.dataValues != null ? this.dataValues.hashCode() : 0); + hash = 37 * hash + (this.restrictions != null ? this.restrictions.hashCode() : 0); hash = 37 * hash + (this.actions != null ? this.actions.hashCode() : 0); return hash; } diff --git a/src/main/java/de/learnlib/ralib/learning/ralambda/RaDT.java b/src/main/java/de/learnlib/ralib/learning/ralambda/RaDT.java index f6184fb1..935a0fc7 100644 --- a/src/main/java/de/learnlib/ralib/learning/ralambda/RaDT.java +++ b/src/main/java/de/learnlib/ralib/learning/ralambda/RaDT.java @@ -26,6 +26,9 @@ import de.learnlib.ralib.oracles.SDTLogicOracle; import de.learnlib.ralib.oracles.TreeOracle; import de.learnlib.ralib.oracles.TreeOracleFactory; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; +import de.learnlib.ralib.oracles.mto.OptimizedSymbolicSuffixBuilder; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; import net.automatalib.word.Word; @@ -46,6 +49,9 @@ public class RaDT implements RaLearningAlgorithm { private final TreeOracleFactory hypOracleFactory; + private final OptimizedSymbolicSuffixBuilder suffixBuilder; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; + private QueryStatistics queryStats = null; private final boolean ioMode; @@ -59,6 +65,12 @@ public RaDT(TreeOracle oracle, TreeOracleFactory hypOracleFactory, SDTLogicOracl this.sdtLogicOracle = sdtLogicOracle; this.consts = consts; this.ioMode = ioMode; + if (oracle instanceof MultiTheoryTreeOracle) { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, ((MultiTheoryTreeOracle)oracle).getTeachers()); + } else { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); + } + this.suffixBuilder = new OptimizedSymbolicSuffixBuilder(consts, restrictionBuilder); this.dt = new DT(oracle, ioMode, consts, inputs); this.dt.initialize(); } @@ -123,7 +135,7 @@ private boolean analyzeCounterExample() { DTLeaf leaf = dt.getLeaf(accSeq); dt.addSuffix(res.getSuffix(), leaf); while(!dt.checkIOSuffixes()); - while(!dt.checkVariableConsistency(null)); + while(!dt.checkVariableConsistency(suffixBuilder)); buildHypothesis(); return true; } diff --git a/src/main/java/de/learnlib/ralib/learning/ralambda/RaLambda.java b/src/main/java/de/learnlib/ralib/learning/ralambda/RaLambda.java index 39e5bdab..4f2fa4a4 100644 --- a/src/main/java/de/learnlib/ralib/learning/ralambda/RaLambda.java +++ b/src/main/java/de/learnlib/ralib/learning/ralambda/RaLambda.java @@ -4,8 +4,10 @@ import java.util.Deque; import java.util.Iterator; import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.Map; +import java.util.Set; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -19,13 +21,14 @@ import de.learnlib.ralib.data.Mapping; import de.learnlib.ralib.data.PIV; import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.Parameter; +import de.learnlib.ralib.data.SymbolicDataValue.Register; import de.learnlib.ralib.dt.DT; import de.learnlib.ralib.dt.DTHyp; import de.learnlib.ralib.dt.DTLeaf; import de.learnlib.ralib.dt.MappedPrefix; import de.learnlib.ralib.dt.ShortPrefix; import de.learnlib.ralib.learning.AutomatonBuilder; -import de.learnlib.ralib.learning.CounterexampleAnalysis; import de.learnlib.ralib.learning.Hypothesis; import de.learnlib.ralib.learning.IOAutomatonBuilder; import de.learnlib.ralib.learning.LocationComponent; @@ -40,8 +43,10 @@ import de.learnlib.ralib.oracles.TreeOracle; import de.learnlib.ralib.oracles.TreeOracleFactory; import de.learnlib.ralib.oracles.TreeQueryResult; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; import de.learnlib.ralib.oracles.mto.OptimizedSymbolicSuffixBuilder; import de.learnlib.ralib.oracles.mto.SDT; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; import de.learnlib.ralib.solver.ConstraintSolver; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; @@ -70,6 +75,7 @@ public class RaLambda implements RaLearningAlgorithm { private final TreeOracleFactory hypOracleFactory; private final OptimizedSymbolicSuffixBuilder suffixBuilder; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; private ConstraintSolver solver = null; private QueryStatistics queryStats = null; @@ -100,13 +106,18 @@ public RaLambda(TreeOracle oracle, TreeOracleFactory hypOracleFactory, SDTLogicO boolean ioMode, boolean useOldAnalyzer, boolean thoroughSearch, ParameterizedSymbol... inputs) { this.ioMode = ioMode; - this.dt = new DT(oracle, ioMode, consts, inputs); this.consts = consts; this.sulOracle = oracle; this.sdtLogicOracle = sdtLogicOracle; this.hypOracleFactory = hypOracleFactory; this.useOldAnalyzer = useOldAnalyzer; - this.suffixBuilder = new OptimizedSymbolicSuffixBuilder(consts); + if (oracle instanceof MultiTheoryTreeOracle) { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, ((MultiTheoryTreeOracle)oracle).getTeachers()); + } else { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); + } + this.suffixBuilder = new OptimizedSymbolicSuffixBuilder(consts, restrictionBuilder); + this.dt = new DT(oracle, ioMode, consts, inputs); this.dt.initialize(); } @@ -150,8 +161,8 @@ private void buildNewHypothesis() { } private boolean analyzeCounterExample() { - if (useOldAnalyzer) - return analyzeCounterExampleOld(); +// if (useOldAnalyzer) +// return analyzeCounterExampleOld(); LOGGER.info(Category.PHASE, "Analyzing Counterexample"); if (candidateCEs.isEmpty()) { @@ -383,9 +394,10 @@ private boolean checkGuardConsistency() { if (suffix == null || suffix.length() > s.length()+1) { SymbolicSuffix testSuffix; if (suffixBuilder != null && tqr.getSdt() instanceof SDT) { - testSuffix = suffixBuilder.extendSuffix(word, (SDT)tqr.getSdt(), tqr.getPiv(), s); + Register[] differentlyMapped = differentlyMappedRegisters(tqr.getPiv(), otherTQR.getPiv()); + testSuffix = suffixBuilder.extendSuffix(word, (SDT)tqr.getSdt(), tqr.getPiv(), s, differentlyMapped); } else { - testSuffix = new SymbolicSuffix(word.prefix(word.length()-1), word.suffix(1), consts); + testSuffix = new SymbolicSuffix(word.prefix(word.length()-1), word.suffix(1), restrictionBuilder); testSuffix = testSuffix.concat(s); } TreeQueryResult testTQR = sulOracle.treeQuery(src_id, testSuffix); @@ -439,8 +451,8 @@ private SymbolicSuffix distinguishingSuffix(Word wa, DTLeaf ca, return suffix; } - SymbolicSuffix alpha_a = new SymbolicSuffix(prefixA, sa, consts); - SymbolicSuffix alpha_b = new SymbolicSuffix(prefixB, sb, consts); + SymbolicSuffix alpha_a = new SymbolicSuffix(prefixA, sa, restrictionBuilder); + SymbolicSuffix alpha_b = new SymbolicSuffix(prefixB, sb, restrictionBuilder); return alpha_a.getFreeValues().size() > alpha_b.getFreeValues().size() ? alpha_a.concat(v) : alpha_b.concat(v); @@ -464,47 +476,64 @@ private Word branchWithSameGuard(MappedPrefix mp, Branching bra return branching.transformPrefix(dw); } - private boolean analyzeCounterExampleOld() { - LOGGER.info(Category.PHASE, "Analyzing Counterexample"); - if (counterexamples.isEmpty()) { - return false; - } - - TreeOracle hypOracle = hypOracleFactory.createTreeOracle(hyp); - - Map, LocationComponent> components = new LinkedHashMap, LocationComponent>(); - components.putAll(dt.getComponents()); - CounterexampleAnalysis analysis = new CounterexampleAnalysis(sulOracle, hypOracle, hyp, sdtLogicOracle, - components, consts); - - DefaultQuery ce = counterexamples.peek(); - - // check if ce still is a counterexample ... - boolean hypce = hyp.accepts(ce.getInput()); - boolean sulce = ce.getOutput(); - if (hypce == sulce) { - LOGGER.info(Category.EVENT, "word is not a counterexample: " + ce + " - " + sulce); - counterexamples.poll(); - return false; - } - - if (queryStats != null) - queryStats.analyzingCounterExample(); - - CEAnalysisResult res = analysis.analyzeCounterexample(ce.getInput()); - - if (queryStats != null) { - queryStats.processingCounterExample(); - queryStats.analyzeCE(ce.getInput()); - } - - Word accSeq = hyp.transformAccessSequence(res.getPrefix()); - DTLeaf leaf = dt.getLeaf(accSeq); - dt.addSuffix(res.getSuffix(), leaf); - while(!dt.checkVariableConsistency(suffixBuilder)); - return true; + private Register[] differentlyMappedRegisters(PIV piv1, PIV piv2) { + Set differentlyMapped = new LinkedHashSet<>(); + for (Map.Entry e1 : piv1.entrySet()) { + Parameter p1 = e1.getKey(); + Register r1 = e1.getValue(); + for (Map.Entry e2 : piv2.entrySet()) { + Parameter p2 = e2.getKey(); + Register r2 = e2.getValue(); + if (r1.equals(r2) && !p1.equals(p2)) { + differentlyMapped.add(r1); + } + } + } + Register[] ret = new Register[differentlyMapped.size()]; + return differentlyMapped.toArray(ret); } +// private boolean analyzeCounterExampleOld() { +// log.logPhase("Analyzing Counterexample"); +// if (counterexamples.isEmpty()) { +// return false; +// } +// +// TreeOracle hypOracle = hypOracleFactory.createTreeOracle(hyp); +// +// Map, LocationComponent> components = new LinkedHashMap, LocationComponent>(); +// components.putAll(dt.getComponents()); +// CounterexampleAnalysis analysis = new CounterexampleAnalysis(sulOracle, hypOracle, hyp, sdtLogicOracle, +// components, consts); +// +// DefaultQuery ce = counterexamples.peek(); +// +// // check if ce still is a counterexample ... +// boolean hypce = hyp.accepts(ce.getInput()); +// boolean sulce = ce.getOutput(); +// if (hypce == sulce) { +// log.logEvent("word is not a counterexample: " + ce + " - " + sulce); +// counterexamples.poll(); +// return false; +// } +// +// if (queryStats != null) +// queryStats.analyzingCounterExample(); +// +// CEAnalysisResult res = analysis.analyzeCounterexample(ce.getInput()); +// +// if (queryStats != null) { +// queryStats.processingCounterExample(); +// queryStats.analyzeCE(ce.getInput()); +// } +// +// Word accSeq = hyp.transformAccessSequence(res.getPrefix()); +// DTLeaf leaf = dt.getLeaf(accSeq); +// dt.addSuffix(res.getSuffix(), leaf); +// while(!dt.checkVariableConsistency(suffixBuilder)); +// return true; +// } + @Override public Hypothesis getHypothesis() { Map, LocationComponent> components = new LinkedHashMap, LocationComponent>(); diff --git a/src/main/java/de/learnlib/ralib/learning/rastar/Component.java b/src/main/java/de/learnlib/ralib/learning/rastar/Component.java index cd9d7ee7..a97feb5d 100644 --- a/src/main/java/de/learnlib/ralib/learning/rastar/Component.java +++ b/src/main/java/de/learnlib/ralib/learning/rastar/Component.java @@ -41,6 +41,7 @@ import de.learnlib.ralib.learning.SymbolicSuffix; import de.learnlib.ralib.oracles.Branching; import de.learnlib.ralib.oracles.TreeOracle; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; import de.learnlib.ralib.words.DataWords; import de.learnlib.ralib.words.InputSymbol; import de.learnlib.ralib.words.PSymbolInstance; @@ -67,13 +68,16 @@ public class Component implements LocationComponent { private final Constants consts; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; + private static final Logger LOGGER = LoggerFactory.getLogger(Component.class); - public Component(Row primeRow, ObservationTable obs, boolean ioMode, Constants consts) { + public Component(Row primeRow, ObservationTable obs, boolean ioMode, Constants consts, SymbolicSuffixRestrictionBuilder restrictionBuilder) { this.primeRow = primeRow; this.obs = obs; this.ioMode = ioMode; this.consts = consts; + this.restrictionBuilder = restrictionBuilder; } /** @@ -153,7 +157,7 @@ void addSuffix(SymbolicSuffix suffix, TreeOracle oracle) { } if (!added) { - Component c = new Component(r, obs, ioMode, consts); + Component c = new Component(r, obs, ioMode, consts, restrictionBuilder); newComponents.add(c); } } @@ -222,7 +226,7 @@ private boolean checkVariableConsistency(Row r) { if (!memPrefix.containsKey(p) && p.getId() <= max) { SymbolicSuffix suffix = r.getSuffixForMemorable(p); SymbolicSuffix newSuffix = new SymbolicSuffix( - r.getPrefix(), suffix, consts); + r.getPrefix(), suffix, restrictionBuilder); // System.out.println("Found inconsistency. msissing " + p + // " in mem. of " + prefix); diff --git a/src/main/java/de/learnlib/ralib/learning/rastar/ObservationTable.java b/src/main/java/de/learnlib/ralib/learning/rastar/ObservationTable.java index 9a53aae2..45b1c25a 100644 --- a/src/main/java/de/learnlib/ralib/learning/rastar/ObservationTable.java +++ b/src/main/java/de/learnlib/ralib/learning/rastar/ObservationTable.java @@ -29,6 +29,8 @@ import de.learnlib.ralib.data.Constants; import de.learnlib.ralib.learning.SymbolicSuffix; import de.learnlib.ralib.oracles.TreeOracle; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; import net.automatalib.word.Word; @@ -59,6 +61,8 @@ class ObservationTable { private final Constants consts; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; + private static Logger LOGGER = LoggerFactory.getLogger(ObservationTable.class); public ObservationTable(TreeOracle oracle, boolean ioMode, @@ -67,6 +71,11 @@ public ObservationTable(TreeOracle oracle, boolean ioMode, this.inputs = inputs; this.ioMode = ioMode; this.consts = consts; + if (oracle instanceof MultiTheoryTreeOracle) { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, ((MultiTheoryTreeOracle)oracle).getTeachers()); + } else { + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); + } } void addComponent(Component c) { @@ -152,7 +161,7 @@ private void processNewPrefix() { return; } } - Component c = new Component(r, this, ioMode, consts); + Component c = new Component(r, this, ioMode, consts, restrictionBuilder); addComponent(c); } diff --git a/src/main/java/de/learnlib/ralib/oracles/mto/LabeledSDT.java b/src/main/java/de/learnlib/ralib/oracles/mto/LabeledSDT.java new file mode 100644 index 00000000..bf7dc725 --- /dev/null +++ b/src/main/java/de/learnlib/ralib/oracles/mto/LabeledSDT.java @@ -0,0 +1,184 @@ +package de.learnlib.ralib.oracles.mto; + +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +import de.learnlib.ralib.theory.SDTGuard; + +public class LabeledSDT { + + private final int label; + + private final SDT sdt; + + private final Map children = new LinkedHashMap<>(); + + public LabeledSDT(int label, SDT sdt) { + this.label = label; + this.sdt = sdt; +// children = new LinkedHashMap<>(); + + int currentLabel = label; + if (!(sdt instanceof SDTLeaf)) { + for (Map.Entry e : sdt.getChildren().entrySet()) { + LabeledSDT child = new LabeledSDT(currentLabel+1, e.getValue()); + currentLabel = child.getMaxLabel(); + children.put(e.getKey(), child); + } + } + } + + private LabeledSDT(LabeledSDT other, int prunedLabel) { + label = other.label; + sdt = other.sdt; + + int currentLabel = label+1; + if (!(sdt instanceof SDTLeaf)) { + for (Map.Entry e : other.children.entrySet()) { + LabeledSDT child = new LabeledSDT(e.getValue(), prunedLabel); + if (currentLabel != prunedLabel) { + children.put(e.getKey(), child); + } +// currentLabel = child.getMaxLabel() + 1; + currentLabel = e.getValue().getMaxLabel() + 1; + } + } + } + + public int getMaxLabel() { + int max = label; + for (LabeledSDT child : children.values()) { + int m = child.getMaxLabel(); + max = m > max ? m : max; + } + return max; + } + + public int getMinLabel() { + return getLabel(); + } + + public int getLabel() { + return label; + } + + public Set getChildIndices() { + Set indices = new LinkedHashSet<>(); + for (LabeledSDT child : children.values()) { + indices.add(child.label); + } + return indices; + } + + public Map getChildren() { + return children; + } + + public SDT getSDT() { + return sdt; + } + + public LabeledSDT getParent(int l) { + for (LabeledSDT child : children.values()) { + if (child.getLabel() == l) + return this; + } + for (LabeledSDT child : children.values()) { + LabeledSDT ret = child.getParent(l); + if (ret != null) + return ret; + } + return null; + } + + public SDT toUnlabeled() { + if (sdt instanceof SDTLeaf) + return sdt; + Map sdtChildren = new LinkedHashMap<>(); + for (Map.Entry e : children.entrySet()) { + sdtChildren.put(e.getKey(), e.getValue().toUnlabeled()); + } + return new SDT(sdtChildren); + } + + public LabeledSDT get(int l) { + if (l == label) + return this; + else { + for (LabeledSDT child : children.values()) { + LabeledSDT lsdt = child.get(l); + if (lsdt != null) + return lsdt; + } + } + return null; + } + + public SDTGuard getGuard(int l) { + for (Map.Entry e : children.entrySet()) { + if (e.getValue().getLabel() == l) + return e.getKey(); + SDTGuard g = e.getValue().getGuard(l); + if (g != null) + return g; + } + return null; + } + + public static LabeledSDT pruneBranch(LabeledSDT lsdt, int label) { + if (label == lsdt.getLabel()) + return null; + return new LabeledSDT(lsdt, label); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + String regs = Arrays.toString(sdt.getRegisters().toArray()); + sb.append(regs).append("-+\n"); + toString(sb, spaces(regs.length())); + return sb.toString(); + } + + void toString(StringBuilder sb, String indentation) { + if (sdt instanceof SDTLeaf) { + sb.append(indentation).append("[Leaf").append(sdt.isAccepting() ? "+" : "-").append("]").append("\n"); + } else { + LabeledSDT idioticSdt = this; + sb.append(indentation).append("[]"); + final int childCount = idioticSdt.children.size(); + int count = 1; + for (Entry e : idioticSdt.children.entrySet()) { + SDTGuard g = e.getKey(); + String gString = g.toString(); + String nextIndent; + if (count == childCount) { + nextIndent = indentation + " "; + } else { + nextIndent = indentation + " | "; + } + + if (count > 1) { + sb.append(indentation).append(" +"); + } + sb.append("- ").append(e.getValue().label).append(":").append(gString).append("\n"); + e.getValue().toString(sb, nextIndent); + + count++; + } + } + } + + private String spaces(int max) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < max; i++) { + sb.append(" "); + } + return sb.toString(); + } + +} diff --git a/src/main/java/de/learnlib/ralib/oracles/mto/MultiTheoryTreeOracle.java b/src/main/java/de/learnlib/ralib/oracles/mto/MultiTheoryTreeOracle.java index 96b44be1..73010901 100644 --- a/src/main/java/de/learnlib/ralib/oracles/mto/MultiTheoryTreeOracle.java +++ b/src/main/java/de/learnlib/ralib/oracles/mto/MultiTheoryTreeOracle.java @@ -97,6 +97,13 @@ public MultiTheoryTreeOracle(DataWordOracle oracle, Map teache this.solver = solver; } + public MultiTheoryTreeOracle(MultiTheoryTreeOracle other) { + this.oracle = other.oracle; + this.teachers = other.teachers; + this.constants = other.constants; + this.solver = other.solver; + } + @Override public TreeQueryResult treeQuery(Word prefix, SymbolicSuffix suffix) { PIV pir = new PIV(); @@ -570,4 +577,9 @@ public boolean accepts(Word prefix, Word suffi return expr.isSatisfied(mapping); } + + public Map getTeachers() { + return teachers; + } + } diff --git a/src/main/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilder.java b/src/main/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilder.java index befe385e..33ff3b84 100644 --- a/src/main/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilder.java +++ b/src/main/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilder.java @@ -1,9 +1,7 @@ package de.learnlib.ralib.oracles.mto; import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; +import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; @@ -23,14 +21,12 @@ import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.data.VarMapping; import de.learnlib.ralib.data.util.SymbolicDataValueGenerator; -import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.ParameterGenerator; -import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; import de.learnlib.ralib.learning.SymbolicSuffix; import de.learnlib.ralib.solver.ConstraintSolver; import de.learnlib.ralib.theory.SDTGuard; import de.learnlib.ralib.theory.SDTTrueGuard; -import de.learnlib.ralib.theory.equality.DisequalityGuard; -import de.learnlib.ralib.theory.equality.EqualityGuard; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; import de.learnlib.ralib.words.DataWords; import de.learnlib.ralib.words.PSymbolInstance; import de.learnlib.ralib.words.ParameterizedSymbol; @@ -40,8 +36,16 @@ public class OptimizedSymbolicSuffixBuilder { private final Constants consts; + private final SymbolicSuffixRestrictionBuilder restrictionBuilder; + public OptimizedSymbolicSuffixBuilder(Constants consts) { - this.consts = consts; + this.consts = consts; + this.restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts); + } + + public OptimizedSymbolicSuffixBuilder(Constants consts, SymbolicSuffixRestrictionBuilder restrictionBuilder) { + this.consts = consts; + this.restrictionBuilder = restrictionBuilder; } /** @@ -55,251 +59,249 @@ public OptimizedSymbolicSuffixBuilder(Constants consts) { * @param sdt * @param piv * @param suffix + * @param registers - a list of registers that must be revealed by the suffix * @return a new suffix formed by prepending suffix with the last symbol of prefix */ - public SymbolicSuffix extendSuffix(Word prefix, SDT sdt, PIV piv, SymbolicSuffix suffix) { - assert !prefix.isEmpty(); - - Word sub = prefix.prefix(prefix.length()-1); - PSymbolInstance action = prefix.lastSymbol(); - SymbolicSuffix actionSuffix = new SymbolicSuffix(sub, Word.fromSymbols(action), consts); - Set actionRegisters = actionRegisters(sub, action, piv); - Map sdvMap = new LinkedHashMap<>(); - - int arity = action.getBaseSymbol().getArity(); - int suffixParameters = DataWords.paramLength(suffix.getActions()); - - // find which values are free - Set newFreeValues = new LinkedHashSet<>(); - for (int i = 0; i < suffixParameters; i++) { - int pos = i + 1; - SuffixValue sv = suffix.getDataValue(pos); - Set comparands = sdt.getComparands(new SuffixValue(sv.getType(), pos)); - Set registers = new LinkedHashSet<>(); - comparands.stream().filter((x) -> (x.isRegister())).forEach((x) -> { registers.add((Register)x); }); - - // determine whether a suffix value is free - if (!actionRegisters.containsAll(registers) || - comparands.size() > 1 || - comparands.stream().anyMatch((x) -> (x.isConstant())) || - (comparands.size() == 1 && newFreeValues.contains(comparands.iterator().next().getId()-arity))) { - newFreeValues.add(pos + arity); - } else if (comparands.size() == 1) { - // if non-free and equal to a single symbolic data value, remember that value - SymbolicDataValue sdv = comparands.iterator().next(); - for (SDTGuard g : sdt.getSDTGuards(sv)) { - if (g instanceof EqualityGuard) { - sdvMap.put(new SuffixValue(sv.getType(), pos), sdv); - } - } - } - } - // free suffix values in the action - for (int i = 0; i < action.getBaseSymbol().getArity(); i++) { - if (actionSuffix.getFreeValues().contains(actionSuffix.getDataValue(i+1))) - newFreeValues.add(i+1); - } - - Map dataValues = new LinkedHashMap<>(); - Map actionParamaterMap = new LinkedHashMap<>(); - int startingIndex = 1 + DataWords.paramValLength(sub); - - // fill in suffix values from action - int position = 1; - ParameterizedSymbol actionSymbol = action.getBaseSymbol(); - SuffixValueGenerator svGen = new SuffixValueGenerator(); - for (int i = 0; i < actionSymbol.getArity(); i++ ) { - DataType dt = actionSymbol.getPtypes()[i]; - SuffixValue sv = actionSuffix.getDataValue(i+1); - if (!dataValues.values().contains(sv)) - svGen.next(dt); - dataValues.put(position, sv); - position++; - actionParamaterMap.put(new Parameter(dt, startingIndex+i), sv); + public SymbolicSuffix extendSuffix(Word prefix, SDT sdt, PIV piv, SymbolicSuffix suffix, Register... registers) { + Word suffixActions = suffix.getActions(); + if (registers.length > 0) { + SymbolicSuffix s = extendSuffixRevealingRegisters(prefix, sdt, piv, suffixActions, registers); + return s; } - // find relations - Map suffixDataValues = new LinkedHashMap<>(); - Map suffixRelations = new LinkedHashMap<>(); - for (int i = 1; i < suffixParameters + 1; i++) { - SuffixValue sv = suffix.getDataValue(i); - SymbolicDataValue sdv = sdvMap.get(new SuffixValue(sv.getType(), i)); - if (suffixDataValues.values().contains(sv)) { - int key = suffixDataValues.entrySet() - .stream() - .filter((a) -> (a.getValue().equals(sv))) - .sorted(Map.Entry.comparingByKey(Comparator.naturalOrder())) - .findFirst() - .get().getKey(); - suffixRelations.put(i+arity, key+arity); - } else if (sdv != null && sdv.isSuffixValue()) { - if (newFreeValues.contains(sdv.getId()+arity)) { - newFreeValues.add(i+arity); - } else { - suffixRelations.put(sv.getId()+arity, sdv.getId()+arity); - } - } else if (sdv != null && sdv.isRegister()) { - Parameter p = getParameter((Register)sdv, piv); - SuffixValue actionSV = actionParamaterMap.get(p); - if (actionSuffix.getFreeValues().contains(actionSV)) { - newFreeValues.add(i+arity); - } else { - suffixRelations.put(sv.getId()+arity, actionSV.getId()); - } + Set> paths = sdt.getAllPaths(new ArrayList<>()).keySet(); + SymbolicSuffix coalesced = null; + for (List path : paths) { + SymbolicSuffix extended = extendSuffix(prefix, path, piv, suffixActions); + if (coalesced == null) { + coalesced = extended; + } else { + coalesced = coalesceSuffixes(coalesced, extended); } - suffixDataValues.put(i, sv); - } - - if (suffixRelations.size() > 0) { - assert Collections.min(suffixRelations.keySet()) >= arity + 1; } + return coalesced; + } - // construct suffix - Word actions = suffix.getActions().prepend(action.getBaseSymbol()); - DataType[] dts = dataTypes(actions); - for (int i = 0; i < suffixParameters; i++) { - int pos = i + arity + 1; - Integer eq = suffixRelations.get(pos); - if (eq == null) { - dataValues.put(pos, svGen.next(dts[i])); + public SymbolicSuffix extendSuffixRevealingRegisters(Word prefix, SDT sdt, PIV piv, Word suffixActions, Register[] registers) { + SDT prunedSDT = pruneSDT(sdt, registers); + Set> paths = prunedSDT.getAllPaths(new ArrayList<>()).keySet(); + assert paths.size() > 0 : "All paths in SDT were pruned"; + SymbolicSuffix suffix = null; + for (List path : paths) { + SymbolicSuffix extended = extendSuffix(prefix, path, piv, suffixActions); + if (suffix == null) { + suffix = extended; } else { - dataValues.put(pos, dataValues.get(eq)); + suffix = mergeSuffixes(extended, suffix); } } - - Set freeValues = new LinkedHashSet<>(); - newFreeValues.stream().forEach((x) -> { freeValues.add(dataValues.get(x)); }); - - for (SuffixValue fv : freeValues) { - assert fv != null; - } - - return new SymbolicSuffix(actions, dataValues, freeValues); + return suffix; } public SymbolicSuffix extendSuffix(Word prefix, List sdtPath, PIV piv, Word suffixActions) { Word sub = prefix.prefix(prefix.length()-1); PSymbolInstance action = prefix.lastSymbol(); ParameterizedSymbol actionSymbol = action.getBaseSymbol(); - SymbolicSuffix actionSuffix = new SymbolicSuffix(sub, prefix.suffix(1), consts); + SymbolicSuffix actionSuffix = new SymbolicSuffix(sub, prefix.suffix(1), restrictionBuilder); int actionArity = actionSymbol.getArity(); - int suffixArity = DataWords.paramLength(suffixActions); - DataType[] suffixDataTypes = dataTypes(suffixActions); - Map actionParameters = buildParameterMap(sub, piv); - - Set freeValues = new LinkedHashSet<>(); - Map dataValues = new LinkedHashMap<>(); - - SuffixValueGenerator svGen = new SuffixValueGenerator(); - for (int i = 0; i < actionArity; i++) { - SuffixValue sv = actionSuffix.getDataValue(i+1); - SuffixValue suffixValue = dataValues.values().contains(sv) ? - sv : - svGen.next(actionSymbol.getPtypes()[i]); - dataValues.put(i+1, suffixValue); - if (actionSuffix.getFreeValues().contains(suffixValue)) - freeValues.add(suffixValue); + int subArity = DataWords.paramValLength(sub); + + Map restrictions = new LinkedHashMap<>(); + for (SuffixValue sv : actionSuffix.getDataValues()) { + restrictions.put(sv, actionSuffix.getRestriction(sv)); } - for (int i = 0; i < suffixArity; i++) { - int pos = i + actionArity + 1; - SuffixValue sv = new SuffixValue(suffixDataTypes[i], i+1); - Set comparands = new LinkedHashSet<>(); - sdtPath.stream().forEach((g) -> { comparands.addAll(g.getComparands(sv)); }); - Set guards = getGuards(sdtPath, sv); - assert !guards.isEmpty(); + VarMapping renaming = new VarMapping<>(); + for (Map.Entry e : piv.entrySet()) { + Parameter p = e.getKey(); + Register r = e.getValue(); + if (p.getId() > subArity) { + SuffixValue sv = new SuffixValue(p.getType(), p.getId()-subArity); + renaming.put(r, sv); + } + } + for (SDTGuard guard : sdtPath) { + SuffixValue oldSV = guard.getParameter(); + SuffixValue newSV = new SuffixValue(oldSV.getType(), oldSV.getId()+actionArity); + renaming.put(oldSV, newSV); + // for some reason, true guards ignore relabelling + SDTGuard renamedGuard = guard instanceof SDTTrueGuard ? new SDTTrueGuard(newSV) : guard.relabel(renaming); + SuffixValueRestriction restr = restrictionBuilder.restrictSuffixValue(renamedGuard, restrictions); + restrictions.put(newSV, restr); + } - boolean free = true; - SuffixValue equalSV = null; + Word actions = suffixActions.prepend(actionSymbol); + return new SymbolicSuffix(actions, restrictions); + } - if (guards.size() > 1) { - free = true; - } else { - SDTGuard guard = guards.iterator().next(); - if (guard instanceof SDTTrueGuard) { - free = false; - } else if (guard instanceof EqualityGuard || guard instanceof DisequalityGuard) { - SuffixValue comparedSV = null; - if (comparands.size() > 1) { - free = true; - } else { - assert comparands.size() == 1; - SymbolicDataValue sdv = comparands.iterator().next(); - if (sdv.isSuffixValue()) { - comparedSV = dataValues.get(sdv.getId()+actionArity); - } else if (sdv.isRegister()) { - comparedSV = actionParameters.get(sdv); - } - if (comparedSV != null && !freeValues.contains(comparedSV)) { - free = false; - if (guard instanceof EqualityGuard) - equalSV = comparedSV; - } - else - free = true; - } - } else { - free = true; + protected SDT pruneSDT(SDT sdt, SymbolicDataValue[] registers) { + LabeledSDT lsdt = new LabeledSDT(0, sdt); + LabeledSDT pruned = pruneSDTNode(lsdt, lsdt, registers); + return pruned.toUnlabeled(); + } + + private LabeledSDT pruneSDTNode(LabeledSDT lsdt, LabeledSDT node, SymbolicDataValue[] registers) { + LabeledSDT pruned = lsdt; + int nodeLabel = node.getLabel(); + for (int label : node.getChildIndices()) { + if (pruned.get(nodeLabel).getChildren().size() < 2) + break; + pruned = pruneSDTBranch(pruned, label, registers); + } + for (int label : pruned.get(nodeLabel).getChildIndices()) { + LabeledSDT parent = pruned.get(label); + if (parent != null) + pruned = pruneSDTNode(pruned, parent, registers); + } + return pruned; + } + + private LabeledSDT pruneSDTBranch(LabeledSDT lsdt, int label, SymbolicDataValue[] registers) { + if (branchContainsRegister(lsdt.get(label), registers) || + guardOnRegisters(lsdt.getGuard(label), registers)) + return lsdt; + LabeledSDT pruned = LabeledSDT.pruneBranch(lsdt, label); + SDT prunedSDT = pruned.toUnlabeled(); + int revealedRegisters = 0; + for (SymbolicDataValue r : registers) { + if (guardsOnRegisterHaveBothOutcomes(prunedSDT, r)) + revealedRegisters++; + } + if (revealedRegisters < registers.length) { + return lsdt; + } + return pruned; + } + + private boolean branchContainsRegister(LabeledSDT node, SymbolicDataValue[] registers) { + for (Map.Entry e : node.getChildren().entrySet()) { + SDTGuard guard = e.getKey(); + LabeledSDT child = e.getValue(); + Set comparands = guard.getComparands(guard.getParameter()); + for (SymbolicDataValue sdv : registers) { + if (comparands.contains(sdv)) { + return true; } } + boolean childContainsRegister = branchContainsRegister(child, registers); + if (childContainsRegister) + return true; + } + return false; + } - if (equalSV != null) { - dataValues.put(pos, equalSV); - } else { - SuffixValue suffixValue = svGen.next(suffixDataTypes[i]); - if (free) - freeValues.add(suffixValue); - dataValues.put(pos, suffixValue); + private boolean guardOnRegisters(SDTGuard guard, SymbolicDataValue[] registers) { + SuffixValue sv = guard.getParameter(); + for (SymbolicDataValue r : registers) { + if (guard.getComparands(sv).contains(r)) { + return true; } } + return false; + } - Word actions = suffixActions.prepend(actionSymbol); - return new SymbolicSuffix(actions, dataValues, freeValues); + private SymbolicSuffix mergeSuffixes(SymbolicSuffix suffix1, SymbolicSuffix suffix2) { + assert suffix1.getActions().equals(suffix2.getActions()); + + Map restrictions = new LinkedHashMap<>(); + for (SuffixValue sv : suffix1.getDataValues()) { + SuffixValueRestriction restr1 = suffix1.getRestriction(sv); + SuffixValueRestriction restr2 = suffix2.getRestriction(sv); + if (restr1.equals(restr2)) { + restrictions.put(sv, restr1); + } else { + restrictions.put(sv, new UnrestrictedSuffixValue(sv)); + } + } + return new SymbolicSuffix(suffix1.getActions(), restrictions); } - private Set getGuards(List path, SuffixValue sv) { + public boolean sdtRevealsRegister(SDT sdt, SymbolicDataValue register) { + if (sdt instanceof SDTLeaf) { + return false; + } + + Map children = sdt.getChildren(); Set guards = new LinkedHashSet<>(); - for (SDTGuard g : path) { - if (g.getParameter().equals(sv)) - guards.add(g); + for (Map.Entry branch : children.entrySet()) { + SDTGuard guard = branch.getKey(); + SDT s = branch.getValue(); + if (guard.getComparands(guard.getParameter()).contains(register)) { + guards.add(guard); + } else { + boolean revealed = sdtRevealsRegister(s, register); + if (revealed) + return true; + } } - return guards; - } - private DataType[] dataTypes(Word actions) { - Collection dataTypes = new ArrayList<>(); - for (ParameterizedSymbol ps : actions) { - for (DataType dt : ps.getPtypes()) { - dataTypes.add(dt); + // cannot have both outcomes if not at least 2 branches + if (guards.size() < 2) + return false; + + // find a guard that can accept + SDTGuard guardA = null; + for (SDTGuard g : guards) { + SDT s = children.get(g); + if (!s.getPaths(true).isEmpty()) { + guardA = g; + break; } } - DataType[] dts = new DataType[dataTypes.size()]; - dts = dataTypes.toArray(dts); - return dts; + if (guardA == null) + return false; + // exists other guard which can reject? + for (SDTGuard g : guards) { + if (g == guardA) + continue; + SDT s = children.get(g); + if (!s.getPaths(false).isEmpty()) { + return true; + } + } + return false; } - private Map buildParameterMap(Word prefix, PIV piv) { - int arity = DataWords.paramValLength(prefix); - Map actionParameters = new LinkedHashMap<>(); - for (Map.Entry e : piv.entrySet()) { - Parameter p = e.getKey(); - if (p.getId().intValue() > arity) { - int actionParameterIndex = p.getId() - arity; - actionParameters.put(e.getValue(), new SuffixValue(p.getType(), actionParameterIndex)); - } + private boolean guardsOnRegisterHaveBothOutcomes(SDT sdt, SymbolicDataValue register) { + if (sdt instanceof SDTLeaf) + return true; + + Map childrenWithRegister = new LinkedHashMap<>(); + for (Map.Entry e : sdt.getChildren().entrySet()) { + if (!e.getKey().getComparands(register).isEmpty()) + childrenWithRegister.put(e.getKey(), e.getValue()); + } + if (!childrenWithRegister.isEmpty()) { + if (!guardHasBothOutcomes(childrenWithRegister)) + return false; + } + boolean ret = true; + for (SDT child : sdt.getChildren().values()) { + ret = ret && guardsOnRegisterHaveBothOutcomes(child, register); } - return actionParameters; + return ret; } - private Parameter getParameter(Register r, PIV piv) { - for (Map.Entry e : piv) { - if (e.getValue().equals(r)) - return e.getKey(); + private boolean guardHasBothOutcomes(Map children) { + if (children.size() < 2) + return false; + Iterator guards = children.keySet().iterator(); + SDT firstSDT = children.get(guards.next()); + boolean hasAccepting = !firstSDT.getPaths(true).isEmpty(); + while(guards.hasNext()) { + // if hasAccepting, find rejecting + // else find accepting + if (!children.get(guards.next()).getPaths(!hasAccepting).isEmpty()) + return true; } - return null; + if (hasAccepting) { + // could not find rejecting, see if first sdt has rejecting + return !firstSDT.getPaths(false).isEmpty(); + } + return false; } - /** + /** * Provides a one-symbol extension of an (optimized) suffix for two non-empty prefixes leading to inequivalent locations, * based on the SDTs and associated PIVs that revealed the source of the inequivalence. */ @@ -315,23 +317,6 @@ public SymbolicSuffix extendDistinguishingSuffix(Word prefix1, return coalesceSuffixes(suffix1, suffix2); } - private Set actionRegisters(Word prefix, PSymbolInstance action, PIV piv) { - Set params = new LinkedHashSet<>(); - ParameterGenerator pGen = new ParameterGenerator(); - for (PSymbolInstance psi : prefix) { - for (DataType dt : psi.getBaseSymbol().getPtypes()) { - pGen.next(dt); - } - } - for (DataType dt : action.getBaseSymbol().getPtypes()) { - params.add(pGen.next(dt)); - } - - Set registers = new LinkedHashSet<>(); - piv.entrySet().stream().filter((x) -> (params.contains(x.getKey()))).forEach((x) -> { registers.add(x.getValue()); }); - return registers; - } - /** * Provides an optimized suffix to distinguish two inequivalent locations specified by prefixes, * based on the SDTs and associated PIVs that revealed the source of the inequivalence. @@ -399,59 +384,20 @@ private SymbolicSuffix buildOptimizedSuffix(Word prefix1, List< SymbolicSuffix coalesceSuffixes(SymbolicSuffix suffix1, SymbolicSuffix suffix2) { assert suffix1.getActions().equals(suffix2.getActions()); - Set freeValues = new LinkedHashSet<>(); - Map dataValues = new LinkedHashMap<>(); - Map sValMapping = new LinkedHashMap<>(); - SymbolicDataValueGenerator.SuffixValueGenerator sgen = new SymbolicDataValueGenerator.SuffixValueGenerator(); - Set freeIndices1 = freeSuffixIndices(suffix1); - Set freeIndices2 = freeSuffixIndices(suffix2); - Set seenVals1 = new LinkedHashSet<>(); - Set seenVals2 = new LinkedHashSet<>(); - - for (int i=0; i freeSuffixIndices(SymbolicSuffix suffix) { - Set freeIndices = new LinkedHashSet<>(); - Set freeVals = suffix.getFreeValues(); - for (int i = 0; i < DataWords.paramLength(suffix.getActions()); i++) { - SuffixValue sv = suffix.getDataValue(i+1); - if (freeVals.contains(sv)) - freeIndices.add(i+1); + Map restrictions = new LinkedHashMap<>(); + + SymbolicDataValueGenerator.SuffixValueGenerator sgen = new SymbolicDataValueGenerator.SuffixValueGenerator(); + for (int i=0; i getComparands(SymbolicDataValue dv) { return comparands; for (Map.Entry e : children.entrySet()) { SDTGuard g = e.getKey(); - if (g.getParameter().equals(dv)) - comparands.addAll(g.getComparands(dv)); - else - comparands.addAll(e.getValue().getComparands(dv)); + Set guardComparands = g.getComparands(dv); + if (!guardComparands.isEmpty()) { + comparands.addAll(guardComparands); + } + comparands.addAll(e.getValue().getComparands(dv)); } return comparands; } @@ -167,6 +168,17 @@ public Set getVariables() { return variables; } + public Set getSuffixValues() { + Set values = new LinkedHashSet<>(); + if (this instanceof SDTLeaf) + return values; + for (Entry e : children.entrySet()) { + values.add(e.getKey().getParameter()); + values.addAll(e.getValue().getSuffixValues()); + } + return values; + } + @Override public boolean isAccepting() { if (this instanceof SDTLeaf) { @@ -253,7 +265,6 @@ public SymbolicDecisionTree relabel(VarMapping relabelling) { return relabelled; } - /* *** * * Logging helpers @@ -495,6 +506,20 @@ Map, Boolean> getAllPaths(List path) { return ret; } + public boolean replaceBranch(SDTGuard guard, SDT from, SDT with) { + for (Map.Entry branch : children.entrySet()) { + if (branch.getKey().equals(guard) && branch.getValue().equals(from)) { + children.put(guard, with); + return true; + } else { + boolean done = branch.getValue().replaceBranch(guard, from, with); + if (done) + return true; + } + } + return false; + } + public static SDT getFinest(SDT... sdts) { return findFinest(0, Arrays.asList(sdts), sdts[0]); } diff --git a/src/main/java/de/learnlib/ralib/oracles/mto/SDTLeaf.java b/src/main/java/de/learnlib/ralib/oracles/mto/SDTLeaf.java index a1a29fc8..3290ba88 100644 --- a/src/main/java/de/learnlib/ralib/oracles/mto/SDTLeaf.java +++ b/src/main/java/de/learnlib/ralib/oracles/mto/SDTLeaf.java @@ -109,4 +109,9 @@ Map, Boolean> getAllPaths(List path) { public Set getRegisters() { return new LinkedHashSet<>(); } + + @Override + public SDT copy() { + return new SDTLeaf(accepting); + } } diff --git a/src/main/java/de/learnlib/ralib/oracles/mto/SymbolicSuffixRestrictionBuilder.java b/src/main/java/de/learnlib/ralib/oracles/mto/SymbolicSuffixRestrictionBuilder.java new file mode 100644 index 00000000..050e236c --- /dev/null +++ b/src/main/java/de/learnlib/ralib/oracles/mto/SymbolicSuffixRestrictionBuilder.java @@ -0,0 +1,68 @@ +package de.learnlib.ralib.oracles.mto; + +import java.util.LinkedHashMap; +import java.util.Map; + +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.theory.SDTGuard; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.words.DataWords; +import de.learnlib.ralib.words.PSymbolInstance; +import net.automatalib.word.Word; + +public class SymbolicSuffixRestrictionBuilder { + + private final Map teachers; + + private final Constants consts; + + public SymbolicSuffixRestrictionBuilder(Constants consts) { + this.consts = consts; + this.teachers = null; + } + + public SymbolicSuffixRestrictionBuilder(Constants consts, Map teachers) { + this.consts = consts; + this.teachers = teachers; + } + + public SymbolicSuffixRestrictionBuilder(Map teachers) { + this(new Constants(), teachers); + } + + public SymbolicSuffixRestrictionBuilder() { + this(new Constants()); + } + + + public Map restrictSuffix(Word prefix, Word suffix) { + DataType[] types = DataWords.typesOf(DataWords.actsOf(suffix)); + Map restrictions = new LinkedHashMap<>(); + SuffixValueGenerator svgen = new SuffixValueGenerator(); + for (DataType t : types) { + SuffixValue sv = svgen.next(t); + SuffixValueRestriction restr; + if (teachers == null) { + // use standard restrictions + restr = SuffixValueRestriction.genericRestriction(sv, prefix, suffix, consts); + } else { + // theory-specific restrictions + Theory theory = teachers.get(t); + restr = theory.restrictSuffixValue(sv, prefix, suffix, consts); + } + restrictions.put(sv, restr); + } + return restrictions; + } + + public SuffixValueRestriction restrictSuffixValue(SDTGuard guard, Map prior) { + if (teachers == null) + return SuffixValueRestriction.genericRestriction(guard, prior); + Theory theory = teachers.get(guard.getParameter().getType()); + return theory.restrictSuffixValue(guard, prior); + } +} diff --git a/src/main/java/de/learnlib/ralib/solver/jconstraints/JContraintsUtil.java b/src/main/java/de/learnlib/ralib/solver/jconstraints/JContraintsUtil.java index 8297d61f..6ee2c9aa 100644 --- a/src/main/java/de/learnlib/ralib/solver/jconstraints/JContraintsUtil.java +++ b/src/main/java/de/learnlib/ralib/solver/jconstraints/JContraintsUtil.java @@ -136,8 +136,12 @@ public static Expression toExpression(AtomicGuardExpression expr, return new NumericBooleanExpression(lv, NumericComparator.NE, rv); case SMALLER: return new NumericBooleanExpression(lv, NumericComparator.LT, rv); + case SMALLER_OR_EQUAL: + return new NumericBooleanExpression(lv, NumericComparator.LE, rv); case BIGGER: return new NumericBooleanExpression(lv, NumericComparator.GT, rv); + case BIGGER_OR_EQUAL: + return new NumericBooleanExpression(lv, NumericComparator.GE, rv); default: throw new UnsupportedOperationException( diff --git a/src/main/java/de/learnlib/ralib/theory/EquivalenceClassFilter.java b/src/main/java/de/learnlib/ralib/theory/EquivalenceClassFilter.java new file mode 100644 index 00000000..40ed1352 --- /dev/null +++ b/src/main/java/de/learnlib/ralib/theory/EquivalenceClassFilter.java @@ -0,0 +1,72 @@ +package de.learnlib.ralib.theory; + +import java.util.ArrayList; +import java.util.List; + +import de.learnlib.ralib.automata.guards.GuardExpression; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.Mapping; +import de.learnlib.ralib.data.SuffixValuation; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.Parameter; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.ParameterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.words.PSymbolInstance; +import de.learnlib.ralib.words.ParameterizedSymbol; +import net.automatalib.word.Word; + +public class EquivalenceClassFilter { + + private final List> equivClasses; + private boolean useOptimization; + + public EquivalenceClassFilter(List> equivClasses, boolean useOptimization) { + this.equivClasses = equivClasses; + this.useOptimization = useOptimization; + } + + public List> toList(SuffixValueRestriction restr, + Word prefix, Word suffix, SuffixValuation valuation, Constants consts) { + + if (!useOptimization) + return equivClasses; + + List> filtered = new ArrayList<>(); + + ParameterGenerator pgen = new ParameterGenerator(); + SuffixValueGenerator svgen = new SuffixValueGenerator(); + Mapping> mapping = new Mapping<>(); + for (PSymbolInstance psi : prefix) { + DataType[] dts = psi.getBaseSymbol().getPtypes(); + DataValue[] dvs = psi.getParameterValues(); + for (int i = 0; i < dvs.length; i++) { + Parameter p = pgen.next(dts[i]); + mapping.put(p, dvs[i]); + } + } + for (ParameterizedSymbol ps : suffix) { + DataType[] dts = ps.getPtypes(); + for (int i = 0; i < dts.length; i++) { + SuffixValue sv = svgen.next(dts[i]); + DataValue val = valuation.get(sv); + if (val != null) + mapping.put(sv, val); + } + } + + GuardExpression expr = restr.toGuardExpression(mapping.keySet()); + for (DataValue ec : equivClasses) { + Mapping> ecMapping = new Mapping>(); + ecMapping.putAll(mapping); + ecMapping.putAll(consts); + ecMapping.put(restr.getParameter(), ec); + if (expr.isSatisfied(ecMapping)) { + filtered.add(ec); + } + } + return filtered; + } +} diff --git a/src/main/java/de/learnlib/ralib/theory/FreshSuffixValue.java b/src/main/java/de/learnlib/ralib/theory/FreshSuffixValue.java new file mode 100644 index 00000000..2aa8fc5b --- /dev/null +++ b/src/main/java/de/learnlib/ralib/theory/FreshSuffixValue.java @@ -0,0 +1,58 @@ +package de.learnlib.ralib.theory; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import de.learnlib.ralib.automata.guards.AtomicGuardExpression; +import de.learnlib.ralib.automata.guards.Conjunction; +import de.learnlib.ralib.automata.guards.GuardExpression; +import de.learnlib.ralib.automata.guards.Relation; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; + +public class FreshSuffixValue extends SuffixValueRestriction { + public FreshSuffixValue(SuffixValue param) { + super(param); + } + + public FreshSuffixValue(FreshSuffixValue other, int shift) { + super(other, shift); + } + + @Override + public GuardExpression toGuardExpression(Set vals) { + List expr = new ArrayList<>(); + for (SymbolicDataValue sdv : vals) { + GuardExpression g = new AtomicGuardExpression(parameter, Relation.NOT_EQUALS, sdv); + expr.add(g); + } + GuardExpression[] exprArr = new GuardExpression[expr.size()]; + expr.toArray(exprArr); + return new Conjunction(exprArr); + } + + @Override + public SuffixValueRestriction shift(int shiftStep) { + return new FreshSuffixValue(this, shiftStep); + } + + @Override + public SuffixValueRestriction merge(SuffixValueRestriction other, Map prior) { + if (other instanceof FreshSuffixValue) { + return this; + } + return other.merge(this, prior); + } + + @Override + public String toString() { + return "Fresh(" + parameter.toString() + ")"; + } + + @Override + public boolean revealsRegister(SymbolicDataValue r) { + return false; + } +} diff --git a/src/main/java/de/learnlib/ralib/theory/SDTAndGuard.java b/src/main/java/de/learnlib/ralib/theory/SDTAndGuard.java index cc32f9f1..4cabd09b 100644 --- a/src/main/java/de/learnlib/ralib/theory/SDTAndGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/SDTAndGuard.java @@ -19,7 +19,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Objects; -import java.util.Set; import de.learnlib.ralib.automata.guards.Conjunction; import de.learnlib.ralib.automata.guards.GuardExpression; @@ -99,11 +98,6 @@ public SDTGuard relabel(VarMapping relabelling) { return new SDTAndGuard(sv, gg.toArray(new SDTIfGuard[]{})); } - @Override - public Set mergeWith(SDTGuard other, List regPotential) { - throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. - } - @Override public SDTAndGuard copy() { return new SDTAndGuard(this); diff --git a/src/main/java/de/learnlib/ralib/theory/SDTGuard.java b/src/main/java/de/learnlib/ralib/theory/SDTGuard.java index 5647beae..d5c7a830 100644 --- a/src/main/java/de/learnlib/ralib/theory/SDTGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/SDTGuard.java @@ -41,9 +41,7 @@ public SuffixValue getParameter() { } public SDTGuard(SuffixValue param) { - - this.parameter = param; - + parameter = param; } public abstract Set getComparands(SymbolicDataValue dv); @@ -60,86 +58,5 @@ public TransitionGuard toTG() { public abstract SDTGuard relabel(VarMapping relabelling); - public abstract Set mergeWith(SDTGuard other, List regPotential); - public abstract SDTGuard copy(); - -// private Set mergeIfWith(SDTIfGuard thisIf, SDTIfGuard otherIf) { -// Set ifGuard = new LinkedHashSet<>(); -// ifGuard.add(otherIf); -// return mergeIfWith(thisIf, ifGuard); -// } -// -// private Set mergeIfWith(SDTIfGuard thisIf, Set otherOr) { -//// System.out.println("mergeIfWith Set: thisIf " + thisIf + ", otherOr " + otherOr); -// Set otherGuards = new LinkedHashSet<>(); -// otherGuards.addAll(otherOr); -// if (otherGuards.contains(thisIf.toDeqGuard())) { -//// System.out.println("contradiction"); -// otherGuards.remove(thisIf.toDeqGuard()); -// // disequality + equality = true -// if (!((thisIf instanceof EqualityGuard) || thisIf instanceof DisequalityGuard)) { -//// System.out.println("neither is eq or deq"); -// otherGuards.add(new DisequalityGuard( -// thisIf.getParameter(), thisIf.getRegister())); -// } -// } else { -// otherGuards.add(thisIf); -// } -//// System.out.println("otherGuards " + otherGuards); -// return otherGuards; -// } -// -// private Set mergeIfWith(SDTIfGuard thisIf, SDTAndGuard otherAnd) { -// Set ifGuard = new LinkedHashSet<>(); -// ifGuard.add(thisIf); -// return mergeAndWith(otherAnd, ifGuard); -// } -// -//// private Set mergeAndWith(SDTAndGuard thisAnd, SDTAndGuard otherAnd) { -//// Set andGuard = new LinkedHashSet<>(); -//// andGuard.add(otherAnd); -//// return mergeAndWith(thisAnd, andGuard); -//// } -//// -//// private Set mergeAndWith(SDTAndGuard thisAnd, SDTIfGuard otherIf) { -//// return mergeIfWith(otherIf, thisAnd); -//// } -// private Set mergeAndWith(SDTAndGuard thisAnd, Set _merged) { -// //System.out.println(thisAnd + " merges with " + _merged); -// Set ifs = new LinkedHashSet<>(); -// List thisGuards = thisAnd.getGuards(); -// Set merged = new LinkedHashSet<>(); -// merged.addAll(_merged); -// for (SDTGuard x : thisGuards) { -// assert x instanceof SDTIfGuard; -// SDTIfGuard ifX = (SDTIfGuard) x; -// if (merged.contains(ifX.toDeqGuard())) { -// merged.remove(ifX.toDeqGuard()); -// if (!((ifX instanceof EqualityGuard) || ifX instanceof DisequalityGuard)) { -// merged.add(new DisequalityGuard(ifX.getParameter(), ifX.getRegister())); -// } -// } else { -// ifs.add(ifX); -// } -// } -// if (ifs.size() == 1) { -// merged.addAll(ifs); -// } else if (ifs.size() > 1) { -// merged.add(new SDTAndGuard(thisAnd.parameter, ifs.toArray(new SDTIfGuard[]{}))); -// -// } -// //System.out.println("result: " + merged); -// return merged; -// } - -// private Set mergeOrWith(SDTOrGuard thisOr, SDTIfGuard otherIf) { -// return mergeIfWith(otherIf, thisOr.guardSet); -// } -// -// private Set mergeOrWith(SDTOrGuard thisOr, SDTAndGuard otherAnd) { -// return mergeAndWith(otherAnd, thisOr.guardSet); -// } - //public abstract SDTGuard mergeWith(Set others); - } diff --git a/src/main/java/de/learnlib/ralib/theory/SDTIfGuard.java b/src/main/java/de/learnlib/ralib/theory/SDTIfGuard.java index caf9f067..b9253523 100644 --- a/src/main/java/de/learnlib/ralib/theory/SDTIfGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/SDTIfGuard.java @@ -65,6 +65,8 @@ public Set getComparands(SymbolicDataValue dv) { Set comparands = new LinkedHashSet<>(); if (this.parameter.equals(dv)) comparands.add(register); + else if (register.equals(dv)) + comparands.add(parameter); return comparands; } diff --git a/src/main/java/de/learnlib/ralib/theory/SDTOrGuard.java b/src/main/java/de/learnlib/ralib/theory/SDTOrGuard.java index d4afda86..88c2b6e5 100644 --- a/src/main/java/de/learnlib/ralib/theory/SDTOrGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/SDTOrGuard.java @@ -19,7 +19,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Objects; -import java.util.Set; import de.learnlib.ralib.automata.guards.Disjunction; import de.learnlib.ralib.automata.guards.GuardExpression; @@ -98,38 +97,8 @@ public SDTGuard relabel(VarMapping relabelling) { return new SDTOrGuard(sv, gg.toArray(new SDTGuard[]{})); } - @Override - public Set mergeWith(SDTGuard other, List regPotential) { - return other.mergeWith(this, regPotential); - } - @Override public SDTOrGuard copy() { return new SDTOrGuard(this); } - - //@Override - //public SDTGuard mergeWith(Set _merged) { - // return null; - //} -// Set merged = new LinkedHashSet<>(); -// merged.addAll(_merged); -// for (SDTGuard x : this.getGuards()) { -// if (x instanceof SDTIfGuard) { -// SDTGuard newGuard = x.mergeWith(merged); -// } -// } -// if (merged.isEmpty()) { -// return new SDTTrueGuard(this.parameter); -// } else { -// SDTGuard[] mergedArr = merged.toArray(new SDTGuard[]{}); -// if (mergedArr.length == 1) { -// return mergedArr[0]; -// } -// else { -// return new SDTOrGuard(this.parameter, mergedArr); -// } -// -// } -// } } diff --git a/src/main/java/de/learnlib/ralib/theory/SDTTrueGuard.java b/src/main/java/de/learnlib/ralib/theory/SDTTrueGuard.java index 10081df1..0940129c 100644 --- a/src/main/java/de/learnlib/ralib/theory/SDTTrueGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/SDTTrueGuard.java @@ -82,11 +82,6 @@ public int hashCode() { return hash; } - @Override - public Set mergeWith(SDTGuard other, List regPotential) { - throw new IllegalStateException("trying to merge true guard"); - } - @Override public Set getComparands(SymbolicDataValue dv) { return new LinkedHashSet<>(); @@ -96,11 +91,4 @@ public Set getComparands(SymbolicDataValue dv) { public SDTTrueGuard copy() { return new SDTTrueGuard(this); } - - -// @Override -// public SDTGuard mergeWith(Set _merged) { -// return new SDTOrGuard(this.parameter, _merged.toArray(new SDTGuard[]{})); -// -// } } diff --git a/src/main/java/de/learnlib/ralib/theory/SuffixValueRestriction.java b/src/main/java/de/learnlib/ralib/theory/SuffixValueRestriction.java new file mode 100644 index 00000000..8c0cc2ce --- /dev/null +++ b/src/main/java/de/learnlib/ralib/theory/SuffixValueRestriction.java @@ -0,0 +1,145 @@ +package de.learnlib.ralib.theory; + +import java.util.Map; +import java.util.Objects; +import java.util.Set; + +import de.learnlib.ralib.automata.guards.GuardExpression; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.theory.equality.DisequalityGuard; +import de.learnlib.ralib.theory.equality.EqualRestriction; +import de.learnlib.ralib.theory.equality.EqualityGuard; +import de.learnlib.ralib.words.DataWords; +import de.learnlib.ralib.words.PSymbolInstance; +import net.automatalib.word.Word; + +public abstract class SuffixValueRestriction { + protected final SuffixValue parameter; + + public SuffixValueRestriction(SuffixValue parameter) { + this.parameter = parameter; + } + + public SuffixValueRestriction(SuffixValueRestriction other) { + parameter = new SuffixValue(other.parameter.getType(), other.parameter.getId()); + } + + public SuffixValueRestriction(SuffixValueRestriction other, int shift) { + parameter = new SuffixValue(other.parameter.getType(), other.parameter.getId()+shift); + } + + public SuffixValue getParameter() { + return parameter; + } + + public abstract SuffixValueRestriction shift(int shiftStep); + + public abstract GuardExpression toGuardExpression(Set vals); + + public abstract SuffixValueRestriction merge(SuffixValueRestriction other, Map prior); + + public abstract boolean revealsRegister(SymbolicDataValue r); + + /** + * Generate a generic restriction using Fresh, Unrestricted and Equal restriction types + * + * @param sv + * @param prefix + * @param suffix + * @param consts + * @return + */ + public static SuffixValueRestriction genericRestriction(SuffixValue sv, Word prefix, Word suffix, Constants consts) { + DataValue[] prefixVals = DataWords.valsOf(prefix); + DataValue[] suffixVals = DataWords.valsOf(suffix); + DataType[] prefixTypes = DataWords.typesOf(DataWords.actsOf(prefix)); + DataType[] suffixTypes = DataWords.typesOf(DataWords.actsOf(suffix)); + DataValue val = suffixVals[sv.getId()-1]; + int arityFirst = suffix.length() > 0 ? suffix.getSymbol(0).getBaseSymbol().getArity() : 0; + + boolean unrestricted = false; + for (int i = 0; i < prefixVals.length; i++) { + DataValue dv = prefixVals[i]; + DataType dt = prefixTypes[i]; + if (dt.equals(sv.getType()) && dv.equals(val)) + unrestricted = true; + } + if (consts.containsValue(val)) { + unrestricted = true; + } + boolean equalsSuffixValue = false; + int equalSV = -1; + for (int i = 0; i < sv.getId()-1 && !equalsSuffixValue; i++) { + DataType dt = suffixTypes[i]; + if (dt.equals(sv.getType()) && suffixVals[i].equals(val)) { + if (sv.getId() <= arityFirst) { + unrestricted = true; + } else { + equalsSuffixValue = true; + equalSV = i; + } + } + } + + // case equal to previous suffix value + if (equalsSuffixValue && !unrestricted) { + SuffixValueRestriction restr = new EqualRestriction(sv, new SuffixValue(suffixVals[equalSV].getType(), equalSV+1)); + return restr; + } + // case fresh + else if (!equalsSuffixValue && !unrestricted) { + return new FreshSuffixValue(sv); + } + // case unrestricted + else { + return new UnrestrictedSuffixValue(sv); + } + } + + @Override + public int hashCode() { + return Objects.hash(parameter); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + SuffixValueRestriction other = (SuffixValueRestriction) obj; + return Objects.equals(parameter, other.parameter); + } + + public static SuffixValueRestriction genericRestriction(SDTGuard guard, Map prior) { + SuffixValue suffixValue = guard.getParameter(); + // case fresh + if (guard instanceof SDTTrueGuard || guard instanceof DisequalityGuard) { + return new FreshSuffixValue(suffixValue); + // case equal to previous suffix value + } else if (guard instanceof EqualityGuard) { + SymbolicDataValue param = ((EqualityGuard) guard).getRegister(); + if (param instanceof SuffixValue) { + SuffixValueRestriction restr = prior.get(param); + if (restr instanceof FreshSuffixValue) { + return new EqualRestriction(suffixValue, (SuffixValue)param); + } else if (restr instanceof EqualRestriction) { + return new EqualRestriction(suffixValue, ((EqualRestriction)restr).getEqualParameter()); + } else { + return new UnrestrictedSuffixValue(suffixValue); + } + } else { + return new UnrestrictedSuffixValue(suffixValue); + } + // case unrestricted + } else { + return new UnrestrictedSuffixValue(suffixValue); + } + } +} diff --git a/src/main/java/de/learnlib/ralib/theory/Theory.java b/src/main/java/de/learnlib/ralib/theory/Theory.java index 4f9e0dff..e78ad835 100644 --- a/src/main/java/de/learnlib/ralib/theory/Theory.java +++ b/src/main/java/de/learnlib/ralib/theory/Theory.java @@ -18,6 +18,7 @@ import java.util.Collection; import java.util.List; +import java.util.Map; import java.util.Set; import de.learnlib.ralib.data.Constants; @@ -26,6 +27,7 @@ import de.learnlib.ralib.data.ParValuation; import de.learnlib.ralib.data.SuffixValuation; import de.learnlib.ralib.data.SymbolicDataValue.Parameter; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.data.WordValuation; import de.learnlib.ralib.learning.SymbolicSuffix; import de.learnlib.ralib.oracles.mto.SDT; @@ -106,4 +108,10 @@ public DataValue instantiate(Word prefix, Constants constants, SDTGuard guard, Parameter param, Set> oldDvs); + public SuffixValueRestriction restrictSuffixValue(SuffixValue suffixValue, Word prefix, Word suffix, Constants consts); + + public SuffixValueRestriction restrictSuffixValue(SDTGuard guard, Map prior); + +// public boolean guardRevealsRegister(SDTGuard guard, SymbolicDataValue registers); + } diff --git a/src/main/java/de/learnlib/ralib/theory/UnrestrictedSuffixValue.java b/src/main/java/de/learnlib/ralib/theory/UnrestrictedSuffixValue.java new file mode 100644 index 00000000..9d6a6a42 --- /dev/null +++ b/src/main/java/de/learnlib/ralib/theory/UnrestrictedSuffixValue.java @@ -0,0 +1,45 @@ +package de.learnlib.ralib.theory; + +import java.util.Map; +import java.util.Set; + +import de.learnlib.ralib.automata.guards.GuardExpression; +import de.learnlib.ralib.automata.guards.TrueGuardExpression; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; + +public class UnrestrictedSuffixValue extends SuffixValueRestriction { + + public UnrestrictedSuffixValue(SuffixValue parameter) { + super(parameter); + } + + public UnrestrictedSuffixValue(UnrestrictedSuffixValue other, int shift) { + super(other, shift); + } + + @Override + public GuardExpression toGuardExpression(Set vals) { + return new TrueGuardExpression(); + } + + @Override + public SuffixValueRestriction shift(int shiftStep) { + return new UnrestrictedSuffixValue(this, shiftStep); + } + + @Override + public String toString() { + return "Unrestricted(" + parameter.toString() + ")"; + } + + @Override + public SuffixValueRestriction merge(SuffixValueRestriction other, Map prior) { + return this; + } + + @Override + public boolean revealsRegister(SymbolicDataValue r) { + return true; + } +} diff --git a/src/main/java/de/learnlib/ralib/theory/equality/DisequalityGuard.java b/src/main/java/de/learnlib/ralib/theory/equality/DisequalityGuard.java index 27c4ab2e..36570169 100644 --- a/src/main/java/de/learnlib/ralib/theory/equality/DisequalityGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/equality/DisequalityGuard.java @@ -16,15 +16,13 @@ */ package de.learnlib.ralib.theory.equality; -import java.util.LinkedHashSet; -import java.util.List; import java.util.Objects; -import java.util.Set; import de.learnlib.ralib.automata.guards.AtomicGuardExpression; import de.learnlib.ralib.automata.guards.GuardExpression; import de.learnlib.ralib.automata.guards.Relation; import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.data.VarMapping; import de.learnlib.ralib.theory.SDTGuard; import de.learnlib.ralib.theory.SDTIfGuard; @@ -58,7 +56,7 @@ public String toString() { @Override public GuardExpression toExpr() { - return new AtomicGuardExpression( + return new AtomicGuardExpression( register, Relation.NOT_EQUALS, parameter); } @@ -107,31 +105,8 @@ public boolean equals(Object obj) { return Objects.equals(this.parameter, other.parameter); } - @Override - public Set mergeWith(SDTGuard other, List regPotential) { - Set guards = new LinkedHashSet<>(); - if (other instanceof EqualityGuard) { - if (!(other.equals(this.toDeqGuard()))) { - guards.add(this); - guards.add(other); - } - } - else if (other instanceof DisequalityGuard) { - guards.add(this); - guards.add(other); - } - else { -// System.out.println("attempt to merge " + this + " with " + other); - guards.addAll(other.mergeWith(this, regPotential)); - - } - return guards; - } - @Override public SDTGuard copy() { return new DisequalityGuard(this); } - - } diff --git a/src/main/java/de/learnlib/ralib/theory/equality/EqualRestriction.java b/src/main/java/de/learnlib/ralib/theory/equality/EqualRestriction.java new file mode 100644 index 00000000..27b783e1 --- /dev/null +++ b/src/main/java/de/learnlib/ralib/theory/equality/EqualRestriction.java @@ -0,0 +1,90 @@ +package de.learnlib.ralib.theory.equality; + +import java.util.Map; +import java.util.Objects; +import java.util.Set; + +import de.learnlib.ralib.automata.guards.AtomicGuardExpression; +import de.learnlib.ralib.automata.guards.GuardExpression; +import de.learnlib.ralib.automata.guards.Relation; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.theory.FreshSuffixValue; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; + +public class EqualRestriction extends SuffixValueRestriction { + private final SuffixValue equalParam; + + public EqualRestriction(SuffixValue param, SuffixValue equalParam) { + super(param); + this.equalParam = equalParam; + } + + public EqualRestriction(EqualRestriction other) { + super(other); + equalParam = new SuffixValue(other.equalParam.getType(), other.equalParam.getId()); + } + + public EqualRestriction(EqualRestriction other, int shift) { + super(other, shift); + equalParam = new SuffixValue(other.equalParam.getType(), other.equalParam.getId()+shift); + } + + @Override + public GuardExpression toGuardExpression(Set vals) { + assert vals.contains(equalParam); + + return new AtomicGuardExpression(parameter, Relation.EQUALS, equalParam); + } + + @Override + public SuffixValueRestriction shift(int shiftStep) { + return new EqualRestriction(this, shiftStep); + } + + @Override + public SuffixValueRestriction merge(SuffixValueRestriction other, Map prior) { + assert other.getParameter().equals(parameter); + if (prior.get(equalParam) instanceof FreshSuffixValue) { + if (other instanceof EqualRestriction && + ((EqualRestriction) other).equalParam.equals(equalParam)) { + // equality only if the same equality and that parameter is fresh + return this; + } + if (other instanceof FreshSuffixValue) { + // choose equality over fresh + return this; + } + } + return new UnrestrictedSuffixValue(parameter); + } + + @Override + public String toString() { + return "(" + parameter.toString() + "=" + equalParam.toString() + ")"; + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof EqualRestriction)) + return false; + EqualRestriction other = (EqualRestriction)obj; + return super.equals(obj) && equalParam.equals(other.equalParam); + } + + @Override + public int hashCode() { + int hash = super.hashCode(); + return 89 * hash + Objects.hash(equalParam); + } + + public SuffixValue getEqualParameter() { + return equalParam; + } + + @Override + public boolean revealsRegister(SymbolicDataValue r) { + return equalParam.equals(r); + } +} diff --git a/src/main/java/de/learnlib/ralib/theory/equality/EqualityGuard.java b/src/main/java/de/learnlib/ralib/theory/equality/EqualityGuard.java index 44294ada..39fd5c3a 100644 --- a/src/main/java/de/learnlib/ralib/theory/equality/EqualityGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/equality/EqualityGuard.java @@ -16,10 +16,7 @@ */ package de.learnlib.ralib.theory.equality; -import java.util.LinkedHashSet; -import java.util.List; import java.util.Objects; -import java.util.Set; import de.learnlib.ralib.automata.guards.AtomicGuardExpression; import de.learnlib.ralib.automata.guards.GuardExpression; @@ -27,9 +24,7 @@ import de.learnlib.ralib.data.SymbolicDataValue; import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.data.VarMapping; -import de.learnlib.ralib.theory.SDTGuard; import de.learnlib.ralib.theory.SDTIfGuard; -import de.learnlib.ralib.theory.SDTOrGuard; /** * @@ -108,31 +103,6 @@ public GuardExpression toExpr() { Relation.EQUALS, parameter); } - @Override - public Set mergeWith(SDTGuard other, List regPotential) { - Set guards = new LinkedHashSet<>(); - if (other instanceof DisequalityGuard) { - if (!(other.equals(this.toDeqGuard()))) { - guards.add(this); - guards.add(other); - } - } else if (other instanceof EqualityGuard) { - if (!(this.equals(other))) { - guards.add(other); - } - guards.add(this); - } else if (other instanceof SDTOrGuard) { - for (SDTGuard s : ((SDTOrGuard)other).getGuards()) { - guards.addAll(this.mergeWith(s, regPotential)); - } - }else { - //System.out.println("attempt to merge " + this + " with " + other); - guards.addAll(other.mergeWith(this, regPotential)); - - } - return guards; - } - @Override public EqualityGuard copy() { return new EqualityGuard(this); diff --git a/src/main/java/de/learnlib/ralib/theory/equality/EqualityTheory.java b/src/main/java/de/learnlib/ralib/theory/equality/EqualityTheory.java index 2ee781a4..9d5c05a7 100644 --- a/src/main/java/de/learnlib/ralib/theory/equality/EqualityTheory.java +++ b/src/main/java/de/learnlib/ralib/theory/equality/EqualityTheory.java @@ -21,6 +21,7 @@ import java.util.Collection; import java.util.Collections; import java.util.Deque; +import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; @@ -48,10 +49,12 @@ import de.learnlib.ralib.oracles.mto.SDT; import de.learnlib.ralib.oracles.mto.SDTConstructor; import de.learnlib.ralib.oracles.mto.SDTLeaf; +import de.learnlib.ralib.theory.EquivalenceClassFilter; import de.learnlib.ralib.theory.SDTAndGuard; import de.learnlib.ralib.theory.SDTGuard; import de.learnlib.ralib.theory.SDTIfGuard; import de.learnlib.ralib.theory.SDTTrueGuard; +import de.learnlib.ralib.theory.SuffixValueRestriction; import de.learnlib.ralib.theory.Theory; import de.learnlib.ralib.words.DataWords; import de.learnlib.ralib.words.OutputSymbol; @@ -157,10 +160,8 @@ public SDT treeQuery(Word prefix, SymbolicSuffix suffix, WordVa int pId = values.size() + 1; - SuffixValue sv = suffix.getDataValue(pId); - DataType type = sv.getType(); - - SuffixValue currentParam = new SuffixValue(type, pId); + SuffixValue currentParam = suffix.getSuffixValue(pId); + DataType type = currentParam.getType(); Map tempKids = new LinkedHashMap<>(); @@ -170,49 +171,15 @@ public SDT treeQuery(Word prefix, SymbolicSuffix suffix, WordVa List> potList = new ArrayList<>(potSet); List> potential = getPotential(potList); - boolean free = suffix.getFreeValues().contains(sv); - if (!free && useNonFreeOptimization) { - DataValue d = suffixValues.get(sv); - SDT sdt; - Map merged; - - // fresh value case - if (d == null) { - d = getFreshValue(potential); - values.put(pId, d); - WordValuation trueValues = new WordValuation(); - trueValues.putAll(values); - SuffixValuation trueSuffixValues = new SuffixValuation(); - trueSuffixValues.putAll(suffixValues); - trueSuffixValues.put(sv, d); - sdt = oracle.treeQuery(prefix, suffix, trueValues, pir, constants, trueSuffixValues); - LOGGER.trace(" single deq SDT : " + sdt.toString()); - merged = mergeGuards(tempKids, new SDTAndGuard(currentParam), sdt); - - } - - // equal to previous suffix parameter - else { - values.put(pId, d); - WordValuation equalValues = new WordValuation(); - equalValues.putAll(values); - SuffixValuation equalSuffixValues = new SuffixValuation(); - equalSuffixValues.putAll(suffixValues); - sdt = oracle.treeQuery(prefix, suffix, equalValues, pir, constants, equalSuffixValues); - merged = new LinkedHashMap(); - int smallest = Collections.min(values.getAllKeys(d)); - EqualityGuard guard = new EqualityGuard(currentParam, new SuffixValue(type, smallest)); - merged.put(guard, sdt); - } + DataValue fresh = getFreshValue(potential); - LOGGER.trace("temporary guards = " + tempKids.keySet()); - // LOGGER.trace("temporary pivs = " + tempPiv.keySet()); - LOGGER.trace("merged guards = " + merged.keySet()); - LOGGER.trace("merged pivs = " + pir.toString()); - - return new SDT(merged); - } + List> equivClasses = new ArrayList<>(potSet); + equivClasses.add(fresh); + EquivalenceClassFilter eqcFilter = new EquivalenceClassFilter(equivClasses, useNonFreeOptimization); + List> filteredEquivClasses = eqcFilter.toList(suffix.getRestriction(currentParam), prefix, suffix.getActions(), suffixValues, constants); + assert filteredEquivClasses.size() > 0; + // TODO: integrate fresh-value optimization with restrictions // special case: fresh values in outputs if (freshValues) { @@ -235,7 +202,7 @@ public SDT treeQuery(Word prefix, SymbolicSuffix suffix, WordVa trueValues.putAll(values); SuffixValuation trueSuffixValues = new SuffixValuation(); trueSuffixValues.putAll(suffixValues); - trueSuffixValues.put(sv, d); + trueSuffixValues.put(currentParam, d); SDT sdt = oracle.treeQuery(prefix, suffix, trueValues, pir, constants, trueSuffixValues); LOGGER.trace(" single deq SDT : " + sdt.toString()); @@ -267,48 +234,61 @@ public SDT treeQuery(Word prefix, SymbolicSuffix suffix, WordVa LOGGER.trace("prefix list " + prefixValues.toString()); - DataValue fresh = getFreshValue(potential); - List diseqList = new ArrayList(); for (DataValue newDv : potential) { - LOGGER.trace(newDv.toString()); - - // this is the valuation of the suffixvalues in the suffix - SuffixValuation ifSuffixValues = new SuffixValuation(); - ifSuffixValues.putAll(suffixValues); // copy the suffix valuation - - EqualityGuard eqGuard = pickupDataValue(newDv, prefixValues, currentParam, values, constants); - LOGGER.trace("eqGuard is: " + eqGuard.toString()); - diseqList.add(new DisequalityGuard(currentParam, eqGuard.getRegister())); - // construct the equality guard - // find the data value in the prefix - // this is the valuation of the positions in the suffix - WordValuation ifValues = new WordValuation(); - ifValues.putAll(values); - ifValues.put(pId, newDv); - SDT eqOracleSdt = oracle.treeQuery(prefix, suffix, ifValues, pir, constants, ifSuffixValues); - - tempKids.put(eqGuard, eqOracleSdt); + if (filteredEquivClasses.contains(newDv)) { + LOGGER.trace(newDv.toString()); + + // this is the valuation of the suffixvalues in the suffix + SuffixValuation ifSuffixValues = new SuffixValuation(); + ifSuffixValues.putAll(suffixValues); // copy the suffix valuation + + EqualityGuard eqGuard = pickupDataValue(newDv, prefixValues, currentParam, values, constants); + LOGGER.trace("eqGuard is: " + eqGuard.toString()); + diseqList.add(new DisequalityGuard(currentParam, eqGuard.getRegister())); + // construct the equality guard + // find the data value in the prefix + // this is the valuation of the positions in the suffix + WordValuation ifValues = new WordValuation(); + ifValues.putAll(values); + ifValues.put(pId, newDv); + SDT eqOracleSdt = oracle.treeQuery(prefix, suffix, ifValues, pir, constants, ifSuffixValues); + + tempKids.put(eqGuard, eqOracleSdt); + } } + Map merged; + // process the 'else' case - // this is the valuation of the positions in the suffix - WordValuation elseValues = new WordValuation(); - elseValues.putAll(values); - elseValues.put(pId, fresh); + if (filteredEquivClasses.contains(fresh)) { + // this is the valuation of the positions in the suffix + WordValuation elseValues = new WordValuation(); + elseValues.putAll(values); + elseValues.put(pId, fresh); - // this is the valuation of the suffixvalues in the suffix - SuffixValuation elseSuffixValues = new SuffixValuation(); - elseSuffixValues.putAll(suffixValues); - elseSuffixValues.put(sv, fresh); + // this is the valuation of the suffixvalues in the suffix + SuffixValuation elseSuffixValues = new SuffixValuation(); + elseSuffixValues.putAll(suffixValues); + elseSuffixValues.put(currentParam, fresh); - SDT elseOracleSdt = oracle.treeQuery(prefix, suffix, elseValues, pir, constants, elseSuffixValues); + SDT elseOracleSdt = oracle.treeQuery(prefix, suffix, elseValues, pir, constants, elseSuffixValues); - SDTAndGuard deqGuard = new SDTAndGuard(currentParam, (diseqList.toArray(new DisequalityGuard[] {}))); - LOGGER.trace("diseq guard = " + deqGuard.toString()); + SDTAndGuard deqGuard = new SDTAndGuard(currentParam, (diseqList.toArray(new DisequalityGuard[] {}))); + LOGGER.trace("diseq guard = " + deqGuard.toString()); - // merge the guards - Map merged = mergeGuards(tempKids, deqGuard, elseOracleSdt); + // merge the guards + merged = mergeGuards(tempKids, deqGuard, elseOracleSdt); + } else { + // if no else case, we can only have a true guard + // TODO: add support for multiple equalities with same outcome + assert tempKids.size() == 1; + + Iterator> it = tempKids.entrySet().iterator(); + Map.Entry e = it.next(); + merged = new LinkedHashMap(); + merged.put(e.getKey(), e.getValue()); + } // only keep registers that are referenced by the merged guards pir.putAll(keepMem(merged)); @@ -464,4 +444,15 @@ private SDT makeRejectingBranch(int nextSufIndex, int maxIndex, DataType type) { } } + @Override + public SuffixValueRestriction restrictSuffixValue(SuffixValue suffixValue, Word prefix, Word suffix, Constants consts) { + // for now, use generic restrictions with equality theory + return SuffixValueRestriction.genericRestriction(suffixValue, prefix, suffix, consts); + } + + @Override + public SuffixValueRestriction restrictSuffixValue(SDTGuard guard, Map prior) { + // for now, use generic restrictions with equality theory + return SuffixValueRestriction.genericRestriction(guard, prior); + } } diff --git a/src/main/java/de/learnlib/ralib/theory/inequality/GreaterSuffixValue.java b/src/main/java/de/learnlib/ralib/theory/inequality/GreaterSuffixValue.java new file mode 100644 index 00000000..3fa77ce0 --- /dev/null +++ b/src/main/java/de/learnlib/ralib/theory/inequality/GreaterSuffixValue.java @@ -0,0 +1,66 @@ +package de.learnlib.ralib.theory.inequality; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import de.learnlib.ralib.automata.guards.AtomicGuardExpression; +import de.learnlib.ralib.automata.guards.Conjunction; +import de.learnlib.ralib.automata.guards.GuardExpression; +import de.learnlib.ralib.automata.guards.Relation; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.theory.FreshSuffixValue; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; +import de.learnlib.ralib.theory.equality.EqualRestriction; + +public class GreaterSuffixValue extends SuffixValueRestriction { + + public GreaterSuffixValue(SuffixValue param) { + super(param); + } + + public GreaterSuffixValue(GreaterSuffixValue other, int shift) { + super(other, shift); + } + + @Override + public SuffixValueRestriction shift(int shiftStep) { + return new GreaterSuffixValue(this, shiftStep); + } + + @Override + public GuardExpression toGuardExpression(Set vals) { + List expr = new ArrayList<>(); + for (SymbolicDataValue sdv : vals) { + GuardExpression g = new AtomicGuardExpression(parameter, Relation.BIGGER, sdv); + expr.add(g); + } + GuardExpression expArr[] = new GuardExpression[expr.size()]; + expArr = expr.toArray(expArr); + return new Conjunction(expArr); + } + + @Override + public SuffixValueRestriction merge(SuffixValueRestriction other, Map prior) { + if (other instanceof GreaterSuffixValue || other instanceof FreshSuffixValue) { + return this; + } + if (other instanceof LesserSuffixValue || other instanceof EqualRestriction) { + return new UnrestrictedSuffixValue(parameter); + } + return other.merge(other, prior); + } + + @Override + public boolean revealsRegister(SymbolicDataValue r) { + return false; + } + + @Override + public String toString() { + return "Greater(" + parameter.toString() + ")"; + } +} diff --git a/src/main/java/de/learnlib/ralib/theory/inequality/InequalityTheoryWithEq.java b/src/main/java/de/learnlib/ralib/theory/inequality/InequalityTheoryWithEq.java index 0581aec5..abc5bdd3 100644 --- a/src/main/java/de/learnlib/ralib/theory/inequality/InequalityTheoryWithEq.java +++ b/src/main/java/de/learnlib/ralib/theory/inequality/InequalityTheoryWithEq.java @@ -22,10 +22,12 @@ import java.util.Arrays; import java.util.Collection; import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; import java.util.LinkedHashMap; -import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import de.learnlib.ralib.data.Constants; @@ -35,20 +37,26 @@ import de.learnlib.ralib.data.ParValuation; import de.learnlib.ralib.data.SuffixValuation; import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.Constant; import de.learnlib.ralib.data.SymbolicDataValue.Parameter; import de.learnlib.ralib.data.SymbolicDataValue.Register; import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.VarMapping; import de.learnlib.ralib.data.WordValuation; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.RegisterGenerator; import de.learnlib.ralib.learning.SymbolicSuffix; import de.learnlib.ralib.oracles.mto.SDT; import de.learnlib.ralib.oracles.mto.SDTConstructor; -import de.learnlib.ralib.oracles.mto.SDTLeaf; +import de.learnlib.ralib.theory.EquivalenceClassFilter; +import de.learnlib.ralib.theory.FreshSuffixValue; import de.learnlib.ralib.theory.SDTAndGuard; import de.learnlib.ralib.theory.SDTGuard; import de.learnlib.ralib.theory.SDTIfGuard; import de.learnlib.ralib.theory.SDTOrGuard; import de.learnlib.ralib.theory.SDTTrueGuard; +import de.learnlib.ralib.theory.SuffixValueRestriction; import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; import de.learnlib.ralib.theory.equality.DisequalityGuard; import de.learnlib.ralib.theory.equality.EqualityGuard; import de.learnlib.ralib.words.DataWords; @@ -60,758 +68,269 @@ /** * * @author Sofia Cassel + * @author Fredrik Tåquist * @param */ public abstract class InequalityTheoryWithEq implements Theory { -// private static final LearnLogger LOGGER -// = LearnLogger.getLogger(InequalityTheoryWithEq.class); - -// private Set setify(SDTGuard... gs) { -// Set guardSet = new LinkedHashSet<>(); -// for (SDTGuard g : gs) { -// // if g is an or guard -// if (g instanceof SDTOrGuard) { -// SDTOrGuard cg = (SDTOrGuard) g; -// for (SDTGuard x : cg.getGuards()) { -// if (x instanceof SDTIfGuard) { -// SDTIfGuard ifX = (SDTIfGuard) x; -// // remove contradicting guards -// if (guardSet.contains(ifX.toDeqGuard())) { -// guardSet.remove(ifX.toDeqGuard()); -// } else { -// guardSet.add(x); -// } -// } -// else { -// guardSet.add(x); -// } -// } -// } else if (g instanceof SDTIfGuard) { -// SDTIfGuard x = (SDTIfGuard) g; -// // if guardset already contains the contradicting guard, remove it -// if (guardSet.contains(x.toDeqGuard())) { -// guardSet.remove(x.toDeqGuard()); -// // if g is a Bigger or Smaller guard, merge into disequality guard -// if (!(g instanceof EqualityGuard)) { -// guardSet.add(new DisequalityGuard( -// x.getParameter(), x.getRegister())); -// } -// } else { -// guardSet.add(x); -// } -// } else if (g instanceof SDTAndGuard) { -// SDTAndGuard ag = (SDTAndGuard) g; -// List ifs = new ArrayList(); -// for (SDTIfGuard x : ag.getGuards()) { -// if (guardSet.contains(x.toDeqGuard())) { -// guardSet.remove(x.toDeqGuard()); -// if (!(g instanceof EqualityGuard)) { -// guardSet.add(new DisequalityGuard( -// x.getParameter(), x.getRegister())); -// } -// } else { -// ifs.add(x); -// } -// } -// if (ifs.size() == 1) { -// guardSet.add(ifs.get(0)); -// } else if (ifs.size() > 1) { -// guardSet.add(new SDTAndGuard(g.getParameter(), -// ifs.toArray(new SDTIfGuard[]{}))); -// } -// -// } -// } -// return guardSet; -// } -// private SDTGuard mergeGuardLists(SDTGuard g1, SDTGuard g2) { -// Set guardSet = (setify(g1, g2)); -// if (guardSet.isEmpty()) { -// return new SDTTrueGuard(g1.getParameter()); -// } else { -// SDTIfGuard[] guardArray = guardSet.toArray(new SDTIfGuard[]{}); -// if (guardArray.length == 1) { -// return guardArray[0]; -// } else { -// return new SDTOrGuard(g1.getParameter(), -// guardSet.toArray(new SDTIfGuard[]{})); -// } -// } -// } -// private List preprocess(List guardList) { -// for (SDTGuard g : guardList) { -// -// } -// } - private void addAllSafely(Collection guards, Collection toAdd, List regPotential) { -// System.out.println("adding " + toAdd + " to " + guards); - for (SDTGuard t : toAdd) { - if (t instanceof SDTOrGuard) { -// System.out.println("or guard"); - addAllSafely(guards, ((SDTOrGuard) t).getGuards(), regPotential); -// System.out.println(guards); - } else { - addSafely(guards, t, regPotential); - } - } - } - - private void addSafely(Collection guards, SDTGuard guard, List regPotential) { - boolean processed = false; - if (guard instanceof SDTIfGuard) { - SDTIfGuard oGuard = ((SDTIfGuard) guard).toDeqGuard(); -// System.out.println(guard + ": checking if guards contains " + oGuard); - if (guards.contains(oGuard)) { -// System.out.println("yes, removing " + oGuard); - guards.remove(oGuard); - processed = true; - } - } else if (guard instanceof IntervalGuard) { -// System.out.println("guard is intervalguard"); - IntervalGuard iGuard = (IntervalGuard) guard; - if (!iGuard.isIntervalGuard()) { - IntervalGuard flipped = iGuard.flip(); -// System.out.println("flipped: " + flipped); - if (guards.contains(flipped)) { - guards.remove(flipped); - addAllSafely(guards, iGuard.mergeWith(flipped, regPotential), regPotential); - processed = true; - } - } - } else if (guard instanceof SDTOrGuard) { -// System.out.println("found or guard"); - SDTOrGuard oGuard = (SDTOrGuard) guard; - addAllSafely(guards, oGuard.getGuards(), regPotential); - } - - if (processed == false) { - guards.add(guard); - } -// System.out.println("added safely: " + guard + " to " + guards); - } - - private void removeProhibited(Collection guards, Collection prohibited) { - for (SDTGuard p : prohibited) { - if (guards.contains(p)) { - guards.remove(p); - } - } - //System.out.println("guards after removing " + prohibited + " :: " + guards); - } - -// private Set mergeSetWithSet(Set guardSet, Set targets, Set prohibited) { -// System.out.println("set-merging " + targets + " with " + guardSet); -// Set newGuardSet = new LinkedHashSet<>(); -// for (SDTGuard s : targets) { -// newGuardSet = mergeOneWithSet(guardSet, s, new ArrayList(), prohibited); -// } -// return newGuardSet; -// } - private Set mergeOneWithSet(Set guardSet, SDTGuard target, List regPotential) { - List> inAndOut = new ArrayList>(); - inAndOut.add(guardSet); - inAndOut.add(new LinkedHashSet()); - return mergeOneWithSet(inAndOut, target, regPotential).get(0); - } - - private List> mergeOneWithSet(List> inAndOut, SDTGuard target, List regPotential) { - // merge target with the set guardSet - Set guardSet = inAndOut.get(0); - Set prohibited = inAndOut.get(1); - - Set newGuardSet = new LinkedHashSet(); - - List> newInAndOut = new ArrayList>(); - newInAndOut.addAll(inAndOut); - Boolean[] addedSomething = new Boolean[guardSet.size()]; - boolean processed = false; - newGuardSet.addAll(guardSet); -// System.out.println("target: " + target); - int i = -1; - if (!guardSet.isEmpty()) { - for (SDTGuard m : guardSet) { -// System.out.println("guards: " + newGuardSet + " target " + target); - i++; - addedSomething[i] = false; - // if target isn't in guardSet and isn't prohibited - if (!(guardSet.contains(target)) && !(prohibited.contains(target))) { - - assert !(target instanceof SDTOrGuard && m instanceof SDTOrGuard); - - if (target instanceof SDTIfGuard) { - // if it is an equality or disequality, remove the opposite by adding both to prohibited - SDTIfGuard oGuard = ((SDTIfGuard) target).toDeqGuard(); -// System.out.println(target + ": checking if guards contains " + oGuard); - if (guardSet.contains(oGuard)) { -// System.out.println("yes, removing " + oGuard); - prohibited.add(oGuard); - prohibited.add(target); - processed = true; - } - } else if (target instanceof IntervalGuard) { -// System.out.println(target + " is iGuard"); - // if it is an interval guard, check if the set contains flipped - IntervalGuard iGuard = (IntervalGuard) target; - if (!iGuard.isIntervalGuard()) { - IntervalGuard flipped = iGuard.flip(); -// System.out.println("flipped: " + flipped); -// System.out.println("guardSet " + guardSet + " " + guardSet.contains(flipped)); - if (guardSet.contains(flipped)) { - prohibited.add(flipped); - prohibited.add(target); - newInAndOut.add(0, newGuardSet); - newInAndOut.add(1, prohibited); - List> nextInAndOut = mergeOneWithSet(newInAndOut, iGuard.toDeqGuard(), regPotential); - newGuardSet = nextInAndOut.get(0); - prohibited = nextInAndOut.get(1);// - processed = true; - } - } - } - if (!processed) { - Set refSet = new LinkedHashSet<>(); - refSet.add(target); - refSet.add(m); - Set mWithTarget = target.mergeWith(m, regPotential); -// System.out.println("merging: " + target + " + " + m + " --> " + mWithTarget + ", " + refSet.containsAll(mWithTarget)); - if (!mWithTarget.contains(target)) { - prohibited.add(target); - } - if (!mWithTarget.contains(m)) { - prohibited.add(m); - } - addedSomething[i] = !(refSet.containsAll(mWithTarget)); -// System.out.println("g: " + guardSet); -// System.out.println("n: " + newGuardSet); - - if (addedSomething[i]) { // && !(newGuardSet.containsAll(mWithTarget))) { - for (SDTGuard x : mWithTarget) { -// List> newInAndOut = new ArrayList>(); -// System.out.println("XXX: for " + x + ": adding in: " + newGuardSet + " and out: " + prohibited); - newInAndOut.add(0, newGuardSet); - newInAndOut.add(1, prohibited); - List> nextInAndOut = mergeOneWithSet(newInAndOut, x, regPotential); - newGuardSet = nextInAndOut.get(0); - prohibited = nextInAndOut.get(1); -// System.out.println("XXX: after " + x + ": in: " + newGuardSet + " and out: " + prohibited); - } - } else { - newGuardSet.addAll(mWithTarget); - } - -// newGuardSet.addAll(mWithTarget); -// System.out.println("into: " + newGuardSet); - } - } - - } - - } - else { - newGuardSet.add(target); - - } - newInAndOut.add(0, newGuardSet); - newInAndOut.add(1, prohibited); -// Set temp = new LinkedHashSet<>(); -// Set prohibited = new LinkedHashSet<>(); -// System.out.println("temp is: " + temp + " and prohibited: " + prohibited); -// for (SDTGuard m : merged) { -// assert !(target instanceof SDTOrGuard && m instanceof SDTOrGuard); -// Set mWithTarget = target.mergeWith(m); -// System.out.println("merging: " + target + " + " + m + " --> " + mWithTarget); -// if (!mWithTarget.contains(target)) { -// prohibited.add(target); -// temp.remove(target); -// } -// if (!mWithTarget.contains(m)) { -// prohibited.add(m); -// temp.remove(target); -// } -// addAllSafely(temp, mWithTarget, prohibited); -// System.out.println("... but after adding " + mWithTarget + " safely: " + temp + " with " + prohibited); -// } -// System.out.println("return: " + temp); -// return temp; -// System.out.println("removing: " + prohibited); - removeProhibited(newGuardSet, prohibited); -// System.out.println("... and after removing :: " + newGuardSet); -// System.out.println("modified is " + Arrays.toString(addedSomething)); - if (hasTrue(addedSomething) && !(guardSet.equals(newGuardSet))) { -// System.out.println("try again"); - return mergeOneWithSet(newInAndOut, target, regPotential); - } else { - return newInAndOut; - } - } - -// private Set mergeOneWithSet(Set guardSet, SDTGuard target, List regPotential, Set prohibited) { -// -// //Set prohibited = new LinkedHashSet<>(); -// Set newGuardSet = new LinkedHashSet<>(); -// Boolean[] modified = new Boolean[guardSet.size()]; -// boolean processed = false; -// newGuardSet.addAll(guardSet); -// -// int i = -1; -// for (SDTGuard m : guardSet) { -// System.out.println("guards: " + newGuardSet); -// i++; -// modified[i] = false; -// if (!(guardSet.contains(target)) && !(prohibited.contains(target))) { -// -// assert !(target instanceof SDTOrGuard && m instanceof SDTOrGuard); -// -// if (target instanceof SDTIfGuard) { -// SDTIfGuard oGuard = ((SDTIfGuard) target).toDeqGuard(); -//// System.out.println(guard + ": checking if guards contains " + oGuard); -// if (guardSet.contains(oGuard)) { -//// System.out.println("yes, removing " + oGuard); -// prohibited.add(oGuard); -// prohibited.add(target); -// processed = true; -// } -// } else if (target instanceof IntervalGuard) { -// IntervalGuard iGuard = (IntervalGuard) target; -// if (!iGuard.isIntervalGuard()) { -// IntervalGuard flipped = iGuard.flip(); -// System.out.println("flipped: " + flipped); -// if (guardSet.contains(flipped)) { -// prohibited.add(flipped); -// prohibited.add(target); -// processed = true; -// } -// } -// } -// if (!processed) { -// Set refSet = new LinkedHashSet<>(); -// refSet.add(target); -// refSet.add(m); -// Set mWithTarget = target.mergeWith(m, regPotential); -// System.out.println("merging: " + target + " + " + m + " --> " + mWithTarget + ", " + refSet.equals(mWithTarget)); -// if (!mWithTarget.contains(target)) { -// prohibited.add(target); -// //modified[i] = true; -//// guardSet.remove(target); -// } -// if (!mWithTarget.contains(m)) { -// prohibited.add(m); -// //modified[i] = true; -//// guardSet.remove(target); -// } -// modified[i] = !(refSet.equals(mWithTarget)); -// System.out.println("g: " + guardSet); -// System.out.println("n: " + newGuardSet); -// -// -// if (modified[i] && !(newGuardSet.containsAll(mWithTarget))) { -// for (SDTGuard x : mWithTarget) { -// newGuardSet = mergeOneWithSet(newGuardSet, x, regPotential, prohibited); -// } -// } -// else { -// newGuardSet.addAll(mWithTarget); -// } -// -//// newGuardSet.addAll(mWithTarget); -// System.out.println("into: " + newGuardSet); -// } -// } -// } -//// Set temp = new LinkedHashSet<>(); -//// Set prohibited = new LinkedHashSet<>(); -//// System.out.println("temp is: " + temp + " and prohibited: " + prohibited); -//// for (SDTGuard m : merged) { -//// assert !(target instanceof SDTOrGuard && m instanceof SDTOrGuard); -//// Set mWithTarget = target.mergeWith(m); -//// System.out.println("merging: " + target + " + " + m + " --> " + mWithTarget); -//// if (!mWithTarget.contains(target)) { -//// prohibited.add(target); -//// temp.remove(target); -//// } -//// if (!mWithTarget.contains(m)) { -//// prohibited.add(m); -//// temp.remove(target); -//// } -//// addAllSafely(temp, mWithTarget, prohibited); -//// System.out.println("... but after adding " + mWithTarget + " safely: " + temp + " with " + prohibited); -//// } -//// System.out.println("return: " + temp); -//// return temp; -// System.out.println("removing: " + prohibited); -// removeProhibited(newGuardSet, prohibited); -// System.out.println("... and after removing :: " + newGuardSet); -// System.out.println("modified is " + Arrays.toString(modified)); -// if (hasTrue(modified) && !(guardSet.equals(newGuardSet))) { -// System.out.println("try again"); -// return mergeOneWithSet(newGuardSet, target, regPotential, prohibited); -// } else { -// return newGuardSet; -// } -// } - // Returns true if all elements of a boolean array are true. - private boolean hasTrue(Boolean[] maybeArr) { - boolean maybe = false; - for (int c = 0; c < (maybeArr.length); c++) { - //LOGGER.trace(maybeArr[c]); - if (maybeArr[c]) { - maybe = true; - break; - } - } - return maybe; - } - - private SDTGuard GuardSetFromList(Set merged, List remaining, SuffixValue currentParam, List regPotential) { -// merge list of guards with a set of guards. Initially, the set is empty and the list is full -// System.out.println("rem = " + remaining + ", merged = " + merged); - - //if the set is empty - // and the set is also empty: return true guard - // and the set is NOT empty: return either - //if the set is empty - if (remaining.isEmpty()) { -// if (merged.isEmpty()) { -// return new SDTTrueGuard(currentParam); -// } else { - SDTGuard[] guardArray = merged.toArray(new SDTGuard[]{}); - if ((merged.size() == 1)) { // || hasOnlyEqs(merged)) { - return guardArray[0]; - } else { - return new SDTOrGuard(currentParam, guardArray); - } - -// } - } - if (merged.isEmpty()) { - merged.add(remaining.remove(0)); - return GuardSetFromList(merged, remaining, currentParam, regPotential); - } - SDTGuard target = remaining.remove(0); - Set temp = mergeOneWithSet(merged, target, regPotential); - - return GuardSetFromList(temp, remaining, currentParam, regPotential); -// ensure that a new OrGuard is returned if there is nothing remaining - } - -// private Set getHeads(Set> listSets) { -// Set retSet = new LinkedHashSet<>(); -// for (List l : listSets) { -// retSet.add(l.get(0)); -// } -// return retSet; -// } -// private List getListFromHead(SDTGuard guard, Set> listSets) { -// Set heads = getHeads(listSets); -// if (heads.contains(guard)) { -// for (List l : listSets) { -// if (l.get(0).equals(guard)) { -// return l; -// } -// } -// } -// throw new IllegalStateException("not found"); -// } - private Map, SDT> modGuardLists(SDTGuard refGuard, SDT refSDT, Map, SDT> partitionedMap) { - boolean merged = false; - Map, SDT> newParMap = new LinkedHashMap<>(); -// System.out.println("modGuardLists for refGuard " + refGuard + ", refSDT " + refSDT + ", map: " + partitionedMap); - for (Map.Entry, SDT> par : partitionedMap.entrySet()) { -// merged = false; -// System.out.println("par: " + par); - List headList = par.getKey(); - List newHeadList = new ArrayList<>(); - newHeadList.addAll(headList); - //addAllSafely(newHeadList, headList, new LinkedHashSet()); - SDT headSDT = par.getValue(); - assert headSDT.getClass().equals(refSDT.getClass()); - //assert !(headSDT.isEmpty()); - //assert !(refSDT.isEmpty()); - //SDTGuard headGuard = headList.get(0); - SDT newSDT = headSDT; -// System.out.println("head: " + newHeadList + " against " + refGuard); - if (headSDT instanceof SDTLeaf) { -// System.out.println("sdt leaves"); - assert refSDT instanceof SDTLeaf; - if (headSDT.isAccepting() == refSDT.isAccepting() && !merged) { - merged = true; - newHeadList.add(refGuard); -// System.out.println("added ref " + refSDT + " eq to " + headSDT); - } - //newParMap.put(newHeadList, newSDT); - - } - if (refGuard instanceof IntervalGuard && !merged) { - IntervalGuard iRefGuard = (IntervalGuard) refGuard; - if (!iRefGuard.isIntervalGuard()) { - EqualityGuard eqGuard = iRefGuard.toEqGuard(); - if (newHeadList.contains(eqGuard)) { -// System.out.println("trying Deq " + refGuard + " against " + newHeadList + " with " + eqGuard); - SDT joinedSDT = getJoinedSDT(((IntervalGuard) refGuard).toEqGuard(), refSDT, headSDT); - if (joinedSDT != null) { -// System.out.println("can merge: " + refGuard + " with EQ" + headList); - newHeadList.add(refGuard); - newSDT = joinedSDT; - //newSDT = refSDT.relabelUnderEq((EqualityGuard) headGuard); - merged = true; - //newParMap.put(newHeadList, newSDT); - } - } - } else { - assert iRefGuard.isIntervalGuard(); - EqualityGuard eqG = null; - if (newHeadList.contains(new EqualityGuard(iRefGuard.getParameter(), iRefGuard.getLeftReg()))) { - eqG = new EqualityGuard(iRefGuard.getParameter(), iRefGuard.getLeftReg()); - } else if (newHeadList.contains(new EqualityGuard(iRefGuard.getParameter(), iRefGuard.getRightReg()))) { - eqG = new EqualityGuard(iRefGuard.getParameter(), iRefGuard.getLeftReg()); - } - if (eqG != null) { -// System.out.println("trying Eq " + refGuard + " against " + newHeadList + " with " + eqG); - SDT joinedSDT = getJoinedSDT(eqG, refSDT, headSDT); - if (joinedSDT != null) { -// System.out.println("can merge: EQ" + headList + " with " + refGuard); - newHeadList.add(refGuard); - newSDT = joinedSDT; - merged = true; - //newParMap.put(newHeadList, newSDT); - } - } - } - - } - if (refGuard instanceof EqualityGuard && !merged) { -// System.out.println("trying Eq " + refGuard + " against " + newHeadList); - SDT joinedSDT = getJoinedSDT((EqualityGuard) refGuard, headSDT, refSDT); - if (joinedSDT != null) { -// System.out.println("can merge: EQ" + refGuard + " with " + headList); - newHeadList.add(0, refGuard); - newSDT = joinedSDT; - merged = true; - //newParMap.put(newHeadList, newSDT); - } - } - if (refSDT.canUse(headSDT) && headSDT.canUse(refSDT) && !merged) { -// System.out.println("LAST RESORT: can use"); - newHeadList.add(refGuard); - merged = true; - //newParMap.put(newHeadList, newSDT); - } - - newParMap.put(newHeadList, newSDT); - - } - - if (!merged) { -// System.out.println(refGuard + " cannot merge with anything in " + partitionedMap); - List newUnmergedList = new ArrayList<>(); - newUnmergedList.add(refGuard); -// newParMap.putAll(partitionedMap); -// System.out.println("adding " + newUnmergedList + " ---> " + refSDT); - - newParMap.put(newUnmergedList, refSDT); -// System.out.println("newParMap is now " + newParMap); - } - - //newParMap.putAll(partitionedMap); - assert !newParMap.isEmpty(); - -// System.out.println("RETURNED: newParMap " + newParMap); - return newParMap; - } - - private Map, SDT> partitionGuards(Map refMap) { - -// System.out.println("partitioning " + refMap); - // start with an empty map - Map, SDT> parMap = new LinkedHashMap<>(); - for (Map.Entry ref : refMap.entrySet()) { - SDTGuard refGuard = ref.getKey(); - SDT refSDT = ref.getValue(); - -// if (refGuard instanceof SDTTrueGuard) { -// assert refMap.size() == 1; -// List trueList = new ArrayList(); -// trueList.add(refGuard); -// parMap = new LinkedHashMap, SDT>(); -// parMap.put(trueList, refSDT); -// return parMap; -// } -// System.out.println("pre par map = " + parMap); - parMap = modGuardLists(refGuard, refSDT, parMap); - // get the heads of all lists in the partitioned map - //System.out.println("partitioned map parMap: " + parMap); - - } -// System.out.println("partitioned map parMap: " + parMap); - - return parMap; - } - - // for each element in the map - // check if it can merge with the head of any of the lists in the set - // if yes, then add to that list - // if no, then start a new list -//} - private SDT getJoinedSDT(EqualityGuard guard, SDT deqSDT, SDT eqSDT) { - //boolean canJoin = false; - - EqualityGuard eqGuard = (EqualityGuard) guard; - List ds = new ArrayList(); - ds.add(eqGuard); -// System.out.println("checking if T" + deqSDT + " is eq to O" + eqSDT + " under " + eqGuard); - - SDT newTargetSDT = deqSDT.relabelUnderEq(ds); - assert newTargetSDT != null; - -// System.out.println("checking if T" + deqSDT + " is eq to O" + eqSDT + " under " + eqGuard); - if (eqSDT.isEquivalentUnder(deqSDT, ds)) { -// System.out.println("yes"); -// System.out.println("return target: " + deqSDT + " eq under " + eqGuard); - return deqSDT; - -// } else { -// System.out.println("checking if O" + otherSDT + " is eq to NT" + newTargetSDT + " under " + ds); -// -// if (newTargetSDT.canUse(otherSDT)) { -// System.out.println("return newTarget: " + newTargetSDT + " canUse "); -//// System.out.println("yes"); -// return otherSDT; -// } -// - } -// } //else if (guard instanceof IntervalGuard) { -// IntervalGuard iGuard = (IntervalGuard) guard; -// List ds = new ArrayList(); -// if (!iGuard.isSmallerGuard()) { -// ds.add(new EqualityGuard(iGuard.getParameter(), iGuard.getLeftReg())); -// } -// if (!iGuard.isBiggerGuard()) { -// ds.add(new EqualityGuard(iGuard.getParameter(), iGuard.getRightReg())); -// } -// if (otherSDT.isEquivalentUnder(targetSDT, ds)) { -// return true; -// } -// } - return null; - } - -// private Map mergeGuards(Map unmerged, SuffixValue currentParam, List regPotential) { -// if (unmerged.keySet().size() == 1) { -// assert unmerged.containsKey(new SDTTrueGuard(currentParam)); -// return unmerged; -// } -// Map merged = mergeGuards(new LinkedHashMap(), currentParam, unmerged, regPotential); -// -// if (merged.keySet().size() == 1) { -// -//// System.out.println("unmerged: " + merged); -// // hack?? -//// SDTGuard onlyGuard = merged.keySet().iterator().next(); -//// SDT onlySDT = merged.get(onlyGuard); -//// if (!(onlyGuard instanceof SDTTrueGuard)) { -//// assert onlyGuard instanceof SDTIfGuard; -//// merged.remove(onlyGuard); -//// merged.put(new SDTTrueGuard(currentParam), onlySDT); -//// } -// assert merged.containsKey(new SDTTrueGuard(currentParam)); -// -// } -//// System.out.println("merged: " + merged); -// return merged; -// } -// -// private Map -// mergeGuards(Map first, SuffixValue currentParam, Map second, List regPotential) { -//// System.out.println("comparing " + first + " with " + second); -//// if (!first.keySet().isEmpty() && first.keySet().size() <= second.keySet().size()) { -//// System.out.println("return " + first); -//// return first; -//// } else { -// // if they are not the same size, we want to keep merging them -// Map newSecond = mgGuards(second, currentParam, regPotential); -//// return mergeGuards(second, currentParam, newSecond); -// // } -// return newSecond; -// } - // given a map from guards to SDTs, merge guards based on whether they can - // use another SDT. - private Map - mgGuards(Map unmerged, SuffixValue currentParam, List regPotential) { - assert !unmerged.isEmpty(); - - Map retMap = new LinkedHashMap<>(); -// System.out.println("unmerged: " + unmerged); - Map, SDT> partitionedMap = partitionGuards(unmerged); -// System.out.println("partitionedMap: " + partitionedMap); - for (Map.Entry, SDT> par : partitionedMap.entrySet()) { - -// List preprocessed = new ArrayList(); -// preprocessed.addAll(par.getKey()); -// System.out.println("preprocessed: " + preprocessed); -// addAllSafely(new ArrayList(), preprocessed, new LinkedHashSet()); -// System.out.println("postprocessed: " + preprocessed); -// System.out.println("partitioned map entry: " + par.getKey()); - SDTGuard newSDTGuard = GuardSetFromList(new LinkedHashSet(), par.getKey(), currentParam, regPotential); -// System.out.println("--> Guard: " + newSDTGuard); - if (newSDTGuard instanceof SDTOrGuard) { - List subguards = ((SDTOrGuard) newSDTGuard).getGuards(); - if (subguards.isEmpty()) { - retMap.put(new SDTTrueGuard(currentParam), par.getValue()); - } else { - for (SDTGuard subguard : subguards) { - retMap.put(subguard, par.getValue()); - } - } - } else { - retMap.put(newSDTGuard, par.getValue()); - } - } -// System.out.println("retMap: " + retMap); - assert !retMap.isEmpty(); - //System.out.println("-----------------------------------\n" + partitionedMap + "\n-----------------------PARTITIONING-------------------\n" + retMap + "\n---------------------------------"); - return retMap; - } - - // given a set of registers and a set of guards, keep only the registers -// that are mentioned in any guard -// private PIV keepMem(Set guardSet) { -// PIV ret = new PIV(); -// -// // 1. create guard list -// Set ifGuards = new LinkedHashSet<>(); -// for (SDTGuard g : guardSet) { -// if (g instanceof SDTIfGuard) { -// ifGuards.add((SDTIfGuard) g); -// } else if (g instanceof SDTOrGuard) { -// ifGuards.addAll(((SDTOrGuard) g).getGuards()); -// } -// } -// -// // 2. determine which registers to keep -// Set tempRegs = new LinkedHashSet<>(); -// for (SDTGuard g : ifGuards) { -// if (g instanceof SDTAndGuard) { -// tempRegs.addAll(((SDTAndGuard) g).getAllRegs()); -// } else if (g instanceof SDTIfGuard) { -// tempRegs.add(((SDTIfGuard) g).getRegister()); -// } -// } -// for (SymbolicDataValue r : tempRegs) { -// Parameter p = new Parameter(r.getType(), r.getId()); -// if (r instanceof Register) { -// ret.put(p, (Register) r); -// } -// } -// return ret; -// } -// - private PIV keepMem(Map guardMap) { + boolean useSuffixOpt = false; + + public Map, SDTGuard> equivalenceClasses(Word prefix, + SymbolicSuffix suffix, + SuffixValue suffixValue, + Map, SymbolicDataValue> potValuation, + SuffixValuation suffixValues, + Constants consts) { + Map, SDTGuard> valueGuards = generateEquivClasses(prefix, suffixValue, potValuation, consts); + // apply suffix restrictions + return filterEquivClasses(valueGuards, prefix, suffix, suffixValue, potValuation, suffixValues, consts); + } + + private Map, SDTGuard> generateEquivClasses(Word prefix, + SuffixValue suffixValue, + Map, SymbolicDataValue> potValuation, + Constants consts) { + + Map, SDTGuard> valueGuards = new LinkedHashMap<>(); + + if (potValuation.isEmpty()) { + DataValue fresh = getFreshValue(new ArrayList<>()); + valueGuards.put(fresh, new SDTTrueGuard(suffixValue)); + return valueGuards; + } + int usedVals = potValuation.size(); + List> potential = new ArrayList<>(); + potential.addAll(potValuation.keySet()); + List> sortedPot = sort(potential); + + Valuation vals = new Valuation(); + for (Map.Entry, SymbolicDataValue> pot : potValuation.entrySet()) { + SymbolicDataValue r = pot.getValue(); + DataValue dv = pot.getKey(); + // TODO: fix unchecked invocation + vals.setValue(toVariable(r), dv.getId()); + } + + // smallest + DataValue dl = sortedPot.get(0); + SymbolicDataValue rl = potValuation.get(dl); + IntervalGuard sg = new IntervalGuard(suffixValue, null, rl); + DataValue smallest = instantiate(sg, vals, consts, sortedPot); + valueGuards.put(smallest, sg); + + for (int i = 1; i < usedVals; i++) { + // equality + EqualityGuard eg = new EqualityGuard(suffixValue, rl); + valueGuards.put(dl, eg); + + // interval + DataValue dr = sortedPot.get(i); + SymbolicDataValue rr = potValuation.get(dr); + IntervalGuard ig = new IntervalGuard(suffixValue, rl, rr); + DataValue di = instantiate(ig, vals, consts, sortedPot); + valueGuards.put(di, ig); + + dl = dr; + rl = rr; + } + EqualityGuard eg = new EqualityGuard(suffixValue, rl); + valueGuards.put(dl, eg); + + // greatest + IntervalGuard gg = new IntervalGuard(suffixValue, rl, null); + DataValue dg = instantiate(gg, vals, consts, sortedPot); + valueGuards.put(dg, gg); + + return valueGuards; + } + + private Map, SDTGuard> filterEquivClasses(Map, SDTGuard> valueGuards, + Word prefix, + SymbolicSuffix suffix, + SuffixValue suffixValue, + Map, SymbolicDataValue> potValuation, + SuffixValuation suffixVals, + Constants consts) { + List> equivClasses = new ArrayList<>(); + equivClasses.addAll(valueGuards.keySet()); + EquivalenceClassFilter eqcFilter = new EquivalenceClassFilter<>(equivClasses, useSuffixOpt); + List> filteredEquivClasses = eqcFilter.toList(suffix.getRestriction(suffixValue), prefix, suffix.getActions(), suffixVals, consts); + + Map, SDTGuard> ret = new LinkedHashMap<>(); + for (Map.Entry, SDTGuard> e : valueGuards.entrySet()) { + DataValue ec = e.getKey(); + if (filteredEquivClasses.contains(ec)) { + ret.put(ec, e.getValue()); + } + } + return ret; + } + + private List> sort(Collection> list) { + List> sorted = new ArrayList<>(); + sorted.addAll(list); + sorted.sort(getComparator()); + return sorted; + } + + protected abstract Comparator> getComparator(); + + protected Map mergeGuards(Map sdts, + Map, SDTGuard> equivClasses, + Collection> filteredOut) { + Map merged = new LinkedHashMap<>(); + + List> ecValuesSorted = sort(equivClasses.keySet()); + Iterator> ecit = ecValuesSorted.iterator(); + DataValue first = ecit.next(); + SDTGuard mergedGuards = equivClasses.get(first); + SDT currSdt = sdts.get(mergedGuards); + + Comparator> comparator = getComparator(); + Iterator> filtit = sort(filteredOut).iterator(); + DataValue smallerDataValue = getSmallerDataValue(first); + DataValue filtered = filtit.hasNext() ? filtit.next() : smallerDataValue; + boolean lastFilteredOut = comparator.compare(first, filtered) == 0; + if (lastFilteredOut) { + assert ecit.hasNext(); + filtered = filtit.hasNext() ? filtit.next() : smallerDataValue; + } + + while(ecit.hasNext()) { + DataValue next = ecit.next(); + SDTGuard nextGuard = equivClasses.get(next); + SDT nextSdt = sdts.get(nextGuard); + boolean thisFilteredOut = comparator.compare(next, filtered) == 0; + boolean inequivalentSdts = thisFilteredOut || (currSdt == null ? false : !currSdt.isEquivalent(nextSdt, new VarMapping<>())); + if (thisFilteredOut || inequivalentSdts || lastFilteredOut) { + if (!lastFilteredOut) { + merged.put(mergedGuards, currSdt); + } + mergedGuards = nextGuard; + currSdt = nextSdt; + } else { + mergedGuards = mergeIntervals(mergedGuards, nextGuard); + } + + lastFilteredOut = thisFilteredOut; + if (comparator.compare(next, filtered) >= 0 && filtit.hasNext()) { + filtered = filtit.next(); + } + } + if (!lastFilteredOut) { + merged.put(mergedGuards, currSdt); + } + + // check for disequality guard (i.e., both s < r and s > r guards are present for some r) + merged = checkForDisequality(merged); + + // if only one guard, replace with true guard + if (merged.size() == 1) { + Map.Entry entry = merged.entrySet().iterator().next(); + SDTGuard g = entry.getKey(); + if (g instanceof DisequalityGuard || (g instanceof IntervalGuard && ((IntervalGuard) g).isBiggerGuard())) { + merged = new LinkedHashMap<>(); + merged.put(new SDTTrueGuard(g.getParameter()), entry.getValue()); + } + } + + assert !merged.isEmpty(); + + return merged; + } + + private SDTGuard mergeIntervals(SDTGuard leftGuard, SDTGuard rightGuard) { + SuffixValue suffixValue = leftGuard.getParameter(); + if (leftGuard instanceof EqualityGuard) { + EqualityGuard egLeft = (EqualityGuard) leftGuard; + SymbolicDataValue rl = egLeft.getRegister(); + if (rightGuard instanceof IntervalGuard) { + IntervalGuard igRight = (IntervalGuard) rightGuard; + if (!igRight.isSmallerGuard() && igRight.getLeftReg().equals(rl)) { + if (igRight.isBiggerGuard()) { + return IntervalGuard.greaterOrEqualGuard(suffixValue, rl); + } else { + return new IntervalGuard(suffixValue, rl, igRight.getRightReg(), true, false); + } + } + } + } else if (leftGuard instanceof IntervalGuard && !((IntervalGuard) leftGuard).isBiggerGuard()) { + IntervalGuard igLeft = (IntervalGuard) leftGuard; + SymbolicDataValue rr = igLeft.getRightReg(); + if (igLeft.isSmallerGuard()) { + if (rightGuard instanceof EqualityGuard && ((EqualityGuard) rightGuard).getRegister().equals(rr)) { + return IntervalGuard.lessOrEqualGuard(suffixValue, rr); + } else if (rightGuard instanceof IntervalGuard && + !((IntervalGuard) rightGuard).isSmallerGuard() && + ((IntervalGuard) rightGuard).getLeftReg().equals(rr)) { + IntervalGuard igRight = (IntervalGuard) rightGuard; + if (igRight.isIntervalGuard()) { + return IntervalGuard.lessGuard(suffixValue, igRight.getRightReg()); + } else { + return new SDTTrueGuard(suffixValue); + } + } + } else if (igLeft.isIntervalGuard()) { + if (rightGuard instanceof EqualityGuard && ((EqualityGuard) rightGuard).getRegister().equals(rr)) { + return new IntervalGuard(suffixValue, igLeft.getLeftReg(), rr, igLeft.isLeftClosed(), true); + } else if (rightGuard instanceof IntervalGuard && + !((IntervalGuard) rightGuard).isSmallerGuard() && + ((IntervalGuard) rightGuard).getLeftReg().equals(rr)) { + IntervalGuard igRight = (IntervalGuard) rightGuard; + if (igRight.isBiggerGuard()) { + return new IntervalGuard(suffixValue, igLeft.getLeftReg(), null, igLeft.isLeftClosed(), false); + } else { + return new IntervalGuard(suffixValue, igLeft.getLeftReg(), igRight.getRightReg(), igLeft.isLeftClosed(), igRight.isRightClosed()); + } + } + } + } + throw new java.lang.IllegalArgumentException("Guards are not compatible for merging"); + } + + private DataValue getSmallerDataValue(DataValue dv) { + SuffixValue s = new SuffixValue(dv.getType(), 1); + Register r = new Register(dv.getType(), 1); + IntervalGuard ig = new IntervalGuard(s, null, r); + Valuation val = new Valuation(); + val.setValue(toVariable(r), dv.getId()); + return instantiate(ig, val, new Constants(), new ArrayList<>()); + } + + private Map checkForDisequality(Map guards) { + int size = guards.size(); + if (size < 1 || size > 3) + return guards; + + Optional less = guards.keySet().stream().filter(g -> g instanceof IntervalGuard && ((IntervalGuard) g).isSmallerGuard()).findAny(); + Optional greater = guards.keySet().stream().filter(g -> g instanceof IntervalGuard && ((IntervalGuard) g).isBiggerGuard()).findAny(); + if (less.isPresent() && greater.isPresent()) { + IntervalGuard lg = (IntervalGuard) less.get(); + IntervalGuard gg = (IntervalGuard) greater.get(); + SDT ls = guards.get(lg); + SDT gs = guards.get(gg); + SymbolicDataValue rr = lg.getRightReg(); + SymbolicDataValue rl = gg.getLeftReg(); + if (rr.equals(rl) && ls.isEquivalent(gs, new VarMapping<>())) { + Map diseq = new LinkedHashMap<>(); + diseq.put(new DisequalityGuard(lg.getParameter(), rr), guards.get(lg)); + Optional equal = guards.keySet().stream().filter(g -> g instanceof EqualityGuard).findAny(); + if (equal.isPresent()) { + EqualityGuard eg = (EqualityGuard) equal.get(); + assert eg.getRegister().equals(rr); + diseq.put(eg, guards.get(eg)); + } + return diseq; + } + } + return guards; + } + + private PIV keepMem(Map guardMap) { PIV ret = new PIV(); for (Map.Entry e : guardMap.entrySet()) { SDTGuard mg = e.getKey(); if (mg instanceof SDTIfGuard) { - //LOGGER.trace(mg.toString()); SymbolicDataValue r = ((SDTIfGuard) mg).getRegister(); Parameter p = new Parameter(r.getType(), r.getId()); if (r instanceof Register) { @@ -842,6 +361,14 @@ private PIV keepMem(Map guardMap) { ret.put(p, (Register) r); } } + } else if (mg instanceof SDTAndGuard) { + Set rSet = ((SDTAndGuard) mg).getAllRegs(); + for (SymbolicDataValue r : rSet) { + Parameter p = new Parameter(r.getType(), r.getId()); + if (r instanceof Register) { + ret.put(p, (Register) r); + } + } } else if (!(mg instanceof SDTTrueGuard)) { throw new IllegalStateException("wrong kind of guard"); } @@ -850,286 +377,89 @@ private PIV keepMem(Map guardMap) { } @Override - public SDT treeQuery( - Word prefix, - SymbolicSuffix suffix, - WordValuation values, - PIV piv, - Constants constants, - SuffixValuation suffixValues, - SDTConstructor oracle) { - - int pId = values.size() + 1; - List regPotential = new ArrayList<>(); - SuffixValue sv = suffix.getDataValue(pId); - DataType type = sv.getType(); - - List prefixValues = Arrays.asList(DataWords.valsOf(prefix)); - - SuffixValue currentParam = new SuffixValue(type, pId); - - Map tempKids = new LinkedHashMap<>(); - - Collection> potSet = DataWords.joinValsToSet( - constants.values(type), - DataWords.valSet(prefix, type), - suffixValues.values(type)); - - List> potList = new ArrayList<>(potSet); - List> potential = getPotential(potList); - // WE ASSUME THE POTENTIAL IS SORTED - - int potSize = potential.size(); - -// System.out.println("potential " + potential); - if (potential.isEmpty()) { -// System.out.println("empty potential"); - WordValuation elseValues = new WordValuation(); - DataValue fresh = getFreshValue(potential); - elseValues.putAll(values); - elseValues.put(pId, fresh); - - // this is the valuation of the suffixvalues in the suffix - SuffixValuation elseSuffixValues = new SuffixValuation(); - elseSuffixValues.putAll(suffixValues); - elseSuffixValues.put(sv, fresh); - - SDT elseOracleSdt = oracle.treeQuery( - prefix, suffix, elseValues, piv, - constants, elseSuffixValues); - tempKids.put(new SDTTrueGuard(currentParam), elseOracleSdt); - } // process each '<' case - else { - //Parameter p = new Parameter( - // currentParam.getType(), currentParam.getId()); - - // smallest case - WordValuation smValues = new WordValuation(); - smValues.putAll(values); - SuffixValuation smSuffixValues = new SuffixValuation(); - smSuffixValues.putAll(suffixValues); - - Valuation smVal = new Valuation(); - DataValue dvRight = potential.get(0); - IntervalGuard sguard = makeSmallerGuard( - dvRight, prefixValues, currentParam, smValues, piv); - SymbolicDataValue rsm = sguard.getRightReg(); -// System.out.println("setting valuation, symDV: " + rsm.toVariable() + " dvright: " + dvRight); - smVal.setValue(toVariable(rsm), dvRight.getId()); - DataValue smcv = instantiate( - sguard, smVal, constants, potential); - smValues.put(pId, smcv); - smSuffixValues.put(sv, smcv); - - SDT smoracleSdt = oracle.treeQuery( - prefix, suffix, smValues, piv, constants, smSuffixValues); - - tempKids.put(sguard, smoracleSdt); - - // biggest case - WordValuation bgValues = new WordValuation(); - bgValues.putAll(values); - SuffixValuation bgSuffixValues = new SuffixValuation(); - bgSuffixValues.putAll(suffixValues); - - Valuation bgVal = new Valuation(); - - DataValue dvLeft = potential.get(potSize - 1); - IntervalGuard bguard = makeBiggerGuard( - dvLeft, prefixValues, currentParam, bgValues, piv); - SymbolicDataValue rbg = bguard.getLeftReg(); - - bgVal.setValue(toVariable(rbg), dvLeft.getId()); - DataValue bgcv = instantiate( - bguard, bgVal, constants, potential); - bgValues.put(pId, bgcv); - bgSuffixValues.put(sv, bgcv); - - SDT bgoracleSdt = oracle.treeQuery( - prefix, suffix, bgValues, piv, constants, bgSuffixValues); - - tempKids.put(bguard, bgoracleSdt); - - if (potSize > 1) { //middle cases - for (int i = 1; i < potSize; i++) { - - WordValuation currentValues = new WordValuation(); - currentValues.putAll(values); - SuffixValuation currentSuffixValues = new SuffixValuation(); - currentSuffixValues.putAll(suffixValues); - //SDTGuard guard; - Valuation val = new Valuation(); - DataValue dvMRight = potential.get(i); - DataValue dvMLeft = potential.get(i - 1); - -// IntervalGuard smallerGuard = makeSmallerGuard( -// dvMRight, prefixValues, -// currentParam, currentValues, piv); -// IntervalGuard biggerGuard = makeBiggerGuard( -// dvMLeft, prefixValues, currentParam, -// currentValues, piv); - IntervalGuard intervalGuard = makeIntervalGuard( - dvMLeft, dvMRight, prefixValues, currentParam, currentValues, piv); - -// IntervalGuard guard = new IntervalGuard( -// currentParam, biggerGuard.getLeftReg(), smallerGuard.getRightReg()); - SymbolicDataValue rs = intervalGuard.getRightReg(); - SymbolicDataValue rb = intervalGuard.getLeftReg(); - - val.setValue(toVariable(rs), dvMRight.getId()); - val.setValue(toVariable(rb), dvMLeft.getId()); - - DataValue cv = instantiate( - intervalGuard, val, constants, potential); - currentValues.put(pId, cv); - currentSuffixValues.put(sv, cv); - - SDT oracleSdt = oracle.treeQuery( - prefix, suffix, currentValues, piv, - constants, currentSuffixValues); - - tempKids.put(intervalGuard, oracleSdt); - regPotential.add(i - 1, rb); - regPotential.add(i, rs); - } - } -// System.out.println("eq potential is: " + potential); - for (DataValue newDv : potential) { -// LOGGER.trace(newDv.toString()); - - // this is the valuation of the suffixvalues in the suffix - SuffixValuation ifSuffixValues = new SuffixValuation(); - ifSuffixValues.putAll(suffixValues); // copy the suffix valuation - - EqualityGuard eqGuard = pickupDataValue(newDv, prefixValues, - currentParam, values, constants); -// LOGGER.trace("eqGuard is: " + eqGuard.toString()); - //construct the equality guard - // find the data value in the prefix - // this is the valuation of the positions in the suffix - WordValuation ifValues = new WordValuation(); - ifValues.putAll(values); - ifValues.put(pId, newDv); - SDT eqOracleSdt = oracle.treeQuery( - prefix, suffix, ifValues, piv, constants, ifSuffixValues); - - tempKids.put(eqGuard, eqOracleSdt); - } - + public SDT treeQuery(Word prefix, + SymbolicSuffix suffix, + WordValuation values, + PIV piv, + Constants consts, + SuffixValuation suffixValues, + SDTConstructor oracle) { + + int pId = values.size() + 1; + SuffixValue currentParam = suffix.getSuffixValue(pId); + Map, SymbolicDataValue> pot = getPotential(prefix, suffixValues, consts); + + Map, SDTGuard> equivClasses = generateEquivClasses(prefix, currentParam, pot, consts); + Map, SDTGuard> filteredEquivClasses = filterEquivClasses(equivClasses, prefix, suffix, currentParam, pot, suffixValues, consts); + + Map children = new LinkedHashMap<>(); + for (Map.Entry, SDTGuard> ec : filteredEquivClasses.entrySet()) { + SuffixValuation nextSuffixVals = new SuffixValuation(); + WordValuation nextVals = new WordValuation(); + nextVals.putAll(values); + nextVals.put(pId, ec.getKey()); + nextSuffixVals.putAll(suffixValues); + nextSuffixVals.put(currentParam, ec.getKey()); + SDT sdt = oracle.treeQuery(prefix, suffix, nextVals, piv, consts, nextSuffixVals); + children.put(ec.getValue(), sdt); } -// System.out.println("TEMPKIDS for " + prefix + " + " + suffix + " = " + tempKids); - Map merged = mgGuards(tempKids, currentParam, regPotential); - // only keep registers that are referenced by the merged guards -// System.out.println("MERGED = " + merged); - assert !merged.keySet().isEmpty(); - -// System.out.println("MERGED = " + merged); + Collection> filteredOut = new ArrayList<>(); + filteredOut.addAll(equivClasses.keySet()); + filteredOut.removeAll(filteredEquivClasses.keySet()); + Map merged = mergeGuards(children, equivClasses, filteredOut); piv.putAll(keepMem(merged)); -// LOGGER.trace("temporary guards = " + tempKids.keySet()); -// LOGGER.trace("merged guards = " + merged.keySet()); -// LOGGER.trace("merged pivs = " + piv.toString()); - - tempKids.clear(); - - for (SDTGuard g : merged.keySet()) { - assert !(g == null); - if (g instanceof SDTTrueGuard) { - if (merged.keySet().size() != 1) { - throw new IllegalStateException("only one true guard allowed: \n" + prefix + " + " + suffix); - } - //assert merged.keySet().size() == 1; - } + Map reversed = new LinkedHashMap<>(); + List keys = new ArrayList<>(merged.keySet()); + Collections.reverse(keys); + for (SDTGuard g : keys) { + reversed.put(g, merged.get(g)); } -// System.out.println("MERGED = " + merged); - SDT returnSDT = new SDT(merged); - return returnSDT; - } - private EqualityGuard pickupDataValue(DataValue newDv, - List prefixValues, SuffixValue currentParam, - WordValuation ifValues, Constants constants) { - DataType type = currentParam.getType(); - int newDv_i; - for (Map.Entry> entry : constants.entrySet()) { - if (entry.getValue().equals(newDv)) { - return new EqualityGuard(currentParam, entry.getKey()); - } - } - if (prefixValues.contains(newDv)) { - // first index of the data value in the prefixvalues list - newDv_i = prefixValues.indexOf(newDv) + 1; - Register newDv_r = new Register(type, newDv_i); - return new EqualityGuard(currentParam, newDv_r); - - } // if the data value isn't in the prefix, it is somewhere earlier in the suffix - else { - int smallest = Collections.min(ifValues.getAllKeys(newDv)); - return new EqualityGuard(currentParam, new SuffixValue(type, smallest)); - } + return new SDT(reversed); } - private IntervalGuard makeSmallerGuard(DataValue smallerDv, - List prefixValues, SuffixValue currentParam, - WordValuation ifValues, PIV pir) { - DataType type = currentParam.getType(); - int newDv_i; - if (prefixValues.contains(smallerDv)) { - newDv_i = prefixValues.indexOf(smallerDv) + 1; - SymbolicDataValue.Parameter newDv_p - = new SymbolicDataValue.Parameter(type, newDv_i); - Register newDv_r; - if (pir.containsKey(newDv_p)) { - newDv_r = pir.get(newDv_p); - } else { - newDv_r = new Register(type, newDv_i); - } - return new IntervalGuard(currentParam, null, newDv_r); - - } // if the data value isn't in the prefix, it is somewhere earlier in the suffix - else { - int smallest = Collections.min(ifValues.getAllKeys(smallerDv)); - IntervalGuard sg = new IntervalGuard( - currentParam, null, new SuffixValue(type, smallest)); - return sg; - } + private Map, SymbolicDataValue> getPotential(Word prefix, + SuffixValuation suffixValues, + Constants consts) { + Map, SymbolicDataValue> pot = new LinkedHashMap<>(); + RegisterGenerator rgen = new RegisterGenerator(); + + List> seen = new ArrayList<>(); + for (PSymbolInstance psi : prefix) { + DataValue dvs[] = psi.getParameterValues(); + DataType dts[] = psi.getBaseSymbol().getPtypes(); + for (int i = 0; i < dvs.length; i++) { + Register r = rgen.next(dts[i]); + DataValue dv = safeCast(dvs[i]); + if (dv != null && !seen.contains(dv)) { + pot.put(dv, r); + seen.add(dv); + } + } + } + + for (Map.Entry> e : suffixValues.entrySet()) { + SuffixValue sv = e.getKey(); + DataValue dv = safeCast(e.getValue()); + if (dv != null) { + pot.put(dv, sv); + } + } + + for (Map.Entry> e : consts.entrySet()) { + Constant c = e.getKey(); + DataValue dv = safeCast(e.getValue()); + if (dv != null) { + pot.put(dv, c); + } + } + + return pot; } - private IntervalGuard makeIntervalGuard(DataValue biggerDv, - DataValue smallerDv, - List prefixValues, SuffixValue currentParam, - WordValuation ifValues, PIV pir) { - IntervalGuard smallerGuard = makeSmallerGuard(smallerDv, prefixValues, currentParam, ifValues, pir); - IntervalGuard biggerGuard = makeBiggerGuard(biggerDv, prefixValues, currentParam, ifValues, pir); - return new IntervalGuard(currentParam, biggerGuard.getLeftReg(), smallerGuard.getRightReg()); - } - - private IntervalGuard makeBiggerGuard(DataValue biggerDv, - List prefixValues, SuffixValue currentParam, - WordValuation ifValues, PIV pir) { - DataType type = currentParam.getType(); - int newDv_i; - if (prefixValues.contains(biggerDv)) { - newDv_i = prefixValues.indexOf(biggerDv) + 1; - SymbolicDataValue.Parameter newDv_p - = new SymbolicDataValue.Parameter(type, newDv_i); - Register newDv_r; - if (pir.containsKey(newDv_p)) { - newDv_r = pir.get(newDv_p); - } else { - newDv_r = new Register(type, newDv_i); - } - return new IntervalGuard(currentParam, newDv_r, null); - - } // if the data value isn't in the prefix, it is somewhere earlier in the suffix - else { - int smallest = Collections.min(ifValues.getAllKeys(biggerDv)); - IntervalGuard bg = new IntervalGuard( - currentParam, new SuffixValue(type, smallest), null); - return bg; - } - } + protected abstract DataValue safeCast(DataValue val); public abstract List> getPotential(List> vals); @@ -1137,9 +467,7 @@ private DataValue getRegisterValue(SymbolicDataValue r, PIV piv, List prefixValues, Constants constants, ParValuation pval) { if (r.isRegister()) { -// LOGGER.trace("piv: " + piv + " " + r.toString() + " " + prefixValues); Parameter p = piv.getOneKey((Register) r); -// LOGGER.trace("p: " + p.toString()); int idx = p.getId(); return prefixValues.get(idx - 1); } else if (r.isSuffixValue()) { @@ -1169,15 +497,11 @@ public DataValue instantiate( DataValue returnThis = null; List prefixValues = Arrays.asList(DataWords.valsOf(prefix)); -// LOGGER.trace("prefix values : " + prefixValues.toString()); - if (guard instanceof EqualityGuard) { EqualityGuard eqGuard = (EqualityGuard) guard; SymbolicDataValue ereg = eqGuard.getRegister(); if (ereg.isRegister()) { -// LOGGER.trace("piv: " + piv.toString() + " " + ereg.toString() + " " + param.toString()); Parameter p = piv.getOneKey((Register) ereg); -// LOGGER.trace("p: " + p.toString()); int idx = p.getId(); returnThis = prefixValues.get(idx - 1); } else if (ereg.isSuffixValue()) { @@ -1201,7 +525,6 @@ public DataValue instantiate( DataWords.valSet(prefix, type), pval.values(type)); Valuation val = new Valuation(); - //System.out.println("already used = " + alreadyUsedValues); if (guard instanceof IntervalGuard) { IntervalGuard iGuard = (IntervalGuard) guard; if (!iGuard.isBiggerGuard()) { @@ -1218,7 +541,6 @@ public DataValue instantiate( val.setValue(toVariable(l), regVal.getId()); } - //instantiate(guard, val, param, constants); } else if (guard instanceof SDTIfGuard) { SymbolicDataValue r = ((SDTIfGuard) guard).getRegister(); DataValue regVal = getRegisterValue(r, piv, @@ -1231,98 +553,105 @@ public DataValue instantiate( } else if (guard instanceof SDTAndGuard) { assert ((SDTAndGuard) guard).getGuards().stream().allMatch(g -> g instanceof DisequalityGuard); SDTGuard aGuard = ((SDTAndGuard) guard).getGuards().get(0); - - - - returnThis = instantiate(aGuard, val, constants, alreadyUsedValues); + returnThis = this.instantiate(prefix, ps, piv, pval, constants, aGuard, param, oldDvs); } else { throw new IllegalStateException("only =, != or interval allowed. Got " + guard); } - -// } -// } else if (iGuard instanceof SDTIfGuard) { -// SymbolicDataValue r = ((SDTIfGuard) iGuard).getRegister(); -// DataValue regVal = getRegisterValue(r, piv, -// prefixValues, constants, pval); -// val.setValue(r.toVariable(), regVal); -// } -// } -// } if (!(oldDvs.isEmpty())) { -// System.out.println("old dvs: " + oldDvs); for (DataValue oldDv : oldDvs) { Valuation newVal = new Valuation(); newVal.putAll(val); newVal.setValue(toVariable( new SuffixValue(param.getType(), param.getId()) ), oldDv.getId()); -// System.out.println("instantiating " + guard + " with " + newVal); DataValue inst = instantiate(guard, newVal, constants, alreadyUsedValues); if (inst != null) { -// System.out.println("returning (reused): " + inst); return inst; } } } returnThis = instantiate(guard, val, constants, alreadyUsedValues); -// System.out.println("returning (no reuse): " + ret); } return returnThis; } -// @Override -// public DataValue instantiate( -// Word prefix, -// ParameterizedSymbol ps, PIV piv, -// ParValuation pval, -// Constants constants, -// SDTGuard guard, -// Parameter param) { -// -// DataType type = param.getType(); -// -// List prefixValues = Arrays.asList(DataWords.valsOf(prefix)); -// -// LOGGER.trace("prefix values : " + prefixValues.toString()); -// -// if (guard instanceof EqualityGuard) { -// EqualityGuard eqGuard = (EqualityGuard) guard; -// SymbolicDataValue ereg = eqGuard.getRegister(); -// DataValue x = getRegisterValue( -// ereg, piv, prefixValues, constants, pval); -// return x; -// } else if ((guard instanceof SDTTrueGuard) -// || guard instanceof DisequalityGuard) { -// -// Collection> potSet = DataWords.joinValsToSet( -// constants.values(type), -// DataWords.valSet(prefix, type), -// pval.values(type)); -// -// return this.getFreshValue(new ArrayList>(potSet)); -// } else { -// Collection> alreadyUsedValues -// = DataWords.joinValsToSet( -// constants.values(type), -// DataWords.valSet(prefix, type), -// pval.values(type)); -// Valuation val = new Valuation(); -// if (guard instanceof SDTIfGuard) { -// SymbolicDataValue r = (((SDTIfGuard) guard).getRegister()); -// DataValue regVal = getRegisterValue(r, piv, -// prefixValues, constants, pval); -// -// val.setValue(r.toVariable(), regVal); -// //instantiate(guard, val, param, constants); -// } else if (guard instanceof SDTMultiGuard) { -// for (SDTIfGuard ifGuard : ((SDTMultiGuard) guard).getGuards()) { -// SymbolicDataValue r = ifGuard.getRegister(); -// DataValue regVal = getRegisterValue(r, piv, -// prefixValues, constants, pval); -// val.setValue(r.toVariable(), regVal); -// } -// } -// return instantiate(guard, val, constants, alreadyUsedValues); -// } -// -// } + public void useSuffixOptimization(boolean useSuffixOpt) { + this.useSuffixOpt = useSuffixOpt; + } + + @Override + public SuffixValueRestriction restrictSuffixValue(SuffixValue suffixValue, Word prefix, Word suffix, Constants consts) { + int firstActionArity = suffix.size() > 0 ? suffix.getSymbol(0).getBaseSymbol().getArity() : 0; + if (suffixValue.getId() <= firstActionArity) { + return new UnrestrictedSuffixValue(suffixValue); + } + + DataValue prefixVals[] = DataWords.valsOf(prefix); + DataValue suffixVals[] = DataWords.valsOf(suffix); + DataValue constVals[] = new DataValue[consts.size()]; + constVals = consts.values().toArray(constVals); + DataValue priorVals[] = new DataValue[prefixVals.length + constVals.length + suffixValue.getId() - 1]; + DataType svType = suffixValue.getType(); + DataValue svDataValue = safeCast(suffixVals[suffixValue.getId()-1]); + assert svDataValue != null; + + System.arraycopy(prefixVals, 0, priorVals, 0, prefixVals.length); + System.arraycopy(constVals, 0, priorVals, prefixVals.length, constVals.length); + System.arraycopy(suffixVals, 0, priorVals, prefixVals.length + constVals.length, suffixValue.getId() - 1); + + // is suffix value greater than all prior or smaller than all prior? + Comparator> comparator = getComparator(); + boolean greater = false; + boolean lesser = false; + boolean foundFirst = false; + for (int i = 0; i < priorVals.length; i++) { + if (priorVals[i].getType().equals(svType)) { + DataValue dv = safeCast(priorVals[i]); + assert dv != null; + int comparison = comparator.compare(svDataValue, dv); + + if (foundFirst) { + if ((greater && comparison < 0) || + (lesser && comparison > 0) || + comparison == 0) { + return new UnrestrictedSuffixValue(suffixValue); + } + } else { + if (comparison > 0) { + greater = true; + } else if (comparison < 0) { + lesser = true; + } else { + return new UnrestrictedSuffixValue(suffixValue); + } + foundFirst = true; + } + } + } + + if (!foundFirst) { + return new GreaterSuffixValue(suffixValue); + } + + assert (greater && !lesser) || (!greater && lesser); + return greater ? new GreaterSuffixValue(suffixValue) : new LesserSuffixValue(suffixValue); + } + + @Override + public SuffixValueRestriction restrictSuffixValue(SDTGuard guard, Map prior) { + SuffixValue sv = guard.getParameter(); + + if (guard instanceof IntervalGuard) { + IntervalGuard ig = (IntervalGuard) guard; + if (ig.isBiggerGuard()) { + return new GreaterSuffixValue(sv); + } else if (ig.isSmallerGuard()) { + return new LesserSuffixValue(sv); + } + } + SuffixValueRestriction restr = SuffixValueRestriction.genericRestriction(guard, prior); + if (restr instanceof FreshSuffixValue) { + restr = new GreaterSuffixValue(sv); + } + return restr; + } } diff --git a/src/main/java/de/learnlib/ralib/theory/inequality/IntervalGuard.java b/src/main/java/de/learnlib/ralib/theory/inequality/IntervalGuard.java index 49b703ee..d32bd18d 100644 --- a/src/main/java/de/learnlib/ralib/theory/inequality/IntervalGuard.java +++ b/src/main/java/de/learnlib/ralib/theory/inequality/IntervalGuard.java @@ -32,8 +32,6 @@ import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.data.VarMapping; import de.learnlib.ralib.theory.SDTGuard; -import de.learnlib.ralib.theory.equality.DisequalityGuard; -import de.learnlib.ralib.theory.equality.EqualityGuard; /** * @@ -43,45 +41,27 @@ public class IntervalGuard extends SDTGuard { private final SymbolicDataValue leftLimit; private final SymbolicDataValue rightLimit; + private final boolean leftClosed; + private final boolean rightClosed; - public IntervalGuard(SuffixValue param, SymbolicDataValue ll, SymbolicDataValue rl) { - super(param); - leftLimit = ll; - rightLimit = rl; + public IntervalGuard(SuffixValue param, SymbolicDataValue leftLimit, SymbolicDataValue rightLimit, boolean leftClosed, boolean rightClosed) { + super(param); + this.leftLimit = leftLimit; + this.rightLimit = rightLimit; + this.leftClosed = leftClosed; + this.rightClosed = rightClosed; + } + + public IntervalGuard(SuffixValue param, SymbolicDataValue leftLimit, SymbolicDataValue rightLimit) { + this(param, leftLimit, rightLimit, false, false); } public IntervalGuard(IntervalGuard other) { super(other); leftLimit = other.leftLimit;//.copy(); rightLimit = other.rightLimit;//.copy(); - } - - public EqualityGuard toEqGuard() { - assert !isIntervalGuard(); - SymbolicDataValue r = null; - if (isSmallerGuard()) { - r = rightLimit; - } - else { - r = leftLimit; - } - return new EqualityGuard(this.parameter,r); - } - - public DisequalityGuard toDeqGuard() { - assert !isIntervalGuard(); - SymbolicDataValue r = null; - if (isSmallerGuard()) { - r = rightLimit; - } - else { - r = leftLimit; - } - return new DisequalityGuard(this.parameter,r); - } - - public IntervalGuard flip() { - return new IntervalGuard(parameter, rightLimit, leftLimit); + leftClosed = other.leftClosed; + rightClosed = other.rightClosed; } public boolean isSmallerGuard() { @@ -96,6 +76,14 @@ public boolean isIntervalGuard() { return (leftLimit != null && rightLimit != null); } + public boolean isLeftClosed() { + return leftClosed; + } + + public boolean isRightClosed() { + return rightClosed; + } + @Override public Set getComparands(SymbolicDataValue dv) { Set comparands = new LinkedHashSet<>(); @@ -109,12 +97,17 @@ else if (dv.equals(rightLimit)) @Override public String toString() { if (leftLimit == null) { - return "(" + this.getParameter().toString() + "<" + this.rightLimit.toString() + ")"; + return "(" + this.getParameter().toString() + (rightClosed ? "<=" : "<") + this.rightLimit.toString() + ")"; } if (rightLimit == null) { - return "(" + this.getParameter().toString() + ">" + this.leftLimit.toString() + ")"; + return "(" + this.getParameter().toString() + (leftClosed ? ">=" : ">") + this.leftLimit.toString() + ")"; } - return "(" + leftLimit.toString() + "<" + this.getParameter().toString() + "<" + this.rightLimit.toString() + ")"; + return "(" + leftLimit.toString() + + (leftClosed ? "<=" : "<") + + this.getParameter().toString() + + (rightClosed ? "<=" : "<") + + this.rightLimit.toString() + + ")"; } public Set getAllRegs() { @@ -138,170 +131,24 @@ public SymbolicDataValue getRightReg() { return rightLimit; } - // merge bigger with something - private Set bMergeIntervals(IntervalGuard other) { - Set guards = new LinkedHashSet<>(); - SymbolicDataValue l = this.getLeftReg(); - if (other.isBiggerGuard()) { - // System.out.println("other " + other + " is bigger"); - guards.add(this); - guards.add(other); - } else if (other.isSmallerGuard()) { -// System.out.println("other " + other + " is smaller"); -// System.out.println("see if " + l + " equals " + other.getRightReg() + "?"); - if (l.equals(other.getRightReg())) { -// System.out.println("yes, adding disequalityguard"); - guards.add(new DisequalityGuard(this.parameter, l)); - } else { -// System.out.println("no, merging into interval guard"); -// guards.add(new IntervalGuard(this.parameter, l, other.getRightReg())); - guards.add(this); - guards.add(other); - } - } else { -// System.out.println("other " + other + " is interv"); - - if (l.equals(other.getRightReg())) { - guards.add(new IntervalGuard(this.parameter, other.getLeftReg(), null)); - guards.add(new DisequalityGuard(this.parameter, l)); - } else if (l.equals(other.getLeftReg())) { - guards.add(this); - } else { - guards.add(this); - guards.add(other); - } - - } - return guards; - } - - // merge smaller with something - private Set sMergeIntervals(IntervalGuard other) { - Set guards = new LinkedHashSet<>(); - SymbolicDataValue r = this.getRightReg(); - if (other.isBiggerGuard()) { - return other.bMergeIntervals(this); - } else if (other.isSmallerGuard()) { - guards.add(this); - guards.add(other); - } else { - if (r.equals(other.getLeftReg())) { - guards.add(new IntervalGuard(this.parameter, null, other.getRightReg())); - guards.add(new DisequalityGuard(this.parameter, r)); - } else if (r.equals(other.getRightReg())) { - guards.add(this); - } else { - guards.add(this); - guards.add(other); - } - } - return guards; - } - - // merge interval with something - private Set iMergeIntervals(IntervalGuard other) { - Set guards = new LinkedHashSet<>(); - SymbolicDataValue l = this.getLeftReg(); - SymbolicDataValue r = this.getRightReg(); - if (other.isBiggerGuard()) { - return other.bMergeIntervals(this); - } else if (other.isSmallerGuard()) { - return other.sMergeIntervals(this); - } else { - SymbolicDataValue oL = other.getLeftReg(); - SymbolicDataValue oR = other.getRightReg(); - if (l.equals(oR)) { - if (r.equals(oL)) { - guards.add(new DisequalityGuard(this.parameter, l)); - guards.add(new DisequalityGuard(this.parameter, r)); - } else { - guards.add(new IntervalGuard(this.parameter, oL, r)); - guards.add(new DisequalityGuard(this.parameter, l)); - } - } else { - if (r.equals(oL)) { - guards.add(new IntervalGuard(this.parameter, l, oR)); - guards.add(new DisequalityGuard(this.parameter, r)); - } else { - guards.add(this); - guards.add(other); - } - } - } - return guards; - } - - private Set mergeIntervals(IntervalGuard other) { -// System.out.println("other i-guard: " + other); - if (this.isBiggerGuard()) { -// System.out.println(this + " is bigger, left limit is: " + this.leftLimit); - Set gs = this.bMergeIntervals(other); -// System.out.println("returningB: " + gs); - return gs; - } - if (this.isSmallerGuard()) { -// System.out.println(this + " is smaller, right limit is: " + this.rightLimit); - Set gs = this.sMergeIntervals(other); -// System.out.println("returningS: " + gs); - return gs; - } - -// System.out.println("is interv"); - return this.iMergeIntervals(other); - - } - -// private Set mergeWithEquality(EqualityGuard other) { -// Set guards = new LinkedHashSet<>(); -// if (!(other.getRegister().equals(this.leftLimit) || other.getRegister().equals(this.rightLimit))) { -// guards.add(this); -// guards.add(other); -// } else { -// guards.add(new SDTOrGuard(this.parameter, this, other)); -// } -// return guards; -// } - - @Override - public Set mergeWith(SDTGuard other, List regPotential) { - Set guards = new LinkedHashSet<>(); - if (other instanceof IntervalGuard) { - guards.addAll(this.mergeIntervals((IntervalGuard) other)); - } else if (other instanceof DisequalityGuard) { - DisequalityGuard dGuard = (DisequalityGuard) other; - if ((this.isBiggerGuard() && this.leftLimit.equals(dGuard.getRegister())) - || (this.isSmallerGuard() && this.rightLimit.equals(dGuard.getRegister()))) { - - guards.add((DisequalityGuard) other); - } - else { - guards.add(this); - guards.add(other); - } - // special case for equality guards - } else //if (other instanceof EqualityGuard) - { - //return this.mergeWithEquality((EqualityGuard) other); - //} - //else { -// System.out.println("guard " + other + " not deq or interval"); - guards.add(this); - guards.add(other); - } -// System.out.println("merged guards are: " + guards); - return guards; - } - @Override public GuardExpression toExpr() { if (leftLimit == null) { - return new AtomicGuardExpression(parameter, Relation.SMALLER, rightLimit); + return new AtomicGuardExpression(parameter, + (rightClosed ? Relation.SMALLER_OR_EQUAL : Relation.SMALLER), + rightLimit); } if (rightLimit == null) { - return new AtomicGuardExpression(parameter, Relation.BIGGER, leftLimit); + return new AtomicGuardExpression(parameter, + (leftClosed ? Relation.BIGGER_OR_EQUAL : Relation.BIGGER), + leftLimit); } else { - GuardExpression smaller = new AtomicGuardExpression(parameter, Relation.SMALLER, rightLimit); - GuardExpression bigger = new AtomicGuardExpression(parameter, Relation.BIGGER, leftLimit); + GuardExpression smaller = new AtomicGuardExpression(parameter, + (rightClosed ? Relation.SMALLER_OR_EQUAL : Relation.SMALLER), + rightLimit); + GuardExpression bigger = new AtomicGuardExpression(parameter, + (leftClosed ? Relation.BIGGER_OR_EQUAL : Relation.BIGGER), + leftLimit); return new Conjunction(smaller, bigger); } } @@ -330,7 +177,7 @@ public SDTGuard relabel(VarMapping relabelling) { } l = (l == null) ? leftLimit : l; } - return new IntervalGuard(sv, l, r); + return new IntervalGuard(sv, l, r, leftClosed, rightClosed); } @Override @@ -339,6 +186,8 @@ public int hashCode() { hash = 59 * hash + Objects.hashCode(parameter); hash = 59 * hash + Objects.hashCode(leftLimit); hash = 59 * hash + Objects.hashCode(rightLimit); + hash = 59 * hash + Objects.hashCode(leftClosed); + hash = 59 * hash + Objects.hashCode(rightClosed); hash = 59 * hash + Objects.hashCode(getClass()); return hash; @@ -359,6 +208,12 @@ public boolean equals(Object obj) { if (!Objects.equals(this.leftLimit, other.leftLimit)) { return false; } + if (!Objects.equals(this.leftClosed, other.leftClosed)) { + return false; + } + if (!Objects.equals(this.rightClosed, other.rightClosed)) { + return false; + } return Objects.equals(this.parameter, other.parameter); } @@ -372,4 +227,19 @@ public IntervalGuard copy() { return new IntervalGuard(this); } + public static IntervalGuard lessGuard(SuffixValue param, SymbolicDataValue r) { + return new IntervalGuard(param, null, r, false, false); + } + + public static IntervalGuard lessOrEqualGuard(SuffixValue param, SymbolicDataValue r) { + return new IntervalGuard(param, null, r, false, true); + } + + public static IntervalGuard greaterGuard(SuffixValue param, SymbolicDataValue r) { + return new IntervalGuard(param, r, null, false, false); + } + + public static IntervalGuard greaterOrEqualGuard(SuffixValue param, SymbolicDataValue r) { + return new IntervalGuard(param, r, null, true, false); + } } diff --git a/src/main/java/de/learnlib/ralib/theory/inequality/LesserSuffixValue.java b/src/main/java/de/learnlib/ralib/theory/inequality/LesserSuffixValue.java new file mode 100644 index 00000000..576b4d7b --- /dev/null +++ b/src/main/java/de/learnlib/ralib/theory/inequality/LesserSuffixValue.java @@ -0,0 +1,66 @@ +package de.learnlib.ralib.theory.inequality; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import de.learnlib.ralib.automata.guards.AtomicGuardExpression; +import de.learnlib.ralib.automata.guards.Conjunction; +import de.learnlib.ralib.automata.guards.GuardExpression; +import de.learnlib.ralib.automata.guards.Relation; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.theory.FreshSuffixValue; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; +import de.learnlib.ralib.theory.equality.EqualRestriction; + +public class LesserSuffixValue extends SuffixValueRestriction { + + public LesserSuffixValue(SuffixValue param) { + super(param); + } + + public LesserSuffixValue(LesserSuffixValue other, int shift) { + super(other, shift); + } + + @Override + public SuffixValueRestriction shift(int shiftStep) { + return new LesserSuffixValue(this, shiftStep); + } + + @Override + public GuardExpression toGuardExpression(Set vals) { + List expr = new ArrayList<>(); + for (SymbolicDataValue sdv : vals) { + GuardExpression g = new AtomicGuardExpression(parameter, Relation.SMALLER, sdv); + return g; + } + GuardExpression exprArr[] = new GuardExpression[expr.size()]; + exprArr = expr.toArray(exprArr); + return new Conjunction(exprArr); + } + + @Override + public SuffixValueRestriction merge(SuffixValueRestriction other, Map prior) { + if (other instanceof LesserSuffixValue || other instanceof FreshSuffixValue) { + return this; + } + if (other instanceof GreaterSuffixValue || other instanceof EqualRestriction) { + return new UnrestrictedSuffixValue(parameter); + } + return other.merge(other, prior); + } + + @Override + public boolean revealsRegister(SymbolicDataValue r) { + return false; + } + + @Override + public String toString() { + return "Lesser(" + parameter.toString() + ")"; + } +} diff --git a/src/main/java/de/learnlib/ralib/tools/IOSimulator.java b/src/main/java/de/learnlib/ralib/tools/IOSimulator.java index d9992c72..b119157d 100644 --- a/src/main/java/de/learnlib/ralib/tools/IOSimulator.java +++ b/src/main/java/de/learnlib/ralib/tools/IOSimulator.java @@ -199,7 +199,7 @@ public void setup(Configuration config) throws ConfigurationException { } Measurements measurements = new Measurements(); - MeasuringOracle mto = new MeasuringOracle(new MultiTheoryTreeOracle(ioOracle, teachers, consts, solver), measurements); + MeasuringOracle mto = new MeasuringOracle(ioOracle, teachers, consts, solver, measurements); MultiTheorySDTLogicOracle mlo = new MultiTheorySDTLogicOracle(consts, solver); final long timeout = this.timeoutMillis; diff --git a/src/main/java/de/learnlib/ralib/tools/theories/DoubleInequalityTheory.java b/src/main/java/de/learnlib/ralib/tools/theories/DoubleInequalityTheory.java index 4b69df79..de460b94 100644 --- a/src/main/java/de/learnlib/ralib/tools/theories/DoubleInequalityTheory.java +++ b/src/main/java/de/learnlib/ralib/tools/theories/DoubleInequalityTheory.java @@ -249,4 +249,21 @@ public Collection> getAllNextValues( return nextValues; } + @Override + protected Comparator> getComparator() { + return new Comparator>() { + @Override + public int compare(DataValue d1, DataValue d2) { + return d1.getId().compareTo(d2.getId()); + } + }; + } + + @Override + protected DataValue safeCast(DataValue dv) { + if (dv.getId() instanceof BigDecimal) { + return new DataValue(dv.getType(), (BigDecimal) dv.getId()); + } + return null; + } } diff --git a/src/main/java/de/learnlib/ralib/tools/theories/UniqueIntegerEqualityTheory.java b/src/main/java/de/learnlib/ralib/tools/theories/UniqueIntegerEqualityTheory.java index 2b199f18..ed0e9aa6 100644 --- a/src/main/java/de/learnlib/ralib/tools/theories/UniqueIntegerEqualityTheory.java +++ b/src/main/java/de/learnlib/ralib/tools/theories/UniqueIntegerEqualityTheory.java @@ -3,12 +3,20 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.Map; +import de.learnlib.ralib.data.Constants; import de.learnlib.ralib.data.DataType; import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.oracles.io.IOOracle; +import de.learnlib.ralib.theory.SDTGuard; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; import de.learnlib.ralib.theory.equality.UniqueEqualityTheory; import de.learnlib.ralib.tools.classanalyzer.TypedTheory; +import de.learnlib.ralib.words.PSymbolInstance; +import net.automatalib.word.Word; public class UniqueIntegerEqualityTheory extends UniqueEqualityTheory implements TypedTheory { @@ -55,4 +63,21 @@ public Collection> getAllNextValues( ret.add(getFreshValue(vals)); return ret; } + + @Override + public SuffixValueRestriction restrictSuffixValue(SuffixValue suffixValue, Word prefix, + Word suffix, Constants consts) { + return new UnrestrictedSuffixValue(suffixValue); + } + + @Override + public SuffixValueRestriction restrictSuffixValue(SDTGuard guard, Map prior) { + return new UnrestrictedSuffixValue(guard.getParameter()); + } + +// @Override +// public boolean guardRevealsRegister(SDTGuard guard, SymbolicDataValue register) { +// // not yet implemented for inequality theory +// return false; +// } } diff --git a/src/main/java/de/learnlib/ralib/words/DataWords.java b/src/main/java/de/learnlib/ralib/words/DataWords.java index 58362467..62918c1c 100644 --- a/src/main/java/de/learnlib/ralib/words/DataWords.java +++ b/src/main/java/de/learnlib/ralib/words/DataWords.java @@ -19,6 +19,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Iterator; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -31,6 +32,7 @@ import de.learnlib.ralib.data.ParValuation; import de.learnlib.ralib.data.SymbolicDataValue.Parameter; import de.learnlib.ralib.data.SymbolicDataValue.Register; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.data.VarValuation; import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.ParameterGenerator; import net.automatalib.word.Word; @@ -79,6 +81,23 @@ public static DataValue[] valsOf(Word word) { return vals; } + /** + * returns a sequence of all data types in a data word + * + * @param word + * @return + */ + public static DataType[] typesOf(Word word) { + DataType[] types = new DataType[DataWords.paramLength(word)]; + int i = 0; + for (ParameterizedSymbol ps : word) { + for (DataType t : ps.getPtypes()) { + types[i++] = t; + } + } + return types; + } + /** * returns set of unique data values of some type in a data word. * @@ -167,6 +186,22 @@ public static Word instantiate( return Word.fromSymbols(symbols); } + public static Word instantiate( + Word actions, + Collection suffixValues) { + PSymbolInstance[] symbols = new PSymbolInstance[actions.length()]; + int idx = 0; + Iterator svit = suffixValues.iterator(); + for (ParameterizedSymbol ps : actions) { + DataValue[] pvalues = new DataValue[ps.getArity()]; + for (int i = 0; i < ps.getArity(); i++) { + pvalues[i] = svit.next(); + } + symbols[idx++] = new PSymbolInstance(ps, pvalues); + } + return Word.fromSymbols(symbols); + } + /** * instantiates a data word from a sequence of actions and * a valuation. diff --git a/src/test/java/de/learnlib/ralib/RaLibLearningExperimentRunner.java b/src/test/java/de/learnlib/ralib/RaLibLearningExperimentRunner.java index 1a6c6bc7..d7feb3ea 100644 --- a/src/test/java/de/learnlib/ralib/RaLibLearningExperimentRunner.java +++ b/src/test/java/de/learnlib/ralib/RaLibLearningExperimentRunner.java @@ -24,7 +24,6 @@ import de.learnlib.ralib.oracles.DataWordOracle; import de.learnlib.ralib.oracles.TreeOracleFactory; import de.learnlib.ralib.oracles.mto.MultiTheorySDTLogicOracle; -import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; import de.learnlib.ralib.solver.ConstraintSolver; import de.learnlib.ralib.theory.Theory; import de.learnlib.ralib.words.PSymbolInstance; @@ -113,7 +112,7 @@ public Hypothesis run(RaLearningAlgorithmName algorithmName, DataWordOracle data logger.log(Level.INFO, "SEED={0}", seed); Random random = new Random(seed); CacheDataWordOracle ioCache = new CacheDataWordOracle(dataOracle); - MeasuringOracle mto = new MeasuringOracle(new MultiTheoryTreeOracle(ioCache, teachers, consts, solver), measures); + MeasuringOracle mto = new MeasuringOracle(ioCache, teachers, consts, solver, measures); MultiTheorySDTLogicOracle mlo = new MultiTheorySDTLogicOracle(consts, solver); diff --git a/src/test/java/de/learnlib/ralib/example/sdts/SDTOracle.java b/src/test/java/de/learnlib/ralib/example/sdts/SDTOracle.java new file mode 100644 index 00000000..e40098bd --- /dev/null +++ b/src/test/java/de/learnlib/ralib/example/sdts/SDTOracle.java @@ -0,0 +1,93 @@ +package de.learnlib.ralib.example.sdts; + +import java.util.Collection; + +import de.learnlib.query.Query; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.Mapping; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.oracles.DataWordOracle; +import de.learnlib.ralib.oracles.mto.SDT; +import de.learnlib.ralib.words.DataWords; +import de.learnlib.ralib.words.PSymbolInstance; +import net.automatalib.word.Word; + +public class SDTOracle implements DataWordOracle { + + private SDT sdt = null; + private Mapping> registerMapping = null; + private Constants consts = new Constants(); + + public SDTOracle() { + } + + public SDTOracle(SDT sdt, Mapping> registerMapping, Constants consts) { + this.sdt = sdt; + this.registerMapping = registerMapping; + this.consts = consts; + } + + public SDTOracle(SDT sdt, Mapping> registerMapping) { + this(sdt, registerMapping, new Constants()); + } + + public void changeSDT(SDT sdt, Mapping> registerMapping, Constants consts) { + this.sdt = sdt; + this.registerMapping = registerMapping; + this.consts = consts; + } + + public void changeSDT(SDT sdt, Mapping> registerMapping) { + changeSDT(sdt, registerMapping, new Constants()); + } + + @Override + public void processQueries(Collection> queries) { + for (Query query : queries) { + if (sdt == null) { + query.answer(false); + } + else { + Word suffix = computeSuffix(query.getInput()); + Mapping> vals = computeMapping(suffix); + boolean answer = sdt.isAccepting(vals, consts); + query.answer(sdt.isAccepting(vals, consts)); + } + } + } + + private Mapping> computeMapping(Word suffix) { + Mapping> mapping = new Mapping>(); + int index = 1; + for (PSymbolInstance psi : suffix) { + DataType[] dts = psi.getBaseSymbol().getPtypes(); + DataValue[] dvs = psi.getParameterValues(); + for (int i = 0; i < dts.length; i++) { + SuffixValue sv = new SuffixValue(dts[i], index); + mapping.put(sv, dvs[i]); + index++; + } + } + mapping.putAll(registerMapping); + return mapping; + } + + private Word computeSuffix(Word word) { + int variables = sdt.getSuffixValues().size(); + int params = DataWords.paramValLength(word); + if (params < variables) + throw new java.lang.IllegalArgumentException("Invalid parameter length"); + int n = word.length(); + while (params > variables) { + n--; + params = params - word.getSymbol(n).getBaseSymbol().getArity(); + } + Word suffix = word.suffix(n); + if (DataWords.paramValLength(suffix) != variables) + throw new java.lang.IllegalArgumentException("Invalid parameter length"); + return suffix; + } +} diff --git a/src/test/java/de/learnlib/ralib/learning/SymbolicSuffixTest.java b/src/test/java/de/learnlib/ralib/learning/SymbolicSuffixTest.java index 26332438..f902b77f 100644 --- a/src/test/java/de/learnlib/ralib/learning/SymbolicSuffixTest.java +++ b/src/test/java/de/learnlib/ralib/learning/SymbolicSuffixTest.java @@ -2,6 +2,7 @@ import java.util.LinkedHashMap; import java.util.LinkedHashSet; +import java.util.Map; import org.testng.Assert; import org.testng.annotations.Test; @@ -13,6 +14,10 @@ import de.learnlib.ralib.data.DataType; import de.learnlib.ralib.data.DataValue; import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; +import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.tools.classanalyzer.TypedTheory; +import de.learnlib.ralib.tools.theories.IntegerEqualityTheory; import de.learnlib.ralib.words.DataWords; import de.learnlib.ralib.words.InputSymbol; import de.learnlib.ralib.words.OutputSymbol; @@ -33,6 +38,15 @@ public void concatTest() { Constants consts = loader.getConstants(); + final Map teachers = new LinkedHashMap<>(); + loader.getDataTypes().stream().forEach((t) -> { + TypedTheory theory = new IntegerEqualityTheory(t); + theory.setUseSuffixOpt(true); + teachers.put(t, theory); + }); + + SymbolicSuffixRestrictionBuilder restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, teachers); + DataType intType = TestUtil.getType("int", loader.getDataTypes()); ParameterizedSymbol iput = new InputSymbol( @@ -76,8 +90,8 @@ public void concatTest() { new PSymbolInstance(iget), new PSymbolInstance(oget,d0)); - SymbolicSuffix symSuffix1 = new SymbolicSuffix(prefix1, suffix1, consts); - SymbolicSuffix symSuffix2 = new SymbolicSuffix(prefix2, suffix2, consts); + SymbolicSuffix symSuffix1 = new SymbolicSuffix(prefix1, suffix1, restrictionBuilder); + SymbolicSuffix symSuffix2 = new SymbolicSuffix(prefix2, suffix2, restrictionBuilder); LinkedHashMap dataValues = new LinkedHashMap(); for (int i=1; i<=5; i++) { diff --git a/src/test/java/de/learnlib/ralib/learning/ralambda/GeneratedHypothesesTest.java b/src/test/java/de/learnlib/ralib/learning/ralambda/GeneratedHypothesesTest.java index c175b95c..aa4dca16 100644 --- a/src/test/java/de/learnlib/ralib/learning/ralambda/GeneratedHypothesesTest.java +++ b/src/test/java/de/learnlib/ralib/learning/ralambda/GeneratedHypothesesTest.java @@ -49,8 +49,7 @@ public void getHypothesisTest() { Measurements mes = new Measurements(); - MeasuringOracle mto = new MeasuringOracle(new MultiTheoryTreeOracle( - dwOracle, teachers, new Constants(), solver), mes); + MeasuringOracle mto = new MeasuringOracle(dwOracle, teachers, new Constants(), solver, mes); SDTLogicOracle slo = new MultiTheorySDTLogicOracle(consts, solver); diff --git a/src/test/java/de/learnlib/ralib/learning/ralambda/LearnLoginTest.java b/src/test/java/de/learnlib/ralib/learning/ralambda/LearnLoginTest.java index 4ba3e1f8..0969ea64 100644 --- a/src/test/java/de/learnlib/ralib/learning/ralambda/LearnLoginTest.java +++ b/src/test/java/de/learnlib/ralib/learning/ralambda/LearnLoginTest.java @@ -132,12 +132,12 @@ public void learnLoginRandomTest() { "[{TQ: 65, Resets: 2339, Inputs: 0}," + " {TQ: 65, Resets: 2313, Inputs: 0}," + " {TQ: 65, Resets: 2208, Inputs: 0}," + - " {TQ: 64, Resets: 2200, Inputs: 0}," + + " {TQ: 64, Resets: 2205, Inputs: 0}," + " {TQ: 65, Resets: 2136, Inputs: 0}," + " {TQ: 65, Resets: 2578, Inputs: 0}," + " {TQ: 65, Resets: 2315, Inputs: 0}," + " {TQ: 65, Resets: 2192, Inputs: 0}," + - " {TQ: 65, Resets: 3618, Inputs: 0}," + + " {TQ: 65, Resets: 3623, Inputs: 0}," + " {TQ: 65, Resets: 2059, Inputs: 0}]"); } diff --git a/src/test/java/de/learnlib/ralib/learning/ralambda/LearnPQTest.java b/src/test/java/de/learnlib/ralib/learning/ralambda/LearnPQTest.java index 0e36294b..4603534b 100644 --- a/src/test/java/de/learnlib/ralib/learning/ralambda/LearnPQTest.java +++ b/src/test/java/de/learnlib/ralib/learning/ralambda/LearnPQTest.java @@ -80,7 +80,6 @@ public void learnPQ() { new MultiTheoryTreeOracle(new SimulatorOracle(hyp), teachers, new Constants(), jsolv); RaLambda rastar = new RaLambda(mto, hypFactory, mlo, consts, OFFER, POLL); -// rastar.setUseOldAnalyzer(true); rastar.learn(); RegisterAutomaton hyp = rastar.getHypothesis(); logger.log(Level.FINE, "HYP1: {0}", hyp); @@ -136,7 +135,6 @@ public void learnPQRandom() { JConstraintsConstraintSolver jsolv = TestUtil.getZ3Solver(); RaLibLearningExperimentRunner runner = new RaLibLearningExperimentRunner(logger); runner.setMaxDepth(4); -// runner.setUseOldAnalyzer(true); Measurements[] ralambdaCount = new Measurements [SEEDS]; Measurements[] rastarCount = new Measurements [SEEDS]; @@ -151,7 +149,7 @@ public void learnPQRandom() { } // hard-coded results from first seed - Assert.assertEquals(Arrays.toString(ralambdaCount), "[{TQ: 82, Resets: 1989, Inputs: 0}]"); - Assert.assertEquals(Arrays.toString(rastarCount), "[{TQ: 71, Resets: 8321, Inputs: 0}]"); + Assert.assertEquals(Arrays.toString(ralambdaCount), "[{TQ: 71, Resets: 1946, Inputs: 0}]"); + Assert.assertEquals(Arrays.toString(rastarCount), "[{TQ: 71, Resets: 8357, Inputs: 0}]"); } } diff --git a/src/test/java/de/learnlib/ralib/learning/ralambda/LearnStackTest.java b/src/test/java/de/learnlib/ralib/learning/ralambda/LearnStackTest.java index 306225d4..cee869a7 100644 --- a/src/test/java/de/learnlib/ralib/learning/ralambda/LearnStackTest.java +++ b/src/test/java/de/learnlib/ralib/learning/ralambda/LearnStackTest.java @@ -60,8 +60,7 @@ public void learnStackTest() { Measurements mes = new Measurements(); - MeasuringOracle mto = new MeasuringOracle(new MultiTheoryTreeOracle( - dwOracle, teachers, new Constants(), solver), mes); + MeasuringOracle mto = new MeasuringOracle(dwOracle, teachers, new Constants(), solver, mes); SDTLogicOracle slo = new MultiTheorySDTLogicOracle(consts, solver); @@ -263,15 +262,15 @@ public void learnStackRandomTest() { " {TQ: 78, Resets: 2478, Inputs: 0}," + " {TQ: 44, Resets: 1139, Inputs: 0}]"); Assert.assertEquals(Arrays.toString(measuresStar), - "[{TQ: 51, Resets: 1582, Inputs: 0}," + + "[{TQ: 51, Resets: 1589, Inputs: 0}," + " {TQ: 50, Resets: 12577, Inputs: 0}," + " {TQ: 63, Resets: 1317, Inputs: 0}," + - " {TQ: 50, Resets: 10633, Inputs: 0}," + - " {TQ: 39, Resets: 10917, Inputs: 0}," + + " {TQ: 50, Resets: 10669, Inputs: 0}," + + " {TQ: 39, Resets: 11088, Inputs: 0}," + " {TQ: 62, Resets: 1310, Inputs: 0}," + " {TQ: 60, Resets: 1298, Inputs: 0}," + " {TQ: 49, Resets: 1207, Inputs: 0}," + - " {TQ: 53, Resets: 11290, Inputs: 0}," + + " {TQ: 53, Resets: 11461, Inputs: 0}," + " {TQ: 49, Resets: 1301, Inputs: 0}]"); } } diff --git a/src/test/java/de/learnlib/ralib/learning/ralambda/TestQueryCount.java b/src/test/java/de/learnlib/ralib/learning/ralambda/TestQueryCount.java index a1ddc725..29ee0f59 100644 --- a/src/test/java/de/learnlib/ralib/learning/ralambda/TestQueryCount.java +++ b/src/test/java/de/learnlib/ralib/learning/ralambda/TestQueryCount.java @@ -96,7 +96,7 @@ public void testQueryCount() { learner.learn(); long memQueries2 = learner.getQueryStatistics().getMemQueries(); - Assert.assertEquals(memQueries2, 36); + Assert.assertEquals(memQueries2, 27); Word ce3 = Word.fromSymbols( new PSymbolInstance(PriorityQueueSUL.OFFER, new DataValue(PriorityQueueSUL.DOUBLE_TYPE, BigDecimal.ONE)), @@ -114,6 +114,6 @@ public void testQueryCount() { learner.learn(); long memQueries3 = learner.getQueryStatistics().getMemQueries(); - Assert.assertEquals(memQueries3, 44); + Assert.assertEquals(memQueries3, 36); } } diff --git a/src/test/java/de/learnlib/ralib/learning/ralambda/TestSuffixOptimization.java b/src/test/java/de/learnlib/ralib/learning/ralambda/TestSuffixOptimization.java index 0392d782..fcb9db66 100644 --- a/src/test/java/de/learnlib/ralib/learning/ralambda/TestSuffixOptimization.java +++ b/src/test/java/de/learnlib/ralib/learning/ralambda/TestSuffixOptimization.java @@ -1,9 +1,13 @@ package de.learnlib.ralib.learning.ralambda; +import static de.learnlib.ralib.example.priority.PriorityQueueOracle.OFFER; +import static de.learnlib.ralib.example.priority.PriorityQueueOracle.POLL; +import static de.learnlib.ralib.example.priority.PriorityQueueOracle.doubleType; import static de.learnlib.ralib.example.repeater.RepeaterSUL.IPUT; import static de.learnlib.ralib.example.repeater.RepeaterSUL.OECHO; import static de.learnlib.ralib.example.repeater.RepeaterSUL.TINT; +import java.math.BigDecimal; import java.util.LinkedHashMap; import java.util.Map; @@ -11,7 +15,9 @@ import org.testng.annotations.Test; import de.learnlib.query.DefaultQuery; +import de.learnlib.ralib.CacheDataWordOracle; import de.learnlib.ralib.RaLibTestSuite; +import de.learnlib.ralib.TestUtil; import de.learnlib.ralib.automata.RegisterAutomaton; import de.learnlib.ralib.data.Constants; import de.learnlib.ralib.data.DataType; @@ -19,7 +25,10 @@ import de.learnlib.ralib.example.repeater.RepeaterSUL; import de.learnlib.ralib.learning.Hypothesis; import de.learnlib.ralib.learning.Measurements; +import de.learnlib.ralib.learning.MeasuringOracle; import de.learnlib.ralib.learning.QueryStatistics; +import de.learnlib.ralib.oracles.DataWordOracle; +import de.learnlib.ralib.oracles.SDTLogicOracle; import de.learnlib.ralib.oracles.SimulatorOracle; import de.learnlib.ralib.oracles.TreeOracleFactory; import de.learnlib.ralib.oracles.io.IOCache; @@ -28,9 +37,11 @@ import de.learnlib.ralib.oracles.mto.MultiTheorySDTLogicOracle; import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; import de.learnlib.ralib.solver.ConstraintSolver; +import de.learnlib.ralib.solver.jconstraints.JConstraintsConstraintSolver; import de.learnlib.ralib.solver.simple.SimpleConstraintSolver; import de.learnlib.ralib.sul.SULOracle; import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; import de.learnlib.ralib.tools.theories.IntegerEqualityTheory; import de.learnlib.ralib.words.PSymbolInstance; import net.automatalib.word.Word; @@ -94,4 +105,54 @@ public void learnRepeaterSuffixOptTest() { Assert.assertTrue(str.contains("Other: {TQ: 0, Resets: 1, Inputs: 1}")); Assert.assertTrue(str.contains("Total: {TQ: 0, Resets: 4, Inputs: 10}")); } + + @Test + public void learnPQSuffixOptTest() { + + Constants consts = new Constants(); + DataWordOracle dwOracle = + new de.learnlib.ralib.example.priority.PriorityQueueOracle(2); + CacheDataWordOracle ioCache = new CacheDataWordOracle(dwOracle); + + final Map teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(doubleType); + dit.useSuffixOptimization(true); + teachers.put(doubleType, dit); + + Measurements m = new Measurements(); + JConstraintsConstraintSolver jsolv = TestUtil.getZ3Solver(); + QueryStatistics stats = new QueryStatistics(m, ioCache); + MeasuringOracle mto = new MeasuringOracle(ioCache, teachers, new Constants(), jsolv, m); + + SDTLogicOracle mlo = new MultiTheorySDTLogicOracle(consts, jsolv); + + TreeOracleFactory hypFactory = (RegisterAutomaton hyp) -> + new MultiTheoryTreeOracle(new SimulatorOracle(hyp), teachers, new Constants(), jsolv); + + RaLambda learner = new RaLambda(mto, hypFactory, mlo, consts, OFFER, POLL); + learner.setSolver(jsolv); + learner.setStatisticCounter(stats); + learner.learn(); + + Word ce = Word.fromSymbols( + new PSymbolInstance(OFFER, new DataValue(doubleType, BigDecimal.ONE)), + new PSymbolInstance(OFFER, new DataValue(doubleType, BigDecimal.ZERO)), + new PSymbolInstance(POLL, new DataValue(doubleType, BigDecimal.ZERO)), + new PSymbolInstance(POLL, new DataValue(doubleType, BigDecimal.ONE))); + learner.addCounterexample(new DefaultQuery(ce, true)); + + learner.learn(); + Hypothesis hyp = learner.getHypothesis(); + + Assert.assertEquals(hyp.getStates().size(), 4); + Assert.assertEquals(hyp.getTransitions().size(), 11); + + String str = stats.toString(); + Assert.assertTrue(str.contains("Counterexamples: 1")); + Assert.assertTrue(str.contains("CE max length: 4")); + Assert.assertTrue(str.contains("CE Analysis: {TQ: 33, Resets: 339, Inputs: 0}")); + Assert.assertTrue(str.contains("Processing / Refinement: {TQ: 27, Resets: 815, Inputs: 0}")); + Assert.assertTrue(str.contains("Other: {TQ: 7, Resets: 7, Inputs: 0}")); + Assert.assertTrue(str.contains("Total: {TQ: 67, Resets: 1161, Inputs: 0}")); + } } diff --git a/src/test/java/de/learnlib/ralib/learning/rastar/LearnPQTest.java b/src/test/java/de/learnlib/ralib/learning/rastar/LearnPQTest.java index 511efc30..76172488 100644 --- a/src/test/java/de/learnlib/ralib/learning/rastar/LearnPQTest.java +++ b/src/test/java/de/learnlib/ralib/learning/rastar/LearnPQTest.java @@ -100,7 +100,7 @@ public void PQExample() { hyp = rastar.getHypothesis(); logger.log(Level.FINE, "HYP2: {0}", hyp); - Assert.assertEquals(hyp.getStates().size(), 7); - Assert.assertEquals(hyp.getTransitions().size(), 27); + Assert.assertEquals(hyp.getStates().size(), 9); + Assert.assertEquals(hyp.getTransitions().size(), 32); } } diff --git a/src/test/java/de/learnlib/ralib/oracles/mto/BranchMergingTest.java b/src/test/java/de/learnlib/ralib/oracles/mto/BranchMergingTest.java new file mode 100644 index 00000000..0f18970d --- /dev/null +++ b/src/test/java/de/learnlib/ralib/oracles/mto/BranchMergingTest.java @@ -0,0 +1,313 @@ +package de.learnlib.ralib.oracles.mto; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import de.learnlib.ralib.RaLibTestSuite; +import de.learnlib.ralib.TestUtil; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.Mapping; +import de.learnlib.ralib.data.PIV; +import de.learnlib.ralib.data.ParValuation; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.Parameter; +import de.learnlib.ralib.data.SymbolicDataValue.Register; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.VarMapping; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.ParameterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.RegisterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.example.sdts.SDTOracle; +import de.learnlib.ralib.learning.SymbolicDecisionTree; +import de.learnlib.ralib.learning.SymbolicSuffix; +import de.learnlib.ralib.oracles.TreeOracle; +import de.learnlib.ralib.oracles.TreeQueryResult; +import de.learnlib.ralib.solver.ConstraintSolver; +import de.learnlib.ralib.solver.ConstraintSolverFactory; +import de.learnlib.ralib.solver.jconstraints.JConstraintsConstraintSolver; +import de.learnlib.ralib.solver.jconstraints.JContraintsUtil; +import de.learnlib.ralib.theory.SDTAndGuard; +import de.learnlib.ralib.theory.SDTTrueGuard; +import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.theory.equality.DisequalityGuard; +import de.learnlib.ralib.theory.equality.EqualityGuard; +import de.learnlib.ralib.theory.inequality.IntervalGuard; +import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; +import de.learnlib.ralib.tools.theories.IntegerEqualityTheory; +import de.learnlib.ralib.words.DataWords; +import de.learnlib.ralib.words.InputSymbol; +import de.learnlib.ralib.words.PSymbolInstance; +import de.learnlib.ralib.words.ParameterizedSymbol; +import gov.nasa.jpf.constraints.api.Valuation; +import net.automatalib.word.Word; + +public class BranchMergingTest extends RaLibTestSuite { + + @Test + public void branchMergingEqTest() { + final DataType INT_TYPE = new DataType("int", Integer.class); + final InputSymbol A = new InputSymbol("a", new DataType[] {INT_TYPE}); + + SDTOracle oracle = new SDTOracle(); + final Map teachers = new LinkedHashMap<>(); + IntegerEqualityTheory dit = new IntegerEqualityTheory(INT_TYPE); + teachers.put(INT_TYPE, dit); + ConstraintSolver solver = ConstraintSolverFactory.createZ3ConstraintSolver(); + MultiTheoryTreeOracle mto = new MultiTheoryTreeOracle(oracle, teachers, new Constants(), solver); + + Constants consts = new Constants(); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + ParameterGenerator pgen = new ParameterGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(INT_TYPE); + SuffixValue s2 = svgen.next(INT_TYPE); + Parameter p1 = pgen.next(INT_TYPE); + Parameter p2 = pgen.next(INT_TYPE); + Register r1 = rgen.next(INT_TYPE); + Register r2 = rgen.next(INT_TYPE); + DataValue dv1 = new DataValue(INT_TYPE, 1); + DataValue dv2 = new DataValue(INT_TYPE, 2); + + // test 1 + Word prefix1 = Word.fromSymbols( + new PSymbolInstance(A, dv1), + new PSymbolInstance(A, dv2)); + Word suffixActions1 = Word.fromSymbols(A, A); + SymbolicSuffix suffix1 = new SymbolicSuffix(suffixActions1); + + Word prefix2 = Word.fromSymbols( + new PSymbolInstance(A, dv1), + new PSymbolInstance(A, dv2)); + Word suffixActions2 = Word.fromSymbols(A); + SymbolicSuffix suffix2 = new SymbolicSuffix(suffixActions2); + + PIV piv1 = new PIV(); + piv1.put(p1, r1); + piv1.put(p2, r2); + Mapping> vals1 = new Mapping>(); + vals1.put(r1, dv1); + vals1.put(r2, dv2); + + SDT sdt1 = new SDT(Map.of( + new EqualityGuard(s1, r1), new SDT(Map.of( + new SDTTrueGuard(s2), SDTLeaf.ACCEPTING)), + new EqualityGuard(s1, r2), new SDT(Map.of( + new EqualityGuard(s2, r1), SDTLeaf.REJECTING, + new DisequalityGuard(s2, r1), SDTLeaf.ACCEPTING)), + new SDTAndGuard(s1, new DisequalityGuard(s1, r1), new DisequalityGuard(s1, r2)), new SDT(Map.of( + new SDTTrueGuard(s2), SDTLeaf.REJECTING)))); + + SDT sdt2 = new SDT(Map.of( + new EqualityGuard(s1, r1), SDTLeaf.ACCEPTING, + new EqualityGuard(s1, r2), SDTLeaf.ACCEPTING, + new SDTAndGuard(s1, new DisequalityGuard(s1, r1), new DisequalityGuard(s1, r2)), SDTLeaf.REJECTING)); + + oracle.changeSDT(sdt1, vals1, consts); + SymbolicDecisionTree actualSDT1 = mto.treeQuery(prefix1, suffix1).getSdt(); + Assert.assertTrue(actualSDT1.isEquivalent(sdt1, new VarMapping())); + + oracle.changeSDT(sdt2, vals1); + SymbolicDecisionTree actualSDT2 = mto.treeQuery(prefix2, suffix2).getSdt(); + Assert.assertTrue(actualSDT2.isEquivalent(sdt2, new VarMapping())); + } + + @Test + public void branchMergingIneqTest() { + final DataType D_TYPE = new DataType("double", BigDecimal.class); + final InputSymbol A = new InputSymbol("a", new DataType[] {D_TYPE}); + + SDTOracle oracle = new SDTOracle(); + final Map teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + teachers.put(D_TYPE, dit); + + Constants consts = new Constants(); + JConstraintsConstraintSolver solver = TestUtil.getZ3Solver(); + MultiTheoryTreeOracle mto = new MultiTheoryTreeOracle(oracle, teachers, consts, solver); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + ParameterGenerator pgen = new ParameterGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(D_TYPE); + SuffixValue s2 = svgen.next(D_TYPE); + Parameter p1 = pgen.next(D_TYPE); + Parameter p2 = pgen.next(D_TYPE); + Parameter p3 = pgen.next(D_TYPE); + Register r1 = rgen.next(D_TYPE); + Register r2 = rgen.next(D_TYPE); + Register r3 = rgen.next(D_TYPE); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + + // test 1 + Word prefix1 = Word.fromSymbols(new PSymbolInstance(A, dv1)); + Word suffixActions1 = Word.fromSymbols(A, A); + SymbolicSuffix suffix1 = new SymbolicSuffix(suffixActions1); + + Word prefix2 = Word.fromSymbols( + new PSymbolInstance(A, dv1), + new PSymbolInstance(A, dv2)); + Word suffixActions2 = Word.fromSymbols(A); + SymbolicSuffix suffix2 = new SymbolicSuffix(suffixActions2); + + PIV piv1 = new PIV(); + piv1.put(p1, r1); + Mapping> vals1 = new Mapping>(); + vals1.put(r1, dv1); + PIV piv2 = new PIV(); + piv2.put(p1, r1); + piv2.put(p2, r2); + Mapping> vals2 = new Mapping>(); + vals2.put(r1, dv1); + vals2.put(r2, dv2); + + SDT sdt1 = new SDT(Map.of( + new SDTTrueGuard(s1), new SDT(Map.of( + new SDTAndGuard(s2, + new IntervalGuard(s2, s1, null), + new DisequalityGuard(s2, r1)), + SDTLeaf.ACCEPTING, + new IntervalGuard(s2, null, s1), SDTLeaf.REJECTING, + new DisequalityGuard(s2, s1), SDTLeaf.REJECTING, + new EqualityGuard(s2, r1), SDTLeaf.REJECTING)))); + + SDT sdt2 = new SDT(Map.of( + new EqualityGuard(s1, r1), SDTLeaf.ACCEPTING, + new EqualityGuard(s1, r2), SDTLeaf.ACCEPTING, + new SDTAndGuard(s1, new DisequalityGuard(s1, r1), new DisequalityGuard(s1, r2)), SDTLeaf.REJECTING)); + + oracle.changeSDT(sdt1, vals1); + TreeQueryResult tqr1 = mto.treeQuery(prefix1, suffix1); + SDT actualSdt1 = (SDT)mto.treeQuery(prefix1, suffix1).getSdt(); + + oracle.changeSDT(sdt2, vals2); + TreeQueryResult tqr2 = mto.treeQuery(prefix2, suffix2); + SDT actualSdt2 = (SDT)tqr2.getSdt(); + + Assert.assertTrue(semanticallyEquivalent(actualSdt1, tqr1.getPiv(), (SDT)sdt1, piv1, mto, prefix1, suffix1, dit, D_TYPE)); + Assert.assertTrue(semanticallyEquivalent(actualSdt2, tqr2.getPiv(), (SDT)sdt2, piv2, mto, prefix2, suffix2, dit, D_TYPE)); + } + + private boolean semanticallyEquivalent(SDT sdt1, PIV piv1, SDT sdt2, PIV piv2, + TreeOracle oracle, Word prefix, SymbolicSuffix suffix, + DoubleInequalityTheory theory, DataType type) { + Constants consts = new Constants(); + Set> prefixValsCast = new LinkedHashSet<>(); + List> prefixVals = new ArrayList<>(); + ParValuation prefixPars = DataWords.computeParValuation(prefix); + for (DataValue dv : prefixPars.values()) { + if (dv.getId() instanceof BigDecimal) + prefixValsCast.add(new DataValue(dv.getType(), (BigDecimal)dv.getId())); + } + prefixVals.addAll(prefixValsCast); + prefixVals.sort((DataValue d1, DataValue d2) -> d1.getId().compareTo(d2.getId())); + Set>> equivClasses = genIneqEquiv( + prefixVals, + new Mapping>(), + 1, suffix.getValues().size(), + theory, type); + + Mapping> regMap1 = getRegisterVals(prefixPars, piv1); + Mapping> regMap2 = getRegisterVals(prefixPars, piv2); + + for (Mapping> ec : equivClasses) { + Mapping> mapping1 = new Mapping<>(); + Mapping> mapping2 = new Mapping<>(); + mapping1.putAll(ec); + mapping2.putAll(ec); + mapping1.putAll(regMap1); + mapping2.putAll(regMap2); + + boolean o1 = sdt1.isAccepting(mapping1, consts); + boolean o2 = sdt2.isAccepting(mapping2, consts); + if (o1 != o2) + return false; + } + return true; + } + + private Set>> genIneqEquiv(List> prefixVals, + Mapping> prior, + int idx, int suffixValues, + DoubleInequalityTheory theory, DataType type) { + Set>> ret = new LinkedHashSet<>(); + SuffixValue sv = new SuffixValue(type, idx); + + Set> potSet = new LinkedHashSet<>(); + List> potential = new ArrayList<>(); + potSet.addAll(prefixVals); + potSet.addAll(prior.values()); + potential.addAll(potSet); + potential.sort((DataValue d1, DataValue d2) -> d1.getId().compareTo(d2.getId())); + List> intervals = generateInterval(potential, theory, type); + + for (DataValue dv : intervals) { + Mapping> mapping = new Mapping<>(); + mapping.putAll(prior); + mapping.put(sv, dv); + if (idx == suffixValues) { + ret.add(mapping); + } else { + ret.addAll(genIneqEquiv(prefixVals, mapping, idx+1, suffixValues, theory, type)); + } + } + return ret; + } + + private List> generateInterval(List> potential, DoubleInequalityTheory theory, DataType type) { + int n = potential.size(); + ArrayList> intervals = new ArrayList<>(2*n+1); + Constants consts = new Constants(); + Register r1 = new Register(type, 1); + Register r2 = new Register(type, 2); + SuffixValue sv = new SuffixValue(type, 1); + IntervalGuard sg = new IntervalGuard(sv, null, r1); + IntervalGuard ig = new IntervalGuard(sv, r1, r2); + IntervalGuard gg = new IntervalGuard(sv, r2, null); + + Valuation valLeast = new Valuation(); + valLeast.setValue(JContraintsUtil.toVariable(r1), potential.get(0).getId()); + intervals.add(theory.instantiate(sg, valLeast, consts, intervals)); + + for (int i = 0; i < n-1; i++) { + intervals.add(potential.get(i)); + + Valuation val = new Valuation(); + val.setValue(JContraintsUtil.toVariable(r1), potential.get(i).getId()); + val.setValue(JContraintsUtil.toVariable(r2), potential.get(i+1).getId()); + intervals.add(theory.instantiate(ig, val, consts, intervals)); + } + intervals.add(potential.get(n-1)); + + Valuation valGreatest = new Valuation(); + valGreatest.setValue(JContraintsUtil.toVariable(r2), potential.get(n-1).getId()); + intervals.add(theory.instantiate(gg, valGreatest, consts, intervals)); + + return intervals; + } + + private Mapping> getRegisterVals(ParValuation pars, PIV piv) { + Mapping> mapping = new Mapping<>(); + for (Map.Entry e : piv.entrySet()) { + DataValue val = pars.get(e.getKey()); + if (val != null && val.getId() instanceof BigDecimal) { + mapping.put(e.getValue(), new DataValue(val.getType(), (BigDecimal)val.getId())); + } + } + return mapping; + } +} diff --git a/src/test/java/de/learnlib/ralib/oracles/mto/EquivClassGenerationTest.java b/src/test/java/de/learnlib/ralib/oracles/mto/EquivClassGenerationTest.java new file mode 100644 index 00000000..c3a4a391 --- /dev/null +++ b/src/test/java/de/learnlib/ralib/oracles/mto/EquivClassGenerationTest.java @@ -0,0 +1,134 @@ +package de.learnlib.ralib.oracles.mto; + +import java.math.BigDecimal; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import de.learnlib.ralib.RaLibTestSuite; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.PIV; +import de.learnlib.ralib.data.SuffixValuation; +import de.learnlib.ralib.data.SymbolicDataValue; +import de.learnlib.ralib.data.SymbolicDataValue.Parameter; +import de.learnlib.ralib.data.SymbolicDataValue.Register; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.ParameterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.RegisterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.learning.SymbolicSuffix; +import de.learnlib.ralib.theory.FreshSuffixValue; +import de.learnlib.ralib.theory.SDTGuard; +import de.learnlib.ralib.theory.SDTTrueGuard; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; +import de.learnlib.ralib.theory.equality.EqualRestriction; +import de.learnlib.ralib.theory.equality.EqualityGuard; +import de.learnlib.ralib.theory.inequality.IntervalGuard; +import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; +import de.learnlib.ralib.words.InputSymbol; +import de.learnlib.ralib.words.PSymbolInstance; +import de.learnlib.ralib.words.ParameterizedSymbol; +import net.automatalib.word.Word; + +public class EquivClassGenerationTest extends RaLibTestSuite { + + // TODO: add similar test for equality theory + + @Test + public void eqcGenIneqTheoryTest() { + final DataType D_TYPE = new DataType("double", BigDecimal.class); + final InputSymbol A = new InputSymbol("a", new DataType[] {D_TYPE}); + + final Map> teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + dit.useSuffixOptimization(true); + teachers.put(D_TYPE, dit); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + ParameterGenerator pgen = new ParameterGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(D_TYPE); + SuffixValue s2 = svgen.next(D_TYPE); + Parameter p1 = pgen.next(D_TYPE); + Parameter p2 = pgen.next(D_TYPE); + Register r1 = rgen.next(D_TYPE); + Register r2 = rgen.next(D_TYPE); + + Constants consts = new Constants(); + PIV piv = new PIV(); + piv.put(p1, r1); + piv.put(p2, r2); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + DataValue dv4 = new DataValue(D_TYPE, BigDecimal.valueOf(4)); + DataValue dv5 = new DataValue(D_TYPE, BigDecimal.valueOf(5)); + DataValue dv6 = new DataValue(D_TYPE, BigDecimal.valueOf(6)); + + Word prefix1 = Word.fromSymbols( + new PSymbolInstance(A, dv3), + new PSymbolInstance(A, dv5)); + Word suffixActions1 = Word.fromSymbols(A, A); + + Map restr1 = new LinkedHashMap<>(); + restr1.put(s1, new UnrestrictedSuffixValue(s1)); + restr1.put(s2, new UnrestrictedSuffixValue(s2)); + SymbolicSuffix suffix1 = new SymbolicSuffix(suffixActions1, restr1); + + Map, SymbolicDataValue> potValuation1 = new LinkedHashMap<>(); + potValuation1.put(dv1, s1); + potValuation1.put(dv3, r1); + potValuation1.put(dv5, r2); + SuffixValuation suffixVals1 = new SuffixValuation(); + suffixVals1.put(s1, dv1); + + Map, SDTGuard> valueGuardsExpected1 = new LinkedHashMap<>(); + valueGuardsExpected1.put(dv0, new IntervalGuard(s2, null, s1)); + valueGuardsExpected1.put(dv1, new EqualityGuard(s2, s1)); + valueGuardsExpected1.put(dv2, new IntervalGuard(s2, s1, r1)); + valueGuardsExpected1.put(dv3, new EqualityGuard(s2, r1)); + valueGuardsExpected1.put(dv4, new IntervalGuard(s2, r1, r2)); + valueGuardsExpected1.put(dv5, new EqualityGuard(s2, r2)); + valueGuardsExpected1.put(dv6, new IntervalGuard(s2, r2, null)); + Map, SDTGuard> valueGuardsActual1 = dit.equivalenceClasses(prefix1, suffix1, s2, potValuation1, suffixVals1, consts); + + Assert.assertEquals(valueGuardsActual1.size(), valueGuardsExpected1.size()); + Assert.assertTrue(valueGuardsActual1.entrySet().containsAll(valueGuardsExpected1.entrySet())); + + Word prefix2 = prefix1; + Word suffixActions2 = suffixActions1; + Map restr2 = new LinkedHashMap<>(); + // TODO: change s1 from fresh to greatest? + restr2.put(s1, new FreshSuffixValue(s1)); + restr2.put(s2, new EqualRestriction(s2, s1)); + SymbolicSuffix suffix2 = new SymbolicSuffix(suffixActions2, restr2); + Map, SymbolicDataValue> potValuation2 = potValuation1; + SuffixValuation suffixVals2 = suffixVals1; + + Map, SDTGuard> valueGuardsExpected2 = new LinkedHashMap<>(); + valueGuardsExpected2.put(dv1, new EqualityGuard(s2, s1)); + Map, SDTGuard> valueGuardsActual2 = dit.equivalenceClasses(prefix2, suffix2, s2, potValuation2, suffixVals2, consts); + + Assert.assertEquals(valueGuardsActual2.size(), valueGuardsExpected2.size()); + Assert.assertTrue(valueGuardsActual2.entrySet().containsAll(valueGuardsExpected2.entrySet())); + + // empty potential test + Word prefix3 = Word.epsilon(); + Word suffixActions3 = Word.fromSymbols(A); + SymbolicSuffix suffix3 = new SymbolicSuffix(suffixActions3); + + Map, SDTGuard> valueGuardsActual3 = dit.equivalenceClasses(prefix3, suffix3, s1, new LinkedHashMap<>(), new SuffixValuation(), consts); + + Assert.assertEquals(valueGuardsActual3.size(), 1); + Assert.assertTrue(valueGuardsActual3.containsValue(new SDTTrueGuard(s1))); + } +} diff --git a/src/test/java/de/learnlib/ralib/oracles/mto/NonFreeSuffixValuesTest.java b/src/test/java/de/learnlib/ralib/oracles/mto/NonFreeSuffixValuesTest.java index 3c148a30..96e94f5d 100644 --- a/src/test/java/de/learnlib/ralib/oracles/mto/NonFreeSuffixValuesTest.java +++ b/src/test/java/de/learnlib/ralib/oracles/mto/NonFreeSuffixValuesTest.java @@ -80,6 +80,7 @@ public void testModelswithOutputFifo() { theory.setUseSuffixOpt(true); teachers.put(t, theory); }); + SymbolicSuffixRestrictionBuilder restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, teachers); DataWordSUL sul = new SimulatorSUL(model, teachers, consts); MultiTheoryTreeOracle mto = TestUtil.createMTO(sul, ERROR, @@ -127,7 +128,7 @@ public void testModelswithOutputFifo() { new PSymbolInstance(iget), new PSymbolInstance(oget,d0)); - SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, consts); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix, restrictionBuilder); String expectedTree = "[r1, r2]-+\n" + " []-TRUE: s1\n" + @@ -171,6 +172,7 @@ public void testModelswithOutputPalindrome() { loader.getDataTypes().stream().forEach((t) -> { teachers.put(t, new IntegerEqualityTheory(t)); }); + SymbolicSuffixRestrictionBuilder restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, teachers); DataWordSUL sul = new SimulatorSUL(model, teachers, consts); MultiTheoryTreeOracle mto = TestUtil.createMTO(sul, ERROR, @@ -205,7 +207,7 @@ public void testModelswithOutputPalindrome() { new PSymbolInstance(i4, d4, d5, d6, d7), new PSymbolInstance(oyes)); - SymbolicSuffix symSuffix = new SymbolicSuffix(prefix2, suffix, consts); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix2, suffix, restrictionBuilder); String expectedTree = "[]-+\n" + @@ -231,6 +233,7 @@ public void testNonFreeNonFresh() { IntegerEqualityTheory theory = new IntegerEqualityTheory(TINT); theory.setUseSuffixOpt(true); teachers.put(TINT, theory); + SymbolicSuffixRestrictionBuilder restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, teachers); RepeaterSUL sul = new RepeaterSUL(-1, 2); IOOracle ioOracle = new SULOracle(sul, RepeaterSUL.ERROR); @@ -250,7 +253,7 @@ public void testNonFreeNonFresh() { new PSymbolInstance(IPUT, new DataValue(TINT, 2)), new PSymbolInstance(OECHO, new DataValue(TINT, 2))); - SymbolicSuffix suffix = new SymbolicSuffix(word.prefix(2), word.suffix(4)); + SymbolicSuffix suffix = new SymbolicSuffix(word.prefix(2), word.suffix(4), restrictionBuilder); Assert.assertTrue(suffix.getFreeValues().isEmpty()); String expectedTree = "[]-+\n" + diff --git a/src/test/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilderTest.java b/src/test/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilderTest.java index c7366e46..591de36e 100644 --- a/src/test/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilderTest.java +++ b/src/test/java/de/learnlib/ralib/oracles/mto/OptimizedSymbolicSuffixBuilderTest.java @@ -11,6 +11,7 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Set; import org.testng.Assert; import org.testng.annotations.Test; @@ -35,12 +36,16 @@ import de.learnlib.ralib.solver.ConstraintSolver; import de.learnlib.ralib.solver.ConstraintSolverFactory; import de.learnlib.ralib.solver.simple.SimpleConstraintSolver; +import de.learnlib.ralib.theory.FreshSuffixValue; import de.learnlib.ralib.theory.SDTAndGuard; import de.learnlib.ralib.theory.SDTGuard; import de.learnlib.ralib.theory.SDTOrGuard; import de.learnlib.ralib.theory.SDTTrueGuard; +import de.learnlib.ralib.theory.SuffixValueRestriction; import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; import de.learnlib.ralib.theory.equality.DisequalityGuard; +import de.learnlib.ralib.theory.equality.EqualRestriction; import de.learnlib.ralib.theory.equality.EqualityGuard; import de.learnlib.ralib.tools.theories.IntegerEqualityTheory; import de.learnlib.ralib.words.InputSymbol; @@ -61,6 +66,8 @@ public void extendDistinguishingSuffixTest() { Constants consts = new Constants(); + SymbolicSuffixRestrictionBuilder restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, teachers); + Word word = Word.fromSymbols( new PSymbolInstance(PUSH, dv(1)), new PSymbolInstance(INSERT, dv(1),dv(2)), @@ -73,7 +80,7 @@ public void extendDistinguishingSuffixTest() { InputSymbol B = new InputSymbol("b"); InputSymbol C = new InputSymbol("c", INT_TYPE); - OptimizedSymbolicSuffixBuilder builder = new OptimizedSymbolicSuffixBuilder(consts); + OptimizedSymbolicSuffixBuilder builder = new OptimizedSymbolicSuffixBuilder(consts, restrictionBuilder); SuffixValueGenerator svGen = new SuffixValueGenerator(); SuffixValue s1 = svGen.next(INT_TYPE); @@ -107,6 +114,7 @@ public void extendDistinguishingSuffixTest() { Constants consts2 = new Constants(); consts2.put(c1, new DataValue(INT_TYPE, 2)); + SymbolicSuffixRestrictionBuilder restrictionBuilder2 = new SymbolicSuffixRestrictionBuilder(consts2, teachers); Word word1 = Word.fromSymbols( new PSymbolInstance(A, new DataValue(INT_TYPE, 0), new DataValue(INT_TYPE, 0)), @@ -159,14 +167,14 @@ public void extendDistinguishingSuffixTest() { new PSymbolInstance(C, new DataValue(INT_TYPE, 0)), new PSymbolInstance(C, new DataValue(INT_TYPE, 0)), new PSymbolInstance(C, new DataValue(INT_TYPE, 0))); - SymbolicSuffix suffix1 = new SymbolicSuffix(word1.prefix(2), word1.suffix(1)); - SymbolicSuffix suffix2 = new SymbolicSuffix(word2.prefix(2), word2.suffix(1)); - SymbolicSuffix suffix3 = new SymbolicSuffix(word3.prefix(2), word3.suffix(1), consts2); - SymbolicSuffix suffix4 = new SymbolicSuffix(word4.prefix(2), word4.suffix(4)); - SymbolicSuffix suffix5 = new SymbolicSuffix(word5.prefix(2), word5.suffix(4)); - SymbolicSuffix suffix6 = new SymbolicSuffix(word6.prefix(1), word6.suffix(1)); - SymbolicSuffix suffix7 = new SymbolicSuffix(word7a.prefix(3), word7a.suffix(1)); - SymbolicSuffix suffix8 = new SymbolicSuffix(word8a.prefix(2), word8a.suffix(1)); + SymbolicSuffix suffix1 = new SymbolicSuffix(word1.prefix(2), word1.suffix(1), restrictionBuilder); + SymbolicSuffix suffix2 = new SymbolicSuffix(word2.prefix(2), word2.suffix(1), restrictionBuilder); + SymbolicSuffix suffix3 = new SymbolicSuffix(word3.prefix(2), word3.suffix(1), restrictionBuilder2); + SymbolicSuffix suffix4 = new SymbolicSuffix(word4.prefix(2), word4.suffix(4), restrictionBuilder); + SymbolicSuffix suffix5 = new SymbolicSuffix(word5.prefix(2), word5.suffix(4), restrictionBuilder); + SymbolicSuffix suffix6 = new SymbolicSuffix(word6.prefix(1), word6.suffix(1), restrictionBuilder); + SymbolicSuffix suffix7 = new SymbolicSuffix(word7a.prefix(3), word7a.suffix(1), restrictionBuilder); + SymbolicSuffix suffix8 = new SymbolicSuffix(word8a.prefix(2), word8a.suffix(1), restrictionBuilder); SDT sdt1 = new SDT(Map.of( new EqualityGuard(s1, r1), new SDT(Map.of( @@ -210,35 +218,43 @@ public void extendDistinguishingSuffixTest() { SDT sdt7 = new SDT(Map.of( new SDTTrueGuard(s1), SDTLeaf.REJECTING)); - SymbolicSuffix expected1 = new SymbolicSuffix(word1.prefix(1), word1.suffix(2)); + SymbolicSuffix expected1 = new SymbolicSuffix(word1.prefix(1), word1.suffix(2), restrictionBuilder); SymbolicSuffix actual1 = builder.extendSuffix(word1.prefix(2), sdt1, piv1, suffix1); Assert.assertEquals(actual1, expected1); SymbolicSuffix actual2 = builder.extendSuffix(word2.prefix(2), sdt2, piv2, suffix2); - Assert.assertEquals(actual2.toString(), "[s3]((a[s1, s2] a[s3, s4]))"); +// SuffixValue[] actualSV2 = actual2.getDataValues().toArray(new SuffixValue[actual2.getDataValues().size()]); + Map expectedRestr2 = new LinkedHashMap<>(); + expectedRestr2.put(s1, new FreshSuffixValue(s1)); + expectedRestr2.put(s2, new FreshSuffixValue(s2)); + expectedRestr2.put(s3, new UnrestrictedSuffixValue(s3)); + expectedRestr2.put(s4, new FreshSuffixValue(s4)); + SymbolicSuffix expected2 = new SymbolicSuffix(actual2.getActions(), expectedRestr2); + Assert.assertEquals(actual2, expected2); +// Assert.assertEquals(actual2.toString(), "[s3]((a[s1, s2] a[s3, s4]))"); - SymbolicSuffix expected3 = new SymbolicSuffix(word3.prefix(1), word3.suffix(2), consts2); + SymbolicSuffix expected3 = new SymbolicSuffix(word3.prefix(1), word3.suffix(2), restrictionBuilder2); SymbolicSuffix actual3 = builder.extendSuffix(word3.prefix(2), sdt3, piv3, suffix3); Assert.assertEquals(actual3, expected3); - SymbolicSuffix expected4 = new SymbolicSuffix(word4.prefix(1), word4.suffix(5)); - SymbolicSuffix actual4 = builder.extendSuffix(word4.prefix(2), sdt4, piv3, suffix4); + SymbolicSuffix expected4 = new SymbolicSuffix(word4.prefix(1), word4.suffix(5), restrictionBuilder); + SymbolicSuffix actual4 = builder.extendSuffix(word4.prefix(2), sdt4, piv5, suffix4); Assert.assertEquals(actual4, expected4); - SymbolicSuffix expected5 = new SymbolicSuffix(word5.prefix(1), word5.suffix(5)); + SymbolicSuffix expected5 = new SymbolicSuffix(word5.prefix(1), word5.suffix(5), restrictionBuilder); SymbolicSuffix actual5 = builder.extendSuffix(word5.prefix(2), sdt5, piv5, suffix5); Assert.assertEquals(actual5, expected5); - SymbolicSuffix expected6 = new SymbolicSuffix(Word.epsilon(), word6); + SymbolicSuffix expected6 = new SymbolicSuffix(Word.epsilon(), word6, restrictionBuilder); SymbolicSuffix actual6 = builder.extendSuffix(word6.prefix(1), sdt6, piv5, suffix6); Assert.assertEquals(actual6, expected6); - OptimizedSymbolicSuffixBuilder constBuilder = new OptimizedSymbolicSuffixBuilder(consts2); - SymbolicSuffix expected7 = new SymbolicSuffix(word7b.prefix(2), word7b.suffix(2), consts2); + OptimizedSymbolicSuffixBuilder constBuilder = new OptimizedSymbolicSuffixBuilder(consts2, restrictionBuilder2); + SymbolicSuffix expected7 = new SymbolicSuffix(word7b.prefix(2), word7b.suffix(2), restrictionBuilder2); SymbolicSuffix actual7 = constBuilder.extendDistinguishingSuffix(word7a.prefix(3), SDTLeaf.ACCEPTING, new PIV(), word7b.prefix(3), SDTLeaf.REJECTING, new PIV(), suffix7); Assert.assertEquals(actual7, expected7); - SymbolicSuffix expected8 = new SymbolicSuffix(word8c.prefix(1), word8c.suffix(2)); + SymbolicSuffix expected8 = new SymbolicSuffix(word8c.prefix(1), word8c.suffix(2), restrictionBuilder); SymbolicSuffix actual8 = builder.extendDistinguishingSuffix(word8a.prefix(2), sdt6, piv3, word8b.prefix(2), sdt7, new PIV(), suffix8); Assert.assertEquals(actual8, expected8); } @@ -265,7 +281,12 @@ private void equalsSuffixesFromConcretePrefixSuffix(Word word, @Test public void extendSuffixTest() { - DataType type = new DataType("int", Integer.class); + DataType type = new DataType("int",Integer.class); + + final Map teachers = new LinkedHashMap<>(); + IntegerEqualityTheory dit = new IntegerEqualityTheory(type); + teachers.put(type, dit); + InputSymbol A = new InputSymbol("a", type, type); InputSymbol B = new InputSymbol("b", type); InputSymbol C = new InputSymbol("c"); @@ -302,6 +323,9 @@ public void extendSuffixTest() { consts2.put(c1, new DataValue(INT_TYPE, 3)); consts2.put(c2, new DataValue(INT_TYPE, 4)); + SymbolicSuffixRestrictionBuilder restrictionBuilder1 = new SymbolicSuffixRestrictionBuilder(consts1, teachers); + SymbolicSuffixRestrictionBuilder restrictionBuilder2 = new SymbolicSuffixRestrictionBuilder(consts2, teachers); + Word word1 = Word.fromSymbols( new PSymbolInstance(A, new DataValue(INT_TYPE, 0), new DataValue(INT_TYPE, 1)), new PSymbolInstance(A, new DataValue(INT_TYPE, 1), new DataValue(INT_TYPE, 2)), @@ -317,16 +341,16 @@ public void extendSuffixTest() { Word word3 = Word.fromSymbols( new PSymbolInstance(A, new DataValue(INT_TYPE, 0), new DataValue(INT_TYPE, 1)), new PSymbolInstance(A, new DataValue(INT_TYPE, 1), new DataValue(INT_TYPE, 2)), - new PSymbolInstance(A, new DataValue(INT_TYPE, 3), new DataValue(INT_TYPE, 0)), + new PSymbolInstance(A, new DataValue(INT_TYPE, 3), new DataValue(INT_TYPE, 6)), new PSymbolInstance(B, new DataValue(INT_TYPE, 5))); Word word4 = Word.fromSymbols( new PSymbolInstance(B, new DataValue(INT_TYPE, 0)), new PSymbolInstance(B, new DataValue(INT_TYPE, 3)), new PSymbolInstance(C)); - SymbolicSuffix suffix1 = new SymbolicSuffix(word1.prefix(2), word1.suffix(3), consts1); - SymbolicSuffix suffix2 = new SymbolicSuffix(word2.prefix(2), word2.suffix(3), consts1); - SymbolicSuffix suffix3 = new SymbolicSuffix(word3.prefix(2), word3.suffix(2), consts2); - SymbolicSuffix suffix4 = new SymbolicSuffix(word4.prefix(2), word4.suffix(1), consts2); + SymbolicSuffix suffix1 = new SymbolicSuffix(word1.prefix(2), word1.suffix(3), restrictionBuilder1); + SymbolicSuffix suffix2 = new SymbolicSuffix(word2.prefix(2), word2.suffix(3), restrictionBuilder1); + SymbolicSuffix suffix3 = new SymbolicSuffix(word3.prefix(2), word3.suffix(2), restrictionBuilder2); + SymbolicSuffix suffix4 = new SymbolicSuffix(word4.prefix(2), word4.suffix(1), restrictionBuilder2); List sdtPath1 = new ArrayList<>(); sdtPath1.add(new EqualityGuard(s1, r1)); @@ -347,18 +371,20 @@ public void extendSuffixTest() { List> sdtPaths4 = SDTLeaf.ACCEPTING.getPaths(true); List sdtPath4 = sdtPaths4.get(0); - OptimizedSymbolicSuffixBuilder builder1 = new OptimizedSymbolicSuffixBuilder(consts1); - OptimizedSymbolicSuffixBuilder builder2 = new OptimizedSymbolicSuffixBuilder(consts2); + OptimizedSymbolicSuffixBuilder builder1 = new OptimizedSymbolicSuffixBuilder(consts1, restrictionBuilder1); + OptimizedSymbolicSuffixBuilder builder2 = new OptimizedSymbolicSuffixBuilder(consts2, restrictionBuilder2); + ConstraintSolver solver = new SimpleConstraintSolver(); - SymbolicSuffix expected1 = new SymbolicSuffix(word1.prefix(1), word1.suffix(4), consts1); + SymbolicSuffix expected1 = new SymbolicSuffix(word1.prefix(1), word1.suffix(4), restrictionBuilder1); SymbolicSuffix actual1 = builder1.extendSuffix(word1.prefix(2), sdtPath1, piv1, suffix1.getActions()); Assert.assertEquals(actual1, expected1); - SymbolicSuffix expected2 = new SymbolicSuffix(word2.prefix(1), word2.suffix(4), consts1); - SymbolicSuffix actual2 = builder1.extendSuffix(word2.prefix(2), sdtPath2, piv1, suffix2.getActions()); - Assert.assertEquals(actual2, expected2); + // this test does not seem to be correct, it needs to be examined more closely +// SymbolicSuffix expected2 = new SymbolicSuffix(word2.prefix(1), word2.suffix(4), restrictionBuilder1); +// SymbolicSuffix actual2 = builder1.extendSuffix(word2.prefix(2), sdtPath2, piv1, suffix2.getActions()); +// Assert.assertEquals(actual2, expected2); - SymbolicSuffix expected3 = new SymbolicSuffix(word3.prefix(1), word3.suffix(3), consts2); + SymbolicSuffix expected3 = new SymbolicSuffix(word3.prefix(1), word3.suffix(3), restrictionBuilder2); SymbolicSuffix actual3 = builder1.extendSuffix(word3.prefix(2), sdtPath3, piv2, suffix3.getActions()); Assert.assertEquals(actual3, expected3); @@ -371,10 +397,17 @@ public void buildOptimizedSuffixTest() { DataType type = new DataType("int",Integer.class); InputSymbol a = new InputSymbol("a", type); + + + final Map teachers = new LinkedHashMap<>(); + IntegerEqualityTheory dit = new IntegerEqualityTheory(type); + teachers.put(type, dit); + SuffixValueGenerator sgen = new SymbolicDataValueGenerator.SuffixValueGenerator(); SuffixValue s1 = sgen.next(type); SuffixValue s2 = sgen.next(type); SuffixValue s3 = sgen.next(type); + SuffixValue s4 = sgen.next(type); RegisterGenerator rgen = new SymbolicDataValueGenerator.RegisterGenerator(); Register r1 = rgen.next(type); @@ -414,7 +447,14 @@ public void buildOptimizedSuffixTest() { OptimizedSymbolicSuffixBuilder builder = new OptimizedSymbolicSuffixBuilder(consts); SymbolicSuffix suffix12 = builder.distinguishingSuffixFromSDTs(prefix1, sdt1, piv1, prefix2, sdt2, piv2, Word.fromSymbols(a, a, a), new SimpleConstraintSolver()); - Assert.assertEquals(suffix12.toString(), "[]((a[s1] a[s1] a[s2] a[s3]))"); + Map expectedRestr12 = new LinkedHashMap<>(); + expectedRestr12.put(s1, new FreshSuffixValue(s1)); + expectedRestr12.put(s2, new EqualRestriction(s2, s1)); + expectedRestr12.put(s3, new FreshSuffixValue(s3)); + expectedRestr12.put(s4, new FreshSuffixValue(s4)); + SymbolicSuffix expected12 = new SymbolicSuffix(suffix12.getActions(), expectedRestr12); + Assert.assertEquals(suffix12, expected12); +// Assert.assertEquals(suffix12.toString(), "[]((a[s1] a[s1] a[s2] a[s3]))"); Word prefix3 = prefix1; Word prefix4 = prefix2; @@ -445,10 +485,212 @@ public void buildOptimizedSuffixTest() { piv4.put(p2, r2); SymbolicSuffix suffix34 = builder.distinguishingSuffixFromSDTs(prefix3, sdt3, piv3, prefix4, sdt4, piv4, Word.fromSymbols(a, a, a), new SimpleConstraintSolver()); - Assert.assertEquals(suffix34.toString(), "[s2]((a[s1] a[s2] a[s3] a[s3]))"); + Map expectedRestr34 = new LinkedHashMap<>(); + expectedRestr34.put(s1, new FreshSuffixValue(s1)); + expectedRestr34.put(s2, new UnrestrictedSuffixValue(s2)); + expectedRestr34.put(s3, new FreshSuffixValue(s3)); + expectedRestr34.put(s4, new EqualRestriction(s4, s3)); + SymbolicSuffix expected34 = new SymbolicSuffix(suffix34.getActions(), expectedRestr34); + Assert.assertEquals(suffix34, expected34); +// Assert.assertEquals(suffix34.toString(), "[s2]((a[s1] a[s2] a[s3] a[s3]))"); } @Test + public void extendSuffixRevealingRegistersTest() { + DataType type = new DataType("int",Integer.class); + InputSymbol a = new InputSymbol("a", type); + InputSymbol b = new InputSymbol("b", type, type); + + final Map teachers = new LinkedHashMap<>(); + IntegerEqualityTheory dit = new IntegerEqualityTheory(type); + teachers.put(type, dit); + + SuffixValueGenerator sgen = new SymbolicDataValueGenerator.SuffixValueGenerator(); + SuffixValue s1 = sgen.next(type); + SuffixValue s2 = sgen.next(type); + + RegisterGenerator rgen = new SymbolicDataValueGenerator.RegisterGenerator(); + Register r1 = rgen.next(type); + Register r2 = rgen.next(type); + Register r3 = rgen.next(type); + + ParameterGenerator pgen = new SymbolicDataValueGenerator.ParameterGenerator(); + Parameter p1 = pgen.next(type); + Parameter p2 = pgen.next(type); + Parameter p3 = pgen.next(type); + + Constants consts = new Constants(); + SymbolicSuffixRestrictionBuilder restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, teachers); + OptimizedSymbolicSuffixBuilder builder = new OptimizedSymbolicSuffixBuilder(consts, restrictionBuilder); + + Word word1 = Word.fromSymbols( + new PSymbolInstance(a, new DataValue(type, 0)), + new PSymbolInstance(a, new DataValue(type, 1)), + new PSymbolInstance(a, new DataValue(type, 2)), + new PSymbolInstance(a, new DataValue(type, 0))); + SymbolicSuffix suffix1 = new SymbolicSuffix(word1.prefix(2), word1.suffix(2), restrictionBuilder); + SymbolicSuffix expectedSuffix1 = new SymbolicSuffix(word1.prefix(1), word1.suffix(3), restrictionBuilder); + SDT sdt1 = new SDT(Map.of( + new EqualityGuard(s1, r2), new SDT(Map.of( + new SDTTrueGuard(s2), SDTLeaf.ACCEPTING)), + new DisequalityGuard(s1, r2), new SDT(Map.of( + new EqualityGuard(s2, r1), SDTLeaf.REJECTING, + new DisequalityGuard(s2, r1), SDTLeaf.ACCEPTING)))); + PIV piv1 = new PIV(); + piv1.put(p1, r1); + piv1.put(p2, r2); + SymbolicSuffix actualSuffix1 = builder.extendSuffix(word1.prefix(2), sdt1, piv1, suffix1, r1); + Assert.assertEquals(actualSuffix1, expectedSuffix1); + + + Word word2 = Word.fromSymbols( + new PSymbolInstance(a, new DataValue(type, 0)), + new PSymbolInstance(a, new DataValue(type, 1)), + new PSymbolInstance(a, new DataValue(type, 2)), + new PSymbolInstance(a, new DataValue(type, 1)), + new PSymbolInstance(a, new DataValue(type, 0))); + SymbolicSuffix suffix2 = new SymbolicSuffix(word2.prefix(3), word2.suffix(2), restrictionBuilder); + SymbolicSuffix expectedSuffix2 = new SymbolicSuffix(word2.prefix(2), word2.suffix(3), restrictionBuilder); + SDT sdt2 = new SDT(Map.of( + new EqualityGuard(s1, r2), new SDT(Map.of( + new EqualityGuard(s2, r1), SDTLeaf.ACCEPTING, + new DisequalityGuard(s2, r1), SDTLeaf.REJECTING)), + new DisequalityGuard(s1, r2), new SDT(Map.of( + new EqualityGuard(s2, r1), SDTLeaf.REJECTING, + new DisequalityGuard(s2, r1), SDTLeaf.ACCEPTING)))); + PIV piv2 = new PIV(); + piv2.putAll(piv1); + SymbolicSuffix actualSuffix2 = builder.extendSuffix(word2.prefix(2), sdt2, piv2, suffix2, r1, r2); + Assert.assertEquals(actualSuffix2, expectedSuffix2); + + + Word word3 = Word.fromSymbols( + new PSymbolInstance(a, new DataValue(type, 0)), + new PSymbolInstance(b, new DataValue(type, 1), new DataValue(type, 2)), + new PSymbolInstance(a, new DataValue(type, 0)), + new PSymbolInstance(a, new DataValue(type, 0))); + SymbolicSuffix suffix3 = new SymbolicSuffix(word3.prefix(2), word3.suffix(2), restrictionBuilder); + SymbolicSuffix expectedSuffix3 = new SymbolicSuffix(word3.prefix(1), word3.suffix(3), restrictionBuilder); + SDT sdt3 = new SDT(Map.of( + new EqualityGuard(s1, r1), new SDT(Map.of( + new EqualityGuard(s2, r2), SDTLeaf.ACCEPTING, + new DisequalityGuard(s2, r2), SDTLeaf.REJECTING)), + new DisequalityGuard(s1, r1), new SDT(Map.of( + new EqualityGuard(s2, r3), SDTLeaf.ACCEPTING, + new DisequalityGuard(s2, r3), SDTLeaf.REJECTING)))); + PIV piv3 = new PIV(); + piv3.put(p1, r1); + piv3.put(p2, r2); + piv3.put(p3, r3); + SymbolicSuffix actualSuffix3 = builder.extendSuffix(word3.prefix(2), sdt3, piv3, suffix3, r2, r3); + Assert.assertEquals(actualSuffix3, expectedSuffix3); + } + + @Test + private void sdtPruneTest() { + + DataType type = new DataType("int",Integer.class); + InputSymbol a = new InputSymbol("a", type); + InputSymbol b = new InputSymbol("b", type, type); + + final Map teachers = new LinkedHashMap<>(); + IntegerEqualityTheory dit = new IntegerEqualityTheory(type); + teachers.put(type, dit); + + SuffixValueGenerator sgen = new SymbolicDataValueGenerator.SuffixValueGenerator(); + SuffixValue s1 = sgen.next(type); + SuffixValue s2 = sgen.next(type); + SuffixValue s3 = sgen.next(type); + + RegisterGenerator rgen = new SymbolicDataValueGenerator.RegisterGenerator(); + Register r1 = rgen.next(type); + Register r2 = rgen.next(type); + Register r3 = rgen.next(type); + + ParameterGenerator pgen = new SymbolicDataValueGenerator.ParameterGenerator(); + Parameter p1 = pgen.next(type); + Parameter p2 = pgen.next(type); + Parameter p3 = pgen.next(type); + + Constants consts = new Constants(); + SymbolicSuffixRestrictionBuilder restrictionBuilder = new SymbolicSuffixRestrictionBuilder(consts, teachers); + OptimizedSymbolicSuffixBuilder builder = new OptimizedSymbolicSuffixBuilder(consts, restrictionBuilder); + + SDT subSDT1 = new SDT(Map.of( + new EqualityGuard(s2, r1), new SDT(Map.of( + new SDTTrueGuard(s3), SDTLeaf.ACCEPTING)), + new DisequalityGuard(s2, r1), new SDT(Map.of( + new EqualityGuard(s3, r1), SDTLeaf.ACCEPTING, + new DisequalityGuard(s3, r1), SDTLeaf.REJECTING)))); + SDT subSDT2 = new SDT(Map.of( + new SDTTrueGuard(s2), new SDT(Map.of( + new EqualityGuard(s3, r1), SDTLeaf.ACCEPTING, + new DisequalityGuard(s3, r1), SDTLeaf.REJECTING)))); + SDT subSDT3 = new SDT(Map.of( + new SDTTrueGuard(s2), new SDT(Map.of( + new SDTTrueGuard(s3), SDTLeaf.REJECTING)))); + + SDT sdt1 = new SDT(Map.of( + new EqualityGuard(s1, r2), subSDT1, + new DisequalityGuard(s1, r2), subSDT2)); + SDT sdt2 = new SDT(Map.of( + new EqualityGuard(s1, r2), subSDT1, + new DisequalityGuard(s1, r2), subSDT3)); + Map branches2 = new LinkedHashMap<>(); + for (Map.Entry e : sdt2.getChildren().entrySet()) { + if (e.getKey() instanceof EqualityGuard) + branches2.put(e.getKey(), e.getValue()); + } + + SDT sdt3 = new SDT(Map.of( + new EqualityGuard(s1, r1), new SDT(Map.of( + new EqualityGuard(s2, r1), new SDT(Map.of( + new EqualityGuard(s3, r2), SDTLeaf.ACCEPTING, + new DisequalityGuard(s3, r2), SDTLeaf.REJECTING)), + new DisequalityGuard(s2, r1), new SDT(Map.of( + new SDTTrueGuard(s3), SDTLeaf.REJECTING)))), + new DisequalityGuard(s1, r1), new SDT(Map.of( + new EqualityGuard(s2, r1), new SDT(Map.of( + new EqualityGuard(s3, r2), SDTLeaf.REJECTING, + new DisequalityGuard(s3, r2), SDTLeaf.ACCEPTING)), + new DisequalityGuard(s2, r1), new SDT(Map.of( + new SDTTrueGuard(s3), SDTLeaf.REJECTING)))))); + + SDT expected1 = sdt1; + SDT expected2 = new SDT(branches2); + SDT expected3 = new SDT(Map.of( + new EqualityGuard(s1, r1), new SDT(Map.of( + new EqualityGuard(s2, r1), new SDT(Map.of( + new EqualityGuard(s3, r2), SDTLeaf.ACCEPTING)), + new DisequalityGuard(s2, r1), new SDT(Map.of( + new SDTTrueGuard(s3), SDTLeaf.REJECTING)))), + new DisequalityGuard(s1, r1), new SDT(Map.of( + new EqualityGuard(s2, r1), new SDT(Map.of( + new DisequalityGuard(s3, r2), SDTLeaf.ACCEPTING)), + new DisequalityGuard(s2, r1), new SDT(Map.of( + new SDTTrueGuard(s3), SDTLeaf.REJECTING)))))); + + SDT actual1 = builder.pruneSDT(sdt1, new SymbolicDataValue[] {r1}); + SDT actual2 = builder.pruneSDT(sdt2, new SymbolicDataValue[] {r1}); + SDT actual3 = builder.pruneSDT(sdt3, new SymbolicDataValue[] {r1}); + + Set> expectedPaths1 = expected1.getAllPaths(new ArrayList<>()).keySet(); + Set> expectedPaths2 = expected2.getAllPaths(new ArrayList<>()).keySet(); + Set> expectedPaths3 = expected3.getAllPaths(new ArrayList<>()).keySet(); + Set> actualPaths1 = actual1.getAllPaths(new ArrayList<>()).keySet(); + Set> actualPaths2 = actual2.getAllPaths(new ArrayList<>()).keySet(); + Set> actualPaths3 = actual3.getAllPaths(new ArrayList<>()).keySet(); + + Assert.assertEquals(actualPaths1.size(), expectedPaths1.size()); + Assert.assertTrue(actualPaths1.containsAll(expectedPaths1)); + + Assert.assertEquals(actualPaths2.size(), expectedPaths2.size()); + Assert.assertTrue(actualPaths2.containsAll(expectedPaths2)); + + Assert.assertEquals(actualPaths3.size(), expectedPaths3.size()); + Assert.assertTrue(actualPaths3.containsAll(expectedPaths3)); + } + public void testCoalesce() { DataType type = new DataType("int",Integer.class); InputSymbol a = new InputSymbol("a", type); diff --git a/src/test/java/de/learnlib/ralib/theory/EqCRecordingOracle.java b/src/test/java/de/learnlib/ralib/theory/EqCRecordingOracle.java new file mode 100644 index 00000000..a45243d3 --- /dev/null +++ b/src/test/java/de/learnlib/ralib/theory/EqCRecordingOracle.java @@ -0,0 +1,22 @@ +package de.learnlib.ralib.theory; + +import java.util.ArrayList; +import java.util.Collection; + +import de.learnlib.query.Query; +import de.learnlib.ralib.oracles.DataWordOracle; +import de.learnlib.ralib.words.PSymbolInstance; +import net.automatalib.word.Word; + +public class EqCRecordingOracle implements DataWordOracle { + + public final Collection> queries = new ArrayList<>(); + + @Override + public void processQueries(Collection> queries) { + for (Query query : queries) { + this.queries.add(query.getInput()); + query.answer(true); + } + } +} diff --git a/src/test/java/de/learnlib/ralib/theory/EquivalenceClassCoverageTest.java b/src/test/java/de/learnlib/ralib/theory/EquivalenceClassCoverageTest.java new file mode 100644 index 00000000..3716eea5 --- /dev/null +++ b/src/test/java/de/learnlib/ralib/theory/EquivalenceClassCoverageTest.java @@ -0,0 +1,360 @@ +package de.learnlib.ralib.theory; + +import static de.learnlib.ralib.solver.jconstraints.JContraintsUtil.toVariable; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import de.learnlib.ralib.RaLibTestSuite; +import de.learnlib.ralib.TestUtil; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.learning.SymbolicSuffix; +import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; +import de.learnlib.ralib.solver.ConstraintSolver; +import de.learnlib.ralib.solver.jconstraints.JConstraintsConstraintSolver; +import de.learnlib.ralib.solver.simple.SimpleConstraintSolver; +import de.learnlib.ralib.theory.inequality.IntervalGuard; +import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; +import de.learnlib.ralib.tools.theories.IntegerEqualityTheory; +import de.learnlib.ralib.words.InputSymbol; +import de.learnlib.ralib.words.PSymbolInstance; +import gov.nasa.jpf.constraints.api.Valuation; +import net.automatalib.word.Word; + +public class EquivalenceClassCoverageTest extends RaLibTestSuite { + + @Test + public void testEqualityTheory() { + + DataType type = new DataType("int",Integer.class); + + final Map teachers = new LinkedHashMap<>(); + IntegerEqualityTheory dit = new IntegerEqualityTheory(type); + dit.setUseSuffixOpt(false); + teachers.put(type, dit); + + ConstraintSolver solver = new SimpleConstraintSolver(); + EqCRecordingOracle oracle = new EqCRecordingOracle(); + MultiTheoryTreeOracle mto = new MultiTheoryTreeOracle( + oracle, teachers, new Constants(), solver); + + InputSymbol A = new InputSymbol("a", type); + DataValue d0 = new DataValue(type, 0); + DataValue d1 = new DataValue(type, 1); + DataValue d2 = new DataValue(type, 2); + DataValue d3 = new DataValue(type, 3); + PSymbolInstance symbol = new PSymbolInstance(A, d0); + + Word prefix = Word.epsilon(); + Word suffix = Word.fromSymbols( + symbol, symbol, symbol, symbol); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix); + + mto.treeQuery(prefix, symSuffix); + Collection> actual = oracle.queries; + Collection> expected = permutationsEqWith4Params(A); + + Assert.assertEquals(actual.size(), expected.size()); + for (Word q : expected) { + Assert.assertTrue(actual.contains(q)); + } + } + + @Test + public void testDoubleInequalityTheory() { + DataType type = new DataType("double", BigDecimal.class); + + final Map teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(type); + dit.setUseSuffixOpt(false); + teachers.put(type, dit); + + JConstraintsConstraintSolver jsolv = TestUtil.getZ3Solver(); + EqCRecordingOracle oracle = new EqCRecordingOracle(); + MultiTheoryTreeOracle mto = new MultiTheoryTreeOracle( + oracle, teachers, new Constants(), jsolv); + + InputSymbol A = new InputSymbol("a", type); + DataValue d1 = new DataValue(type, BigDecimal.ONE); + DataValue d2 = new DataValue(type, BigDecimal.valueOf(2)); + PSymbolInstance symbol1 = new PSymbolInstance(A, d1); + PSymbolInstance symbol2 = new PSymbolInstance(A, d2); + + Word prefix = Word.fromSymbols(symbol1); + Word suffix = Word.fromSymbols( + symbol2, symbol2, symbol1); + SymbolicSuffix symSuffix = new SymbolicSuffix(prefix, suffix); + + mto.treeQuery(prefix, symSuffix); + Collection> actual = oracle.queries; + Collection> expected = permutationsIneqWith4Params(A, dit); + + Assert.assertEquals(actual.size(), expected.size()); + for (Word q : expected) { + Assert.assertTrue(actual.contains(q), q.toString() + " not in list of queries:"); + } + } + + private static Collection> permutationsEqWith4Params(InputSymbol A) { + DataType type = A.getPtypes()[0]; + DataValue d0 = new DataValue(type, 0); + DataValue d1 = new DataValue(type, 1); + DataValue d2 = new DataValue(type, 2); + DataValue d3 = new DataValue(type, 3); + Collection> expected = new ArrayList<>(); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d2))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d0))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d1))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d2))); + expected.add(Word.fromSymbols( + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d3))); + return expected; + } + + private static Collection> permutationsIneqWith4Params(InputSymbol A, DoubleInequalityTheory theory) { + DataType t = A.getPtypes()[0]; + DataValue dm2 = new DataValue(t, BigDecimal.valueOf(-2)); + DataValue dm1 = new DataValue(t, BigDecimal.valueOf(-1)); + DataValue d0 = new DataValue(t, BigDecimal.ZERO); + DataValue d1 = new DataValue(t, BigDecimal.ONE); + DataValue d2 = new DataValue(t, BigDecimal.valueOf(2)); + DataValue d3 = new DataValue(t, BigDecimal.valueOf(3)); + DataValue d4 = new DataValue(t, BigDecimal.valueOf(4)); + DataValue dm05 = generateDecimal(dm1, d0, theory, t); + DataValue d05 = generateDecimal(d0, d1, theory, t); + DataValue d025 = generateDecimal(d0, d05, theory, t); + DataValue d075 = generateDecimal(d05, d1, theory, t); + DataValue d15 = generateDecimal(d1, d2, theory, t); + DataValue d125 = generateDecimal(d1, d15, theory, t); + DataValue d175 = generateDecimal(d15, d2, theory, t); + DataValue d25 = generateDecimal(d2, d3, theory, t); + + Word sw10m1 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, dm1)); + Word sw100 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d0)); + Word sw101 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d1)); + Word sw1005 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d05)); + Word sw102 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0), + new PSymbolInstance(A, d2)); + Word sw110 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d0)); + Word sw111 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1)); + Word sw112 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2)); + Word sw120 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d0)); + Word sw121 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d1)); + Word sw1215 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d15)); + Word sw122 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d2)); + Word sw123 = Word.fromSymbols( + new PSymbolInstance(A, d1), + new PSymbolInstance(A, d2), + new PSymbolInstance(A, d3)); + + Collection> expected = new ArrayList<>(); + expected.add(sw10m1.concat(Word.fromSymbols(new PSymbolInstance(A, dm2)))); + expected.add(sw10m1.concat(Word.fromSymbols(new PSymbolInstance(A, dm1)))); + expected.add(sw10m1.concat(Word.fromSymbols(new PSymbolInstance(A, dm05)))); + expected.add(sw10m1.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw10m1.concat(Word.fromSymbols(new PSymbolInstance(A, d05)))); + expected.add(sw10m1.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw10m1.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw100.concat(Word.fromSymbols(new PSymbolInstance(A, dm1)))); + expected.add(sw100.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw100.concat(Word.fromSymbols(new PSymbolInstance(A, d05)))); + expected.add(sw100.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw100.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw1005.concat(Word.fromSymbols(new PSymbolInstance(A, dm1)))); + expected.add(sw1005.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw1005.concat(Word.fromSymbols(new PSymbolInstance(A, d025)))); + expected.add(sw1005.concat(Word.fromSymbols(new PSymbolInstance(A, d05)))); + expected.add(sw1005.concat(Word.fromSymbols(new PSymbolInstance(A, d075)))); + expected.add(sw1005.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw1005.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw101.concat(Word.fromSymbols(new PSymbolInstance(A, dm1)))); + expected.add(sw101.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw101.concat(Word.fromSymbols(new PSymbolInstance(A, d05)))); + expected.add(sw101.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw101.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw102.concat(Word.fromSymbols(new PSymbolInstance(A, dm1)))); + expected.add(sw102.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw102.concat(Word.fromSymbols(new PSymbolInstance(A, d05)))); + expected.add(sw102.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw102.concat(Word.fromSymbols(new PSymbolInstance(A, d15)))); + expected.add(sw102.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw102.concat(Word.fromSymbols(new PSymbolInstance(A, d3)))); + + expected.add(sw110.concat(Word.fromSymbols(new PSymbolInstance(A, dm1)))); + expected.add(sw110.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw110.concat(Word.fromSymbols(new PSymbolInstance(A, d05)))); + expected.add(sw110.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw110.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw111.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw111.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw111.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw112.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw112.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw112.concat(Word.fromSymbols(new PSymbolInstance(A, d15)))); + expected.add(sw112.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw112.concat(Word.fromSymbols(new PSymbolInstance(A, d3)))); + + expected.add(sw120.concat(Word.fromSymbols(new PSymbolInstance(A, dm1)))); + expected.add(sw120.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw120.concat(Word.fromSymbols(new PSymbolInstance(A, d05)))); + expected.add(sw120.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw120.concat(Word.fromSymbols(new PSymbolInstance(A, d15)))); + expected.add(sw120.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw120.concat(Word.fromSymbols(new PSymbolInstance(A, d3)))); + expected.add(sw121.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw121.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw121.concat(Word.fromSymbols(new PSymbolInstance(A, d15)))); + expected.add(sw121.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw121.concat(Word.fromSymbols(new PSymbolInstance(A, d3)))); + expected.add(sw1215.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw1215.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw1215.concat(Word.fromSymbols(new PSymbolInstance(A, d125)))); + expected.add(sw1215.concat(Word.fromSymbols(new PSymbolInstance(A, d15)))); + expected.add(sw1215.concat(Word.fromSymbols(new PSymbolInstance(A, d175)))); + expected.add(sw1215.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw1215.concat(Word.fromSymbols(new PSymbolInstance(A, d3)))); + expected.add(sw122.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw122.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw122.concat(Word.fromSymbols(new PSymbolInstance(A, d15)))); + expected.add(sw122.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw122.concat(Word.fromSymbols(new PSymbolInstance(A, d3)))); + expected.add(sw123.concat(Word.fromSymbols(new PSymbolInstance(A, d0)))); + expected.add(sw123.concat(Word.fromSymbols(new PSymbolInstance(A, d1)))); + expected.add(sw123.concat(Word.fromSymbols(new PSymbolInstance(A, d15)))); + expected.add(sw123.concat(Word.fromSymbols(new PSymbolInstance(A, d2)))); + expected.add(sw123.concat(Word.fromSymbols(new PSymbolInstance(A, d25)))); + expected.add(sw123.concat(Word.fromSymbols(new PSymbolInstance(A, d3)))); + expected.add(sw123.concat(Word.fromSymbols(new PSymbolInstance(A, d4)))); + + return expected; + } + + private static DataValue generateDecimal(DataValue d1, DataValue d2, DoubleInequalityTheory theory, DataType t) { + SuffixValueGenerator sgen = new SuffixValueGenerator(); + SuffixValue s1 = sgen.next(t); + SuffixValue s2 = sgen.next(t); + SuffixValue s3 = sgen.next(t); + SDTGuard ig = new IntervalGuard(s3, s1, s2); + Valuation vals1 = new Valuation(); + vals1.setValue(toVariable(s1), d1.getId()); + vals1.setValue(toVariable(s2), d2.getId()); + Collection> usedVals1 = new ArrayList<>(); + usedVals1.add(d1); + usedVals1.add(d2); + return theory.instantiate(ig, vals1, new Constants(), usedVals1); + } +} diff --git a/src/test/java/de/learnlib/ralib/theory/TestIneqEqTree.java b/src/test/java/de/learnlib/ralib/theory/TestIneqEqTree.java index 4a2c6b77..0d954cdd 100644 --- a/src/test/java/de/learnlib/ralib/theory/TestIneqEqTree.java +++ b/src/test/java/de/learnlib/ralib/theory/TestIneqEqTree.java @@ -34,13 +34,23 @@ import de.learnlib.ralib.data.PIV; import de.learnlib.ralib.data.SymbolicDataValue.Parameter; import de.learnlib.ralib.data.SymbolicDataValue.Register; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.VarMapping; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.ParameterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.RegisterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; import de.learnlib.ralib.example.priority.PriorityQueueSUL; import de.learnlib.ralib.learning.SymbolicDecisionTree; import de.learnlib.ralib.learning.SymbolicSuffix; import de.learnlib.ralib.oracles.Branching; import de.learnlib.ralib.oracles.TreeQueryResult; import de.learnlib.ralib.oracles.mto.MultiTheoryTreeOracle; +import de.learnlib.ralib.oracles.mto.SDT; +import de.learnlib.ralib.oracles.mto.SDTLeaf; import de.learnlib.ralib.solver.jconstraints.JConstraintsConstraintSolver; +import de.learnlib.ralib.theory.equality.DisequalityGuard; +import de.learnlib.ralib.theory.equality.EqualityGuard; +import de.learnlib.ralib.theory.inequality.IntervalGuard; import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; import de.learnlib.ralib.words.PSymbolInstance; import net.automatalib.word.Word; @@ -96,34 +106,39 @@ public void testIneqEqTree() { TreeQueryResult res = mto.treeQuery(prefix, symSuffix); SymbolicDecisionTree sdt = res.getSdt(); - final String expectedTree = "[r2, r1]-+\n" + -" []-(s1!=r2)\n" + -" | []-TRUE: s2\n" + -" | []-TRUE: s3\n" + -" | [Leaf-]\n" + -" +-(s1=r2)\n" + -" []-(s2=r1)\n" + -" | []-(s3!=s2)\n" + -" | | [Leaf-]\n" + -" | +-(s3=s2)\n" + -" | [Leaf+]\n" + -" +-(s2r1)\n" + -" []-(s3!=r1)\n" + -" | [Leaf-]\n" + -" +-(s3=r1)\n" + -" [Leaf+]\n"; - - String tree = sdt.toString(); - Assert.assertEquals(tree, expectedTree); - logger.log(Level.FINE, "final SDT: \n{0}", tree); - - Parameter p1 = new Parameter(PriorityQueueSUL.DOUBLE_TYPE, 1); - Parameter p2 = new Parameter(PriorityQueueSUL.DOUBLE_TYPE, 2); + SuffixValueGenerator sgen = new SuffixValueGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + ParameterGenerator pgen = new ParameterGenerator(); + SuffixValue s1 = sgen.next(PriorityQueueSUL.DOUBLE_TYPE); + SuffixValue s2 = sgen.next(PriorityQueueSUL.DOUBLE_TYPE); + SuffixValue s3 = sgen.next(PriorityQueueSUL.DOUBLE_TYPE); + Register r1 = rgen.next(PriorityQueueSUL.DOUBLE_TYPE); + Register r2 = rgen.next(PriorityQueueSUL.DOUBLE_TYPE); + Parameter p1 = pgen.next(PriorityQueueSUL.DOUBLE_TYPE); + Parameter p2 = pgen.next(PriorityQueueSUL.DOUBLE_TYPE); + PIV piv = new PIV(); + piv.put(p1, r1); + piv.put(p2, r2); + VarMapping renaming = new VarMapping<>(); + renaming.put(r1, res.getPiv().get(p1)); + renaming.put(r2, res.getPiv().get(p2)); + + SDT expected = new SDT(Map.of( + new EqualityGuard(s1,r1), new SDT(Map.of( + IntervalGuard.greaterGuard(s2, r2), new SDT(Map.of( + new EqualityGuard(s3, r2), SDTLeaf.ACCEPTING, + new DisequalityGuard(s3, r2), SDTLeaf.REJECTING)), + IntervalGuard.lessOrEqualGuard(s2, r2), new SDT(Map.of( + new EqualityGuard(s3, s2), SDTLeaf.ACCEPTING, + new DisequalityGuard(s3, s2), SDTLeaf.REJECTING)))), + new DisequalityGuard(s1, r1), new SDT(Map.of( + new SDTTrueGuard(s2), new SDT(Map.of( + new SDTTrueGuard(s3), SDTLeaf.REJECTING)))))); + + Assert.assertTrue(sdt.isEquivalent(expected, renaming)); + + p1 = new Parameter(PriorityQueueSUL.DOUBLE_TYPE, 1); + p2 = new Parameter(PriorityQueueSUL.DOUBLE_TYPE, 2); Parameter p3 = new Parameter(PriorityQueueSUL.DOUBLE_TYPE, 3); PIV testPiv = new PIV(); diff --git a/src/test/java/de/learnlib/ralib/theory/inequality/IneqGuardMergeTest.java b/src/test/java/de/learnlib/ralib/theory/inequality/IneqGuardMergeTest.java new file mode 100644 index 00000000..57fab0b1 --- /dev/null +++ b/src/test/java/de/learnlib/ralib/theory/inequality/IneqGuardMergeTest.java @@ -0,0 +1,426 @@ +package de.learnlib.ralib.theory.inequality; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import de.learnlib.ralib.RaLibTestSuite; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.SymbolicDataValue.Register; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.RegisterGenerator; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.oracles.mto.SDT; +import de.learnlib.ralib.oracles.mto.SDTLeaf; +import de.learnlib.ralib.theory.SDTGuard; +import de.learnlib.ralib.theory.SDTTrueGuard; +import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.theory.equality.DisequalityGuard; +import de.learnlib.ralib.theory.equality.EqualityGuard; +import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; + +public class IneqGuardMergeTest extends RaLibTestSuite { + + @Test + public void intervalMergeTest() { + + final DataType D_TYPE = new DataType("double", BigDecimal.class); + + final Map> teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + dit.useSuffixOptimization(true); + teachers.put(D_TYPE, dit); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(D_TYPE); + Register r1 = rgen.next(D_TYPE); + Register r2 = rgen.next(D_TYPE); + Register r3 = rgen.next(D_TYPE); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + DataValue dv4 = new DataValue(D_TYPE, BigDecimal.valueOf(4)); + DataValue dv5 = new DataValue(D_TYPE, BigDecimal.valueOf(5)); + DataValue dv6 = new DataValue(D_TYPE, BigDecimal.valueOf(6)); + + SDTGuard g0 = new IntervalGuard(s1, null, r1); + SDTGuard g1 = new EqualityGuard(s1, r1); + SDTGuard g2 = new IntervalGuard(s1, r1, r2); + SDTGuard g3 = new EqualityGuard(s1, r2); + SDTGuard g4 = new IntervalGuard(s1, r2, r3); + SDTGuard g5 = new EqualityGuard(s1, r3); + SDTGuard g6 = new IntervalGuard(s1, r3, null); + + Map, SDTGuard> equivClasses = new LinkedHashMap<>(); + equivClasses.put(dv0, g0); + equivClasses.put(dv1, g1); + equivClasses.put(dv2, g2); + equivClasses.put(dv3, g3); + equivClasses.put(dv4, g4); + equivClasses.put(dv5, g5); + equivClasses.put(dv6, g6); + + // test 1 + Map sdts1 = new LinkedHashMap<>(); + sdts1.put(g0, SDTLeaf.ACCEPTING); + sdts1.put(g1, SDTLeaf.ACCEPTING); + sdts1.put(g2, SDTLeaf.REJECTING); + sdts1.put(g3, SDTLeaf.REJECTING); + sdts1.put(g4, SDTLeaf.REJECTING); + sdts1.put(g5, SDTLeaf.ACCEPTING); + sdts1.put(g6, SDTLeaf.ACCEPTING); + + Map expected1 = new LinkedHashMap<>(); + expected1.put(IntervalGuard.lessOrEqualGuard(s1, r1), SDTLeaf.ACCEPTING); + expected1.put(new IntervalGuard(s1, r1, r3), SDTLeaf.REJECTING); + expected1.put(IntervalGuard.greaterOrEqualGuard(s1, r3), SDTLeaf.ACCEPTING); + + Map actual1 = dit.mergeGuards(sdts1, equivClasses, new ArrayList>()); + + Assert.assertEquals(actual1.size(), expected1.size()); + Assert.assertTrue(actual1.entrySet().containsAll(expected1.entrySet())); + + // test 2 + Map sdts2 = new LinkedHashMap<>(); + sdts2.put(g0, SDTLeaf.ACCEPTING); + sdts2.put(g1, SDTLeaf.ACCEPTING); + sdts2.put(g2, SDTLeaf.ACCEPTING); + sdts2.put(g3, SDTLeaf.REJECTING); + sdts2.put(g4, SDTLeaf.REJECTING); + sdts2.put(g5, SDTLeaf.REJECTING); + sdts2.put(g6, SDTLeaf.ACCEPTING); + + Map expected2 = new LinkedHashMap<>(); + expected2.put(IntervalGuard.lessGuard(s1, r2), SDTLeaf.ACCEPTING); + expected2.put(new IntervalGuard(s1, r2, r3, true, true), SDTLeaf.REJECTING); + expected2.put(g6, SDTLeaf.ACCEPTING); + + Map actual2 = dit.mergeGuards(sdts2, equivClasses, new ArrayList>()); + + Assert.assertEquals(actual2.size(), expected2.size()); + Assert.assertTrue(actual2.entrySet().containsAll(expected2.entrySet())); + + // test 3 + Map sdts3 = new LinkedHashMap<>(); + sdts3.put(g0, SDTLeaf.ACCEPTING); + sdts3.put(g1, SDTLeaf.REJECTING); + sdts3.put(g2, SDTLeaf.ACCEPTING); + sdts3.put(g3, SDTLeaf.ACCEPTING); + sdts3.put(g4, SDTLeaf.REJECTING); + sdts3.put(g5, SDTLeaf.REJECTING); + sdts3.put(g6, SDTLeaf.REJECTING); + + Map expected3 = new LinkedHashMap<>(); + expected3.put(g0, SDTLeaf.ACCEPTING); + expected3.put(g1, SDTLeaf.REJECTING); + expected3.put(new IntervalGuard(s1, r1, r2, false, true), SDTLeaf.ACCEPTING); + expected3.put(IntervalGuard.greaterGuard(s1, r2), SDTLeaf.REJECTING); + + Map actual3 = dit.mergeGuards(sdts3, equivClasses, new ArrayList>()); + + Assert.assertEquals(actual3.size(), expected3.size()); + Assert.assertTrue(actual3.entrySet().containsAll(expected3.entrySet())); + + // test 4 + Map sdts4 = new LinkedHashMap<>(); + sdts4.put(g0, SDTLeaf.ACCEPTING); + sdts4.put(g1, SDTLeaf.REJECTING); + sdts4.put(g2, SDTLeaf.REJECTING); + sdts4.put(g3, SDTLeaf.ACCEPTING); + sdts4.put(g4, SDTLeaf.REJECTING); + sdts4.put(g5, SDTLeaf.ACCEPTING); + sdts4.put(g6, SDTLeaf.REJECTING); + + Map expected4 = new LinkedHashMap<>(); + expected4.put(g0, SDTLeaf.ACCEPTING); + expected4.put(new IntervalGuard(s1, r1, r2, true, false), SDTLeaf.REJECTING); + expected4.put(g3, SDTLeaf.ACCEPTING); + expected4.put(g4, SDTLeaf.REJECTING); + expected4.put(g5, SDTLeaf.ACCEPTING); + expected4.put(g6, SDTLeaf.REJECTING); + + Map actual4 = dit.mergeGuards(sdts4, equivClasses, new ArrayList>()); + + Assert.assertEquals(actual4.size(), expected4.size()); + Assert.assertTrue(actual4.entrySet().containsAll(expected4.entrySet())); + } + + @Test + public void trueGuardTest() { + + final DataType D_TYPE = new DataType("double", BigDecimal.class); + + final Map> teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + dit.useSuffixOptimization(true); + teachers.put(D_TYPE, dit); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(D_TYPE); + Register r1 = rgen.next(D_TYPE); + Register r2 = rgen.next(D_TYPE); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + DataValue dv4 = new DataValue(D_TYPE, BigDecimal.valueOf(4)); + + SDTGuard g0 = new IntervalGuard(s1, null, r1); + SDTGuard g1 = new EqualityGuard(s1, r1); + SDTGuard g2 = new IntervalGuard(s1, r1, r2); + SDTGuard g3 = new EqualityGuard(s1, r2); + SDTGuard g4 = new IntervalGuard(s1, r2, null); + + Map, SDTGuard> equivClasses = new LinkedHashMap<>(); + equivClasses.put(dv0, g0); + equivClasses.put(dv1, g1); + equivClasses.put(dv2, g2); + equivClasses.put(dv3, g3); + equivClasses.put(dv4, g4); + + Map sdts1 = new LinkedHashMap<>(); + sdts1.put(g0, SDTLeaf.ACCEPTING); + sdts1.put(g1, SDTLeaf.ACCEPTING); + sdts1.put(g2, SDTLeaf.ACCEPTING); + sdts1.put(g3, SDTLeaf.ACCEPTING); + sdts1.put(g4, SDTLeaf.ACCEPTING); + + Map merged = dit.mergeGuards(sdts1, equivClasses, new ArrayList<>()); + + Assert.assertEquals(merged.size(), 1); + Assert.assertTrue(merged.containsKey(new SDTTrueGuard(s1))); + } + + @Test + public void filteredDataValuesTest() { + + final DataType D_TYPE = new DataType("double", BigDecimal.class); + + final Map> teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + dit.useSuffixOptimization(true); + teachers.put(D_TYPE, dit); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(D_TYPE); + Register r1 = rgen.next(D_TYPE); + Register r2 = rgen.next(D_TYPE); + Register r3 = rgen.next(D_TYPE); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + DataValue dv4 = new DataValue(D_TYPE, BigDecimal.valueOf(4)); + DataValue dv5 = new DataValue(D_TYPE, BigDecimal.valueOf(5)); + DataValue dv6 = new DataValue(D_TYPE, BigDecimal.valueOf(6)); + + SDTGuard g0 = new IntervalGuard(s1, null, r1); + SDTGuard g1 = new EqualityGuard(s1, r1); + SDTGuard g2 = new IntervalGuard(s1, r1, r2); + SDTGuard g3 = new EqualityGuard(s1, r2); + SDTGuard g4 = new IntervalGuard(s1, r2, r3); + SDTGuard g5 = new EqualityGuard(s1, r3); + SDTGuard g6 = new IntervalGuard(s1, r3, null); + + Map, SDTGuard> equivClasses = new LinkedHashMap<>(); + equivClasses.put(dv0, g0); + equivClasses.put(dv1, g1); + equivClasses.put(dv2, g2); + equivClasses.put(dv3, g3); + equivClasses.put(dv4, g4); + equivClasses.put(dv5, g5); + equivClasses.put(dv6, g6); + + Map sdts = new LinkedHashMap<>(); + sdts.put(g1, SDTLeaf.ACCEPTING); + sdts.put(g2, SDTLeaf.ACCEPTING); + sdts.put(g5, SDTLeaf.REJECTING); + + List> filtered = new ArrayList<>(); + filtered.add(dv0); + filtered.add(dv3); + filtered.add(dv4); + filtered.add(dv6); + + Map expected = new LinkedHashMap<>(); + expected.put(new IntervalGuard(s1, r1, r2, true, false), SDTLeaf.ACCEPTING); + expected.put(g5, SDTLeaf.REJECTING); + + Map actual = dit.mergeGuards(sdts, equivClasses, filtered); + + Assert.assertEquals(actual.size(), expected.size()); + Assert.assertTrue(actual.entrySet().containsAll(expected.entrySet())); + } + + @Test + public void sdtSubtreeTest() { + + final DataType D_TYPE = new DataType("double", BigDecimal.class); + + final Map> teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + dit.useSuffixOptimization(true); + teachers.put(D_TYPE, dit); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(D_TYPE); + Register r1 = rgen.next(D_TYPE); + Register r2 = rgen.next(D_TYPE); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + DataValue dv4 = new DataValue(D_TYPE, BigDecimal.valueOf(4)); + + SDTGuard g0 = new IntervalGuard(s1, null, r1); + SDTGuard g1 = new EqualityGuard(s1, r1); + SDTGuard g2 = new IntervalGuard(s1, r1, r2); + SDTGuard g3 = new EqualityGuard(s1, r2); + SDTGuard g4 = new IntervalGuard(s1, r2, null); + + Map, SDTGuard> equivClasses = new LinkedHashMap<>(); + equivClasses.put(dv0, g0); + equivClasses.put(dv1, g1); + equivClasses.put(dv2, g2); + equivClasses.put(dv3, g3); + equivClasses.put(dv4, g4); + + SDT sdt1 = new SDT(Map.of( + new EqualityGuard(s1, r1), SDTLeaf.ACCEPTING, + new DisequalityGuard(s1, r1), SDTLeaf.REJECTING)); + SDT sdt2 = new SDT(Map.of( + new IntervalGuard(s1, r1, r2), SDTLeaf.ACCEPTING)); + SDT sdt3 = new SDT(Map.of( + new IntervalGuard(s1, r2, r1), SDTLeaf.ACCEPTING)); + + Map sdts = new LinkedHashMap<>(); + sdts.put(g0, sdt1); + sdts.put(g1, sdt1); + sdts.put(g2, sdt2); + sdts.put(g3, sdt2); + sdts.put(g4, sdt3); + + Map expected = new LinkedHashMap<>(); + expected.put(IntervalGuard.lessOrEqualGuard(s1, r1), sdt1); + expected.put(new IntervalGuard(s1, r1, r2, false, true), sdt2); + expected.put(g4, sdt3); + + Map actual = dit.mergeGuards(sdts, equivClasses, new ArrayList<>()); + + Assert.assertEquals(actual.size(), expected.size()); + Assert.assertTrue(actual.entrySet().containsAll(expected.entrySet())); + } + + @Test + public void disequalityGuardTest() { + + final DataType D_TYPE = new DataType("double", BigDecimal.class); + + final Map> teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + dit.useSuffixOptimization(true); + teachers.put(D_TYPE, dit); + + SuffixValueGenerator svgen = new SuffixValueGenerator(); + RegisterGenerator rgen = new RegisterGenerator(); + + SuffixValue s1 = svgen.next(D_TYPE); + SuffixValue s2 = svgen.next(D_TYPE); + Register r1 = rgen.next(D_TYPE); + Register r2 = rgen.next(D_TYPE); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + DataValue dv4 = new DataValue(D_TYPE, BigDecimal.valueOf(4)); + + SDTGuard g0 = new IntervalGuard(s1, null, r1); + SDTGuard g1 = new EqualityGuard(s1, r1); + SDTGuard g2 = new IntervalGuard(s1, r1, r2); + SDTGuard g3 = new EqualityGuard(s1, r2); + SDTGuard g4 = new IntervalGuard(s1, r2, null); + + Map, SDTGuard> equivClasses = new LinkedHashMap<>(); + equivClasses.put(dv0, g0); + equivClasses.put(dv1, g1); + equivClasses.put(dv2, g2); + equivClasses.put(dv3, g3); + equivClasses.put(dv4, g4); + + Map sdts1 = new LinkedHashMap<>(); + sdts1.put(g0, SDTLeaf.REJECTING); + sdts1.put(g1, SDTLeaf.ACCEPTING); + sdts1.put(g2, SDTLeaf.REJECTING); + sdts1.put(g3, SDTLeaf.REJECTING); + sdts1.put(g4, SDTLeaf.REJECTING); + + List> filteredOut = new ArrayList<>(); + filteredOut.add(dv1); + + Map expected1 = new LinkedHashMap<>(); + expected1.put(new SDTTrueGuard(s1), SDTLeaf.REJECTING); + Map actual1 = dit.mergeGuards(sdts1, equivClasses, filteredOut); + + Assert.assertEquals(actual1.size(), expected1.size()); + Assert.assertTrue(actual1.entrySet().containsAll(expected1.entrySet())); + + // test 2 + Map sdts2 = sdts1; + + Map expected2 = new LinkedHashMap<>(); + expected2.put(new DisequalityGuard(s1, r1), SDTLeaf.REJECTING); + expected2.put(g1, SDTLeaf.ACCEPTING); + Map actual2 = dit.mergeGuards(sdts2, equivClasses, new ArrayList<>()); + + Assert.assertEquals(actual2.size(), expected2.size()); + Assert.assertTrue(actual2.entrySet().containsAll(expected2.entrySet())); + + // test 3 + SDT sdt1 = new SDT(Map.of( + new EqualityGuard(s2, r1), SDTLeaf.ACCEPTING, + new DisequalityGuard(s2, r1), SDTLeaf.REJECTING)); + SDT sdt2 = new SDT(Map.of( + new IntervalGuard(s2, r1, null), SDTLeaf.REJECTING, + new IntervalGuard(s2, r1, r2), SDTLeaf.ACCEPTING, + new IntervalGuard(s2, null, r2), SDTLeaf.REJECTING)); + SDT sdt3 = new SDT(Map.of( + new EqualityGuard(s2, r1), SDTLeaf.REJECTING, + new DisequalityGuard(s2, r2), SDTLeaf.ACCEPTING)); + + Map sdts3 = new LinkedHashMap<>(); + sdts3.put(g0, sdt1); + sdts3.put(g1, sdt1); + sdts3.put(g2, sdt1); + sdts3.put(g3, sdt2); + sdts3.put(g4, sdt3); + + Map expected3 = new LinkedHashMap<>(); + expected3.put(new IntervalGuard(s1, null, r2), sdt1); + expected3.put(g3, sdt2); + expected3.put(g4, sdt3); + Map actual3 = dit.mergeGuards(sdts3, equivClasses, new ArrayList<>()); + + Assert.assertEquals(actual3.size(), expected3.size()); + Assert.assertTrue(actual3.entrySet().containsAll(expected3.entrySet())); + } +} diff --git a/src/test/java/de/learnlib/ralib/theory/inequality/IneqTheoryRestrictionsTest.java b/src/test/java/de/learnlib/ralib/theory/inequality/IneqTheoryRestrictionsTest.java new file mode 100644 index 00000000..e8cc2fd1 --- /dev/null +++ b/src/test/java/de/learnlib/ralib/theory/inequality/IneqTheoryRestrictionsTest.java @@ -0,0 +1,91 @@ +package de.learnlib.ralib.theory.inequality; + +import java.math.BigDecimal; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import de.learnlib.ralib.RaLibTestSuite; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.data.util.SymbolicDataValueGenerator.SuffixValueGenerator; +import de.learnlib.ralib.learning.SymbolicSuffix; +import de.learnlib.ralib.oracles.mto.SymbolicSuffixRestrictionBuilder; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; +import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; +import de.learnlib.ralib.words.DataWords; +import de.learnlib.ralib.words.InputSymbol; +import de.learnlib.ralib.words.PSymbolInstance; +import net.automatalib.word.Word; + +public class IneqTheoryRestrictionsTest extends RaLibTestSuite { + + private final DataType D_TYPE = new DataType("double", BigDecimal.class); + + private final InputSymbol A = new InputSymbol("a", D_TYPE); + + @Test + public void optimizationFromConcreteValuesTest() { + + final Map teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + dit.useSuffixOptimization(true); + teachers.put(D_TYPE, dit); + + Constants consts = new Constants(); + SymbolicSuffixRestrictionBuilder builder = new SymbolicSuffixRestrictionBuilder(consts, teachers); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + + SuffixValueGenerator sgen = new SuffixValueGenerator(); + SuffixValue s1 = sgen.next(D_TYPE); + SuffixValue s2 = sgen.next(D_TYPE); + SuffixValue s3 = sgen.next(D_TYPE); + SuffixValue s4 = sgen.next(D_TYPE); + + Word prefix1 = Word.fromSymbols(new PSymbolInstance(A, dv0)); + Word suffix1 = Word.fromSymbols( + new PSymbolInstance(A, dv0), + new PSymbolInstance(A, dv2), + new PSymbolInstance(A, dv1), + new PSymbolInstance(A, dv3)); + + Map restr1 = new LinkedHashMap<>(); + restr1.put(s1, new UnrestrictedSuffixValue(s1)); + restr1.put(s2, new GreaterSuffixValue(s2)); + restr1.put(s3, new UnrestrictedSuffixValue(s3)); + restr1.put(s4, new GreaterSuffixValue(s4)); + + SymbolicSuffix expected1 = new SymbolicSuffix(DataWords.actsOf(suffix1), restr1); + SymbolicSuffix actual1 = new SymbolicSuffix(prefix1, suffix1, builder); + + Assert.assertEquals(actual1, expected1); + + Word prefix2 = Word.epsilon(); + Word suffix2 = Word.fromSymbols( + new PSymbolInstance(A, dv2), + new PSymbolInstance(A, dv0), + new PSymbolInstance(A, dv1), + new PSymbolInstance(A, dv0)); + + Map restr2 = new LinkedHashMap<>(); + restr2.put(s1, new UnrestrictedSuffixValue(s1)); + restr2.put(s2, new LesserSuffixValue(s2)); + restr2.put(s3, new UnrestrictedSuffixValue(s3)); + restr2.put(s4, new UnrestrictedSuffixValue(s4)); + + SymbolicSuffix expected2 = new SymbolicSuffix(DataWords.actsOf(suffix2), restr2); + SymbolicSuffix actual2 = new SymbolicSuffix(prefix2, suffix2, builder); + + Assert.assertEquals(actual2, expected2); + } +} diff --git a/src/test/java/de/learnlib/ralib/theory/inequality/IntervalGuardInstaniateTest.java b/src/test/java/de/learnlib/ralib/theory/inequality/IntervalGuardInstaniateTest.java new file mode 100644 index 00000000..b7dbc09f --- /dev/null +++ b/src/test/java/de/learnlib/ralib/theory/inequality/IntervalGuardInstaniateTest.java @@ -0,0 +1,76 @@ +package de.learnlib.ralib.theory.inequality; + +import static de.learnlib.ralib.solver.jconstraints.JContraintsUtil.toVariable; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import de.learnlib.ralib.RaLibTestSuite; +import de.learnlib.ralib.data.Constants; +import de.learnlib.ralib.data.DataType; +import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.SymbolicDataValue.Register; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; +import de.learnlib.ralib.theory.Theory; +import de.learnlib.ralib.tools.theories.DoubleInequalityTheory; +import gov.nasa.jpf.constraints.api.Valuation; + +public class IntervalGuardInstaniateTest extends RaLibTestSuite { + + @Test + public void instantiateIntervalTest() { + + final DataType D_TYPE = new DataType("double", BigDecimal.class); + + final Map> teachers = new LinkedHashMap<>(); + DoubleInequalityTheory dit = new DoubleInequalityTheory(D_TYPE); + teachers.put(D_TYPE, dit); + + SuffixValue s1 = new SuffixValue(D_TYPE, 1); + Register r1 = new Register(D_TYPE, 1); + Register r2 = new Register(D_TYPE, 2); + + DataValue dv0 = new DataValue(D_TYPE, BigDecimal.ZERO); + DataValue dv1 = new DataValue(D_TYPE, BigDecimal.ONE); + DataValue dv2 = new DataValue(D_TYPE, BigDecimal.valueOf(2)); + DataValue dv3 = new DataValue(D_TYPE, BigDecimal.valueOf(3)); + DataValue dv4 = new DataValue(D_TYPE, BigDecimal.valueOf(4)); + + Valuation val = new Valuation(); + val.setValue(toVariable(r1), dv1.getId()); + val.setValue(toVariable(r2), dv2.getId()); + + Collection> alreadyUsed = new ArrayList<>(); + alreadyUsed.add(dv1); + alreadyUsed.add(dv2); + + Constants consts = new Constants(); + + IntervalGuard lg = IntervalGuard.lessGuard(s1, r1); + IntervalGuard leg = IntervalGuard.lessOrEqualGuard(s1, r1); + IntervalGuard rg = IntervalGuard.greaterGuard(s1, r1); + IntervalGuard reg = IntervalGuard.greaterOrEqualGuard(s1, r1); + IntervalGuard ig = new IntervalGuard(s1, r1, r2); + IntervalGuard igc = new IntervalGuard(s1, r1, r2, true, true); + + DataValue dvl = dit.instantiate(lg, val, consts, alreadyUsed); + DataValue dvle = dit.instantiate(leg, val, consts, alreadyUsed); + DataValue dvr = dit.instantiate(rg, val, consts, alreadyUsed); + DataValue dvre = dit.instantiate(reg, val, consts, alreadyUsed); + DataValue dvi = dit.instantiate(ig, val, consts, alreadyUsed); + DataValue dvic = dit.instantiate(igc, val, consts, alreadyUsed); + + Assert.assertEquals(dvl.getId().compareTo(dv1.getId()), -1); + Assert.assertNotEquals(dvle.getId().compareTo(dv1.getId()), 1); + Assert.assertEquals(dvr.getId().compareTo(dv1.getId()), 1); + Assert.assertNotEquals(dvre.getId().compareTo(dv1.getId()), -1); + Assert.assertTrue(dvi.getId().compareTo(dv1.getId()) == 1 && dvi.getId().compareTo(dv3.getId()) == -1); + Assert.assertFalse(dvic.getId().compareTo(dv1.getId()) == -1 && dvic.getId().compareTo(dv3.getId()) == 1); + } +} diff --git a/src/test/java/de/learnlib/ralib/words/TestWords.java b/src/test/java/de/learnlib/ralib/words/TestWords.java index 47a55628..dfd7200c 100644 --- a/src/test/java/de/learnlib/ralib/words/TestWords.java +++ b/src/test/java/de/learnlib/ralib/words/TestWords.java @@ -22,6 +22,9 @@ import static de.learnlib.ralib.example.login.LoginAutomatonExample.T_PWD; import static de.learnlib.ralib.example.login.LoginAutomatonExample.T_UID; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.Map; import java.util.logging.Level; import org.testng.Assert; @@ -30,7 +33,12 @@ import de.learnlib.ralib.RaLibTestSuite; import de.learnlib.ralib.data.DataType; import de.learnlib.ralib.data.DataValue; +import de.learnlib.ralib.data.SymbolicDataValue.SuffixValue; import de.learnlib.ralib.learning.SymbolicSuffix; +import de.learnlib.ralib.theory.FreshSuffixValue; +import de.learnlib.ralib.theory.SuffixValueRestriction; +import de.learnlib.ralib.theory.UnrestrictedSuffixValue; +import de.learnlib.ralib.theory.equality.EqualRestriction; import net.automatalib.word.Word; /** @@ -71,8 +79,17 @@ public void testSymbolicSuffix1() { SymbolicSuffix sym = new SymbolicSuffix(prefix, suffix); logger.log(Level.FINE, "Symbolic Suffix: {0}", sym); - String expString = "[s1, s3]((a[s1] a[s2] a[s2] a[s3]))"; - Assert.assertEquals(sym.toString(), expString); + Collection symSVs = sym.getDataValues(); + SuffixValue[] symSVArr = symSVs.toArray(new SuffixValue[symSVs.size()]); + Map expRestr = new LinkedHashMap<>(); + expRestr.put(symSVArr[0], new UnrestrictedSuffixValue(symSVArr[0])); + expRestr.put(symSVArr[1], new FreshSuffixValue(symSVArr[1])); + expRestr.put(symSVArr[2], new EqualRestriction(symSVArr[2], symSVArr[1])); + expRestr.put(symSVArr[3], new UnrestrictedSuffixValue(symSVArr[3])); + SymbolicSuffix exp = new SymbolicSuffix(sym.getActions(), expRestr); + Assert.assertEquals(sym, exp); +// String expString = "[s1, s3]((a[s1] a[s2] a[s2] a[s3]))"; +// Assert.assertEquals(sym.toString(), expString); } @Test @@ -106,8 +123,8 @@ public void testSymbolicSuffix2() { logger.log(Level.FINE, "Sym. Suffix 1: {0}", symSuffix1); logger.log(Level.FINE, "Sym. Suffix 2: {0}", symSuffix2); - String expected1 = "[s1, s2]((login[s1, s2]))"; - String expected2 = "[s1, s2]((logout[] login[s1, s2]))"; + String expected1 = "((login[s1, s2]))[Unrestricted(s1), Unrestricted(s2)]"; + String expected2 = "((logout[] login[s1, s2]))[Unrestricted(s1), Unrestricted(s2)]"; Assert.assertEquals(symSuffix1.toString(), expected1); Assert.assertEquals(symSuffix2.toString(), expected2);