diff --git a/cif/org.eclipse.escet.cif.bdd/src-test/org/eclipse/escet/cif/bdd/workset/dependencies/BddBasedEdgeDependencySetCreatorTest.java b/cif/org.eclipse.escet.cif.bdd/src-test/org/eclipse/escet/cif/bdd/workset/dependencies/BddBasedEdgeDependencySetCreatorTest.java index 7eb64e751bd7c1f89e0e0af9e44f4f2bae49ffba..25fab00fb9e32f77555e05f43f21170f3a034954 100644 --- a/cif/org.eclipse.escet.cif.bdd/src-test/org/eclipse/escet/cif/bdd/workset/dependencies/BddBasedEdgeDependencySetCreatorTest.java +++ b/cif/org.eclipse.escet.cif.bdd/src-test/org/eclipse/escet/cif/bdd/workset/dependencies/BddBasedEdgeDependencySetCreatorTest.java @@ -21,6 +21,7 @@ import java.util.stream.Collectors; import org.eclipse.escet.cif.bdd.conversion.CifToBddConverter; import org.eclipse.escet.cif.bdd.settings.CifBddSettings; import org.eclipse.escet.cif.bdd.settings.EdgeGranularity; +import org.eclipse.escet.cif.bdd.settings.ExplorationStrategy; import org.eclipse.escet.cif.bdd.spec.CifBddEdge; import org.eclipse.escet.cif.bdd.spec.CifBddSpec; import org.eclipse.escet.cif.io.CifReader; @@ -540,7 +541,7 @@ public class BddBasedEdgeDependencySetCreatorTest { // Get settings. CifBddSettings settings = new CifBddSettings(); settings.setEdgeGranularity(EdgeGranularity.PER_EVENT); - settings.setDoUseEdgeWorksetAlgo(true); + settings.setExplorationStrategy(ExplorationStrategy.CHAINING_WORKSET); settings.setEdgeOrderBackward("sorted"); settings.setEdgeOrderForward("sorted"); diff --git a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/conversion/CifToBddConverter.java b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/conversion/CifToBddConverter.java index 0c940a5ab4e61b8984ec3c4a134d3daa3131120c..607bb6c58ec86a76c3f6ca0127dd4978f971f312 100644 --- a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/conversion/CifToBddConverter.java +++ b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/conversion/CifToBddConverter.java @@ -61,6 +61,7 @@ import org.eclipse.escet.cif.bdd.settings.CifBddSettings; import org.eclipse.escet.cif.bdd.settings.CifBddStatistics; import org.eclipse.escet.cif.bdd.settings.EdgeGranularity; import org.eclipse.escet.cif.bdd.settings.EdgeOrderDuplicateEventAllowance; +import org.eclipse.escet.cif.bdd.settings.ExplorationStrategy; import org.eclipse.escet.cif.bdd.spec.CifBddDiscVariable; import org.eclipse.escet.cif.bdd.spec.CifBddEdge; import org.eclipse.escet.cif.bdd.spec.CifBddInputVariable; @@ -588,6 +589,12 @@ public class CifToBddConverter { return cifBddSpec; } + // Check saturation settings. + checkSaturationSettings(cifBddSpec.settings); + if (cifBddSpec.settings.getTermination().isRequested()) { + return cifBddSpec; + } + // Return the conversion result, the CIF/BDD specification. return cifBddSpec; } @@ -2165,7 +2172,7 @@ public class CifToBddConverter { */ private void checkEdgeWorksetAlgorithmSettings(CifBddSettings settings) { // Skip if workset algorithm is disabled. - if (!settings.getDoUseEdgeWorksetAlgo()) { + if (settings.getExplorationStrategy() != ExplorationStrategy.CHAINING_WORKSET) { return; } @@ -2182,6 +2189,25 @@ public class CifToBddConverter { } } + /** + * Check saturation settings. + * + * @param settings The settings. + */ + private void checkSaturationSettings(CifBddSettings settings) { + // Skip if saturation is disabled. + if (settings.getExplorationStrategy() != ExplorationStrategy.SATURATION) { + return; + } + + // Saturation requires no duplicate edges in the edge order. + if (settings.getEdgeOrderAllowDuplicateEvents() == EdgeOrderDuplicateEventAllowance.ALLOWED) { + throw new InvalidOptionException( + "Saturation can not be used with duplicate events in the edge order. " + + "Either disable saturation, or disable duplicates for custom edge orders."); + } + } + /** * Converts CIF predicates to a BDD predicate, assuming conjunction between the CIF predicates. * diff --git a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettings.java b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettings.java index 7d6690117b9033113c505116186a11ed35f4eda1..d8588d7819186bcf9eacca6f6aa143fa9aad479f 100644 --- a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettings.java +++ b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettings.java @@ -128,11 +128,8 @@ public class CifBddSettings { /** Whether duplicate events are allowed for custom edge orders. */ private EdgeOrderDuplicateEventAllowance edgeOrderAllowDuplicateEvents = CifBddSettingsDefaults.EDGE_ORDER_ALLOW_DUPLICATES_EVENTS_DEFAULT; - /** - * Whether to use the edge workset algorithm to dynamically choose the best edge to apply during reachability - * computations ({@code true}), or not ({@code false}). - */ - private boolean doUseEdgeWorksetAlgo = CifBddSettingsDefaults.DO_USE_WORKSET_ALGO_DEFAULT; + /** The exploration strategy to use for symbolic reachability computations. */ + private ExplorationStrategy explorationStrategy = CifBddSettingsDefaults.EXPLORATION_STRATEGY_DEFAULT; /** The kinds of statistics to print. */ private EnumSet<CifBddStatistics> cifBddStatistics = CifBddSettingsDefaults.CIF_BDD_STATISTICS_DEFAULT.clone(); @@ -740,28 +737,26 @@ public class CifBddSettings { } /** - * Get whether to use the edge workset algorithm to dynamically choose the best edge to apply during reachability - * computations. + * Get the exploration strategy to use for symbolic reachability computations. * * <p> - * {@link CifBddSettingsDefaults#DO_USE_WORKSET_ALGO_DEFAULT} is the default value. + * {@link CifBddSettingsDefaults#EXPLORATION_STRATEGY_DEFAULT} is the default value. * </p> * - * @return {@code true} to use the edge workset algorithm, {@code false} to not use it. + * @return The exploration strategy to use for symbolic reachability computations. */ - public boolean getDoUseEdgeWorksetAlgo() { - return doUseEdgeWorksetAlgo; + public ExplorationStrategy getExplorationStrategy() { + return explorationStrategy; } /** - * Set whether to use the edge workset algorithm to dynamically choose the best edge to apply during reachability - * computations. + * Set the exploration strategy to use for symbolic reachability computations. * - * @param doUseEdgeWorksetAlgo {@code true} to use the edge workset algorithm, {@code false} to not use it. + * @param explorationStrategy The exploration strategy to use for symbolic reachability computations. */ - public void setDoUseEdgeWorksetAlgo(boolean doUseEdgeWorksetAlgo) { + public void setExplorationStrategy(ExplorationStrategy explorationStrategy) { Assert.check(modificationAllowed, "Modification is not allowed."); - this.doUseEdgeWorksetAlgo = doUseEdgeWorksetAlgo; + this.explorationStrategy = explorationStrategy; checkSettings(); } diff --git a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettingsDefaults.java b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettingsDefaults.java index 0923ab829e5ec871f0a4cd7b2404292a17998cc8..794c78f9e55a43c8ff499f33764a7b7b2a723040 100644 --- a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettingsDefaults.java +++ b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/CifBddSettingsDefaults.java @@ -71,8 +71,8 @@ public class CifBddSettingsDefaults { /** The default value of the {@link CifBddSettings#getEdgeOrderAllowDuplicateEvents} setting. */ public static final EdgeOrderDuplicateEventAllowance EDGE_ORDER_ALLOW_DUPLICATES_EVENTS_DEFAULT = EdgeOrderDuplicateEventAllowance.DISALLOWED; - /** The default value of the {@link CifBddSettings#getDoUseEdgeWorksetAlgo} setting. */ - public static final boolean DO_USE_WORKSET_ALGO_DEFAULT = false; + /** The default value of the {@link CifBddSettings#getExplorationStrategy} setting. */ + public static final ExplorationStrategy EXPLORATION_STRATEGY_DEFAULT = ExplorationStrategy.SATURATION; /** * The default value of the {@link CifBddSettings#getCifBddStatistics} setting. Do not modify this set, but diff --git a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/ExplorationStrategy.java b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/ExplorationStrategy.java new file mode 100644 index 0000000000000000000000000000000000000000..25a3be87fbe4f49ac415db22456eb9eac1250108 --- /dev/null +++ b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/settings/ExplorationStrategy.java @@ -0,0 +1,26 @@ +////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2024 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available +// under the terms of the MIT License which is available at +// https://opensource.org/licenses/MIT +// +// SPDX-License-Identifier: MIT +////////////////////////////////////////////////////////////////////////////// + +package org.eclipse.escet.cif.bdd.settings; + +/** Exploration strategy for symbolic reachability computations. */ +public enum ExplorationStrategy { + /** Use the chaining strategy with a fixed edge ordering. */ + CHAINING_FIXED, + + /** Use the chaining strategy with a dynamic edge ordering as determined by the edge workset algorithm. */ + CHAINING_WORKSET, + + /** Use the saturation strategy. */ + SATURATION; +} diff --git a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/spec/CifBddEdge.java b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/spec/CifBddEdge.java index bfb3d3db7c03ecfcee53c7de76d8be4a741a5b53..a7062afbeef6ab6a9918ff56730441618961427d 100644 --- a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/spec/CifBddEdge.java +++ b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/spec/CifBddEdge.java @@ -80,7 +80,7 @@ public class CifBddEdge { public BDD updateGuard; /** Precomputed BDD variable support for {@link #updateGuard}. Is {@code null} if not available. */ - private BDDVarSet updateGuardSupport; + public BDDVarSet updateGuardSupport; /** * The runtime error predicate. Indicates the states prior to taking the edge will result in a runtime error when @@ -145,13 +145,15 @@ public class CifBddEdge { } /** - * Returns the variable support for the given relation, including all variables that are assigned on this edge. + * Returns the variable support for the given relation, including the old-state and new-state BDD variables of all + * CIF/BDD variables that are assigned on this edge. * * @param relation The relation for which to compute the BDD variable support. * @return The BDD variable support for the given relation. */ private BDDVarSet getSupportFor(BDD relation) { - return assignedVariables.stream().map(v -> v.domainNew.set()).reduce(relation.support(), BDDVarSet::unionWith); + return assignedVariables.stream().map(v -> v.domain.set().union(v.domainNew.set())).reduce(relation.support(), + BDDVarSet::unionWith); } /** diff --git a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/utils/CifBddReachability.java b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/utils/CifBddReachability.java index 068a5ae4fdb9fcf8862a364c184fb90c7d2139f5..11545ff302cc6624e2b632e5874c2fba3005727e 100644 --- a/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/utils/CifBddReachability.java +++ b/cif/org.eclipse.escet.cif.bdd/src/org/eclipse/escet/cif/bdd/utils/CifBddReachability.java @@ -19,11 +19,15 @@ import static org.eclipse.escet.common.java.Pair.pair; import static org.eclipse.escet.common.java.Strings.fmt; import java.util.BitSet; +import java.util.Comparator; import java.util.List; +import java.util.Map; import java.util.Set; import java.util.function.Predicate; +import java.util.stream.Collectors; import java.util.stream.IntStream; +import org.eclipse.escet.cif.bdd.settings.ExplorationStrategy; import org.eclipse.escet.cif.bdd.spec.CifBddEdge; import org.eclipse.escet.cif.bdd.spec.CifBddEdgeApplyDirection; import org.eclipse.escet.cif.bdd.spec.CifBddEdgeKind; @@ -36,10 +40,12 @@ import org.eclipse.escet.cif.bdd.workset.selectors.FirstEdgeSelector; import org.eclipse.escet.cif.bdd.workset.selectors.PruningEdgeSelector; import org.eclipse.escet.common.java.Assert; import org.eclipse.escet.common.java.BitSets; +import org.eclipse.escet.common.java.Lists; import org.eclipse.escet.common.java.Pair; import org.eclipse.escet.common.java.Strings; import com.github.javabdd.BDD; +import com.github.javabdd.BDDVarSet; /** CIF/BDD reachability computations. */ public class CifBddReachability { @@ -80,6 +86,9 @@ public class CifBddReachability { /** Whether debug output is enabled. */ private final boolean dbgEnabled; + /** The instance number to use for saturation. */ + private Integer saturationInstance; + /** * Constructor for the {@link CifBddReachability} class. * @@ -109,6 +118,17 @@ public class CifBddReachability { this.direction = direction; this.edgeKinds = edgeKinds; this.dbgEnabled = dbgEnabled; + this.saturationInstance = null; + } + + /** + * Set the instance number to use for saturation. This number must be unique for the list of edges with which + * saturation is performed, and will be used internally for caching purposes. + * + * @param instance The instance number. + */ + public void setSaturationInstance(int instance) { + this.saturationInstance = instance; } /** @@ -151,25 +171,29 @@ public class CifBddReachability { } // Determine the edges to be applied. - boolean useWorkSetAlgo = cifBddSpec.settings.getDoUseEdgeWorksetAlgo(); List<CifBddEdge> orderedEdges = (direction == CifBddEdgeApplyDirection.FORWARD) ? cifBddSpec.orderedEdgesForward : cifBddSpec.orderedEdgesBackward; Predicate<CifBddEdge> edgeShouldBeApplied = e -> edgeKinds.contains(e.getEdgeKind()); List<CifBddEdge> edgesToApply = orderedEdges.stream().filter(edgeShouldBeApplied).toList(); - BitSet edgesToApplyMask = useWorkSetAlgo ? IntStream.range(0, orderedEdges.size()) - .filter(i -> edgeShouldBeApplied.test(orderedEdges.get(i))).boxed().collect(BitSets.toBitSet()) : null; // Apply edges until we get a fixed point. if (cifBddSpec.settings.getTermination().isRequested()) { return null; } - Pair<BDD, Boolean> reachabilityResult; - if (useWorkSetAlgo) { - reachabilityResult = performReachabilityWorkset(pred, orderedEdges, edgesToApplyMask); - } else { - reachabilityResult = performReachabilityFixedOrder(pred, edgesToApply); - } + ExplorationStrategy strategy = cifBddSpec.settings.getExplorationStrategy(); + + Pair<BDD, Boolean> reachabilityResult = switch (strategy) { + case CHAINING_FIXED -> performReachabilityFixedOrder(pred, edgesToApply); + case CHAINING_WORKSET -> { + BitSet edgesToApplyMask = IntStream.range(0, orderedEdges.size()) + .filter(i -> edgeShouldBeApplied.test(orderedEdges.get(i))).boxed().collect(BitSets.toBitSet()); + yield performReachabilityWorkset(pred, orderedEdges, edgesToApplyMask); + } + case SATURATION -> performReachabilitySaturation(pred, edgesToApply); + default -> throw new RuntimeException("Unknown exploration strategy: " + strategy); + }; + if (reachabilityResult == null || cifBddSpec.settings.getTermination().isRequested()) { return null; } @@ -372,4 +396,65 @@ public class CifBddReachability { } return pair(pred, changed); } + + /** + * Computes the set of reachable states from the given predicate by using the saturation strategy. The use of + * saturation requires that a saturation instance has been configured using {@link #setSaturationInstance}. + * + * @param pred The predicate to which to apply the reachability. This predicate should not be used after this + * method, as it may have been {@link BDD#free freed} by this method. Instead, continue with the predicate + * returned by this method as part of the return value. + * @param edges The CIF/BDD edges to apply. + * @return The fixed point result of the reachability computation, together with an indication of whether the + * predicate was changed as a result of the reachability computation. Instead of a pair, {@code null} is + * returned if termination was requested. + */ + private Pair<BDD, Boolean> performReachabilitySaturation(BDD pred, List<CifBddEdge> edges) { + Assert.notNull(saturationInstance, "Expected a saturation instance number to have been configured."); + + // Sort the list of (distinct) edges as required by the saturation algorithm. + Map<CifBddEdge, BDD> edgeSupport = edges.stream().distinct() + .collect(Collectors.toMap(edge -> edge, edge -> edge.updateGuardSupport.toBDD())); + + List<CifBddEdge> sortedEdges = edges.stream() + .sorted(Comparator.comparing(edge -> edgeSupport.get(edge).level())) + .toList(); + + edgeSupport.values().forEach(BDD::free); + + if (cifBddSpec.settings.getTermination().isRequested()) { + return null; + } + + // Obtain the BDDs of the transition relations and their variable support sets. + List<BDD> sortedRelations = sortedEdges.stream().map(edge -> edge.updateGuard).collect(Lists.toList()); + List<BDDVarSet> sortedVars = sortedEdges.stream().map(edge -> edge.updateGuardSupport).collect(Lists.toList()); + + if (cifBddSpec.settings.getTermination().isRequested()) { + return null; + } + + // Compute all reachable states using saturation. + BDD result; + + if (direction == CifBddEdgeApplyDirection.FORWARD) { + if (restriction == null) { + result = pred.saturationForward(sortedRelations, sortedVars, saturationInstance); + } else { + result = pred.boundedSaturationForward(restriction, sortedRelations, sortedVars, saturationInstance); + } + } else { + if (restriction == null) { + result = pred.saturationBackward(sortedRelations, sortedVars, saturationInstance); + } else { + result = pred.boundedSaturationBackward(restriction, sortedRelations, sortedVars, saturationInstance); + } + } + + // Determine whether any additional reachable states have been found. + boolean changed = !pred.equals(result); + pred.free(); + + return Pair.pair(result, changed); + } } diff --git a/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/ControllerCheckerBddBasedCheck.java b/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/ControllerCheckerBddBasedCheck.java index e07846a4571d4e57f665750568363e2ee1e1c882..9415f41627c27748ee4889a219b58e558e42615a 100644 --- a/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/ControllerCheckerBddBasedCheck.java +++ b/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/ControllerCheckerBddBasedCheck.java @@ -21,6 +21,15 @@ import org.eclipse.escet.cif.bdd.spec.CifBddSpec; * @param <T> The type of the conclusion of the check. */ public abstract class ControllerCheckerBddBasedCheck<T extends CheckConclusion> extends ControllerCheckerCheck<T> { + /** The saturation instance number for the forward search by the bounded response check. */ + public static final int SATURATION_INSTANCE_BOUNDED_RESPONSE_FORWARD = 0; + + /** The saturation instance number for the backward 'cpp' search by the non-blocking under control check. */ + public static final int SATURATION_INSTANCE_NONBLOCKING_CCP = 1; + + /** The saturation instance number for the backward 'bad' search by the non-blocking under control check. */ + public static final int SATURATION_INSTANCE_NONBLOCKING_BAD = 2; + /** * Performs the check. * diff --git a/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/boundedresponse/BoundedResponseCheck.java b/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/boundedresponse/BoundedResponseCheck.java index c3399efe3d60d22f900e802c801a5dfc0f8ddd55..4d59eaff6eec5e55199f56b7561837d1de89dabe 100644 --- a/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/boundedresponse/BoundedResponseCheck.java +++ b/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/boundedresponse/BoundedResponseCheck.java @@ -18,6 +18,7 @@ import java.util.List; import java.util.Set; import java.util.function.Predicate; +import org.eclipse.escet.cif.bdd.settings.ExplorationStrategy; import org.eclipse.escet.cif.bdd.spec.CifBddEdge; import org.eclipse.escet.cif.bdd.spec.CifBddEdgeApplyDirection; import org.eclipse.escet.cif.bdd.spec.CifBddEdgeKind; @@ -129,6 +130,11 @@ public class BoundedResponseCheck extends ControllerCheckerBddBasedCheck<Bounded CifBddReachability reachability = new CifBddReachability(cifBddSpec, predName, initName, restrictionName, restriction, direction, edgeKinds, dbgEnabled); + // If the saturation strategy is used, configure the saturation instance number. + if (cifBddSpec.settings.getExplorationStrategy() == ExplorationStrategy.SATURATION) { + reachability.setSaturationInstance(SATURATION_INSTANCE_BOUNDED_RESPONSE_FORWARD); + } + // Perform forward reachability. BDD reachabilityResult = reachability.performReachability(initPred); return reachabilityResult; diff --git a/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/nonblockingundercontrol/NonBlockingUnderControlCheck.java b/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/nonblockingundercontrol/NonBlockingUnderControlCheck.java index 437d9f19d9dd02d31246f7b32076e71e0d4eabf0..095971249dceba2202d4530da174427a0e0be70b 100644 --- a/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/nonblockingundercontrol/NonBlockingUnderControlCheck.java +++ b/cif/org.eclipse.escet.cif.controllercheck/src/org/eclipse/escet/cif/controllercheck/checks/nonblockingundercontrol/NonBlockingUnderControlCheck.java @@ -21,6 +21,7 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import org.eclipse.escet.cif.bdd.settings.ExplorationStrategy; import org.eclipse.escet.cif.bdd.spec.CifBddEdge; import org.eclipse.escet.cif.bdd.spec.CifBddEdgeApplyDirection; import org.eclipse.escet.cif.bdd.spec.CifBddEdgeKind; @@ -210,6 +211,11 @@ public class NonBlockingUnderControlCheck CifBddReachability reachability = new CifBddReachability(cifBddSpec, predName, initValName, restrictionName, restriction, direction, edgeKinds, dbgEnabled); + // If the saturation strategy is used, configure the saturation instance number. + if (cifBddSpec.settings.getExplorationStrategy() == ExplorationStrategy.SATURATION) { + reachability.setSaturationInstance(SATURATION_INSTANCE_NONBLOCKING_CCP); + } + // Get the initial predicate for the reachability computation. We use 'marked' rather than 'markedInv', since // preconditions forbid state invariants. BDD initPred = cifBddSpec.marked.id().andWith(notGc); @@ -271,6 +277,11 @@ public class NonBlockingUnderControlCheck CifBddReachability reachability = new CifBddReachability(cifBddSpec, predName, initValName, restrictionName, restriction, direction, edgeKinds, dbgEnabled); + // If the saturation strategy is used, configure the saturation instance number. + if (cifBddSpec.settings.getExplorationStrategy() == ExplorationStrategy.SATURATION) { + reachability.setSaturationInstance(SATURATION_INSTANCE_NONBLOCKING_BAD); + } + // Get the initial predicate for the reachability computation. BDD initPred = ccp.not(); diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesis.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesis.java index 36cd9bb6aa933d956adbdc712d4d309fbdb56c64..fba4fb686b01fd760b9fba6c96e37975384408aa 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesis.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesis.java @@ -30,6 +30,7 @@ import java.util.Set; import java.util.function.Function; import java.util.stream.Stream; +import org.eclipse.escet.cif.bdd.settings.ExplorationStrategy; import org.eclipse.escet.cif.bdd.spec.CifBddDiscVariable; import org.eclipse.escet.cif.bdd.spec.CifBddEdge; import org.eclipse.escet.cif.bdd.spec.CifBddEdgeApplyDirection; @@ -212,7 +213,7 @@ public class CifDataSynthesis { } // Prepare workset algorithm, if enabled. - if (cifBddSpec.settings.getDoUseEdgeWorksetAlgo()) { + if (cifBddSpec.settings.getExplorationStrategy() == ExplorationStrategy.CHAINING_WORKSET) { if (cifBddSpec.settings.getTermination().isRequested()) { return null; } @@ -1423,6 +1424,7 @@ public class CifDataSynthesis { BDD restriction; // The restriction predicate, if applicable. CifBddEdgeApplyDirection direction; // The direction of the reachability computation.. Set<CifBddEdgeKind> edgeKinds; // Kinds of edges to apply. + int saturationInstanceNumber; // The instance number to use for saturation. switch (fixedPointComputation) { case NONBLOCK: predName = "backward controlled-behavior"; @@ -1431,6 +1433,7 @@ public class CifDataSynthesis { restriction = synthResult.ctrlBeh; direction = CifBddEdgeApplyDirection.BACKWARD; edgeKinds = EnumSet.allOf(CifBddEdgeKind.class); + saturationInstanceNumber = 0; break; case CTRL: predName = "backward uncontrolled bad-state"; @@ -1439,6 +1442,7 @@ public class CifDataSynthesis { restriction = null; direction = CifBddEdgeApplyDirection.BACKWARD; edgeKinds = EnumSet.of(CifBddEdgeKind.UNCONTROLLABLE, CifBddEdgeKind.INPUT_VARIABLE); + saturationInstanceNumber = 1; break; case REACH: predName = "forward controlled-behavior"; @@ -1447,6 +1451,7 @@ public class CifDataSynthesis { restriction = synthResult.ctrlBeh; direction = CifBddEdgeApplyDirection.FORWARD; edgeKinds = EnumSet.allOf(CifBddEdgeKind.class); + saturationInstanceNumber = 2; break; default: throw new RuntimeException("Unknown fixed-point computation: " + fixedPointComputation); @@ -1478,6 +1483,12 @@ public class CifDataSynthesis { try { CifBddReachability reachability = new CifBddReachability(cifBddSpec, predName, initName, restrictionName, restriction, direction, edgeKinds, dbgEnabled); + + // If the saturation strategy is used, configure the saturation instance number. + if (cifBddSpec.settings.getExplorationStrategy() == ExplorationStrategy.SATURATION) { + reachability.setSaturationInstance(saturationInstanceNumber); + } + reachabilityResult = reachability.performReachability(startPred); } finally { // Stop timing the fixed-point reachability computation. diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesisApp.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesisApp.java index 41127f2fd873a2432f2bdb000c5092624e13e03b..7efcd2567b2ac39e84bf4b6897b767d4009b40e7 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesisApp.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/CifDataSynthesisApp.java @@ -48,6 +48,7 @@ import org.eclipse.escet.cif.datasynth.options.EdgeOrderForwardOption; import org.eclipse.escet.cif.datasynth.options.EdgeOrderOption; import org.eclipse.escet.cif.datasynth.options.EdgeWorksetAlgoOption; import org.eclipse.escet.cif.datasynth.options.EventWarnOption; +import org.eclipse.escet.cif.datasynth.options.ExplorationStrategyOption; import org.eclipse.escet.cif.datasynth.options.FixedPointComputationsOrderOption; import org.eclipse.escet.cif.datasynth.options.ForwardReachOption; import org.eclipse.escet.cif.datasynth.options.PlantsRefReqsWarnOption; @@ -146,12 +147,12 @@ public class CifDataSynthesisApp extends Application<IOutputComponent> { settings.setEdgeOrderBackward(EdgeOrderBackwardOption.getOrder()); settings.setEdgeOrderForward(EdgeOrderForwardOption.getOrder()); settings.setEdgeOrderAllowDuplicateEvents(EdgeOrderDuplicateEventsOption.getAllowance()); - settings.setDoUseEdgeWorksetAlgo(EdgeWorksetAlgoOption.isEnabled()); settings.setCifBddStatistics(SynthesisStatistics.toCifBdd(SynthesisStatisticsOption.getStatistics())); settings.setDoNeverEnabledEventsWarn(EventWarnOption.isEnabled()); settings.setStateReqInvEnforceMode(StateReqInvEnforceOption.getMode()); settings.setFixedPointComputationsOrder(FixedPointComputationsOrderOption.getOrder()); + settings.setExplorationStrategy(ExplorationStrategyOption.getStrategy()); settings.setDoForwardReach(ForwardReachOption.isEnabled()); settings.setSupervisorName(SupervisorNameOption.getSupervisorName()); settings.setSupervisorNamespace(SupervisorNamespaceOption.getNamespace()); @@ -394,12 +395,13 @@ public class CifDataSynthesisApp extends Application<IOutputComponent> { synthOpts.add(Options.getInstance(SupervisorNamespaceOption.class)); synthOpts.add(Options.getInstance(ForwardReachOption.class)); synthOpts.add(Options.getInstance(FixedPointComputationsOrderOption.class)); + synthOpts.add(Options.getInstance(ExplorationStrategyOption.class)); synthOpts.add(Options.getInstance(EdgeGranularityOption.class)); synthOpts.add(Options.getInstance(EdgeOrderOption.class)); // No longer supported. synthOpts.add(Options.getInstance(EdgeOrderBackwardOption.class)); synthOpts.add(Options.getInstance(EdgeOrderForwardOption.class)); synthOpts.add(Options.getInstance(EdgeOrderDuplicateEventsOption.class)); - synthOpts.add(Options.getInstance(EdgeWorksetAlgoOption.class)); + synthOpts.add(Options.getInstance(EdgeWorksetAlgoOption.class)); // No longer supported. synthOpts.add(Options.getInstance(StateReqInvEnforceOption.class)); synthOpts.add(Options.getInstance(SynthesisStatisticsOption.class)); synthOpts.add(Options.getInstance(ContinuousPerformanceStatisticsFileOption.class)); diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/options/EdgeWorksetAlgoOption.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/options/EdgeWorksetAlgoOption.java index e0a0c10063095ba0636e1929a3038dce2362544f..22139cdbeab3827f3d38a820a977e996569b3f8e 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/options/EdgeWorksetAlgoOption.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/options/EdgeWorksetAlgoOption.java @@ -13,12 +13,15 @@ package org.eclipse.escet.cif.datasynth.options; -import org.eclipse.escet.cif.bdd.settings.CifBddSettingsDefaults; import org.eclipse.escet.common.app.framework.options.BooleanOption; -import org.eclipse.escet.common.app.framework.options.Options; /** Edge workset algorithm option. */ public class EdgeWorksetAlgoOption extends BooleanOption { + /** Message to indicate the option is unsupported. */ + private static final String UNSUPPORTED_MESSAGE = "This option is no longer supported. " + + "It will be removed in a future version of the tool. " + + "Use the 'Exploration strategy for symbolic reachability computations' option instead."; + /** Constructor for the {@link EdgeWorksetAlgoOption} class. */ public EdgeWorksetAlgoOption() { super( @@ -26,8 +29,7 @@ public class EdgeWorksetAlgoOption extends BooleanOption { "Edge workset algorithm", // description - "Whether to use the edge workset algorithm to dynamically choose the best edge to apply during " - + "reachability computations (BOOL=yes), or not (BOOL=no). [DEFAULT=no]", + "Whether to use the edge workset algorithm. " + UNSUPPORTED_MESSAGE, // cmdShort null, @@ -39,25 +41,15 @@ public class EdgeWorksetAlgoOption extends BooleanOption { "BOOL", // defaultValue - CifBddSettingsDefaults.DO_USE_WORKSET_ALGO_DEFAULT, + false, // showInDialog - true, + false, // optDialogDescr - "Whether to use the edge workset algorithm to dynamically choose the best edge to apply during " - + "reachability computations.", + null, // optDialogLabelText - "Use workset algorithm"); - } - - /** - * Should the edge workset algorithm be used? - * - * @return {@code true} to use the algorithm, {@code false} otherwise. - */ - public static boolean isEnabled() { - return Options.get(EdgeWorksetAlgoOption.class); + null); } } diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/options/ExplorationStrategyOption.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/options/ExplorationStrategyOption.java new file mode 100644 index 0000000000000000000000000000000000000000..61faf356a018144c723b94d929b89001140560a0 --- /dev/null +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/options/ExplorationStrategyOption.java @@ -0,0 +1,76 @@ +////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2024 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available +// under the terms of the MIT License which is available at +// https://opensource.org/licenses/MIT +// +// SPDX-License-Identifier: MIT +////////////////////////////////////////////////////////////////////////////// + +package org.eclipse.escet.cif.datasynth.options; + +import org.eclipse.escet.cif.bdd.settings.CifBddSettingsDefaults; +import org.eclipse.escet.cif.bdd.settings.ExplorationStrategy; +import org.eclipse.escet.common.app.framework.options.EnumOption; +import org.eclipse.escet.common.app.framework.options.Options; + +/** Option to specify the exploration strategy for symbolic reachability computations. */ +public class ExplorationStrategyOption extends EnumOption<ExplorationStrategy> { + /** Constructor for the {@link ExplorationStrategyOption} class. */ + public ExplorationStrategyOption() { + super( + // name + "Exploration strategy", + + // description + "Specify the exploration strategy to be used for symbolic reachability computations. " + + "Specify \"chaining-fixed\" to use the chaining strategy with a fixed edge ordering. " + + "Specify \"chaining-workset\" to use the chaining strategy where the edge workset algorithm " + + "is used to dynamically choose the best edge to apply during reachability computations. " + + "Specify \"saturation\" (default) to use the saturation strategy.", + + // cmdShort + null, + + // cmdLong + "exploration-strategy", + + // cmdValue + "STRATEGY", + + // defaultValue + CifBddSettingsDefaults.EXPLORATION_STRATEGY_DEFAULT, + + // showInDialog + true, + + // optDialogDescr + "Specify the exploration strategy to be used for symbolic reachability computations."); + } + + @Override + protected String getDialogText(ExplorationStrategy strategy) { + switch (strategy) { + case CHAINING_FIXED: + return "The chaining strategy with a fixed edge ordering"; + case CHAINING_WORKSET: + return "The chaining strategy with a dynamic edge ordering determined by the edge workset algorithm"; + case SATURATION: + return "The saturation strategy"; + } + throw new RuntimeException("Unknown strategy: " + strategy); + } + + /** + * Returns the value of the {@link ExplorationStrategyOption} option. + * + * @return The value of the {@link ExplorationStrategyOption} option. + */ + public static ExplorationStrategy getStrategy() { + return Options.get(ExplorationStrategyOption.class); + } +} diff --git a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/edge-order.asciidoc b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/edge-order.asciidoc index dd754e5bf4ab9cb7c30f0da2c0f92266cf8cddff..dc4bdbd6104c642817590ff8398fbbc38d2d3e16 100644 --- a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/edge-order.asciidoc +++ b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/edge-order.asciidoc @@ -38,16 +38,18 @@ Besides finding or not finding new states, which new states are found first and It may lead to smaller or larger intermediate BDD representations of predicates. See the <<tools-datasynth-var-order,section about BDD variable order>> for more information. -=== Two approaches +=== Three approaches -There are two approaches that determine the order in which edges are considered: +There are three approaches that determine the order in which edges are considered: * _Fixed order_: + A fixed order is determined upfront, before any reachability computations. Each of the edges is considered in that fixed order, one after the other. Regardless of whether an edge leads to new states being found or not, the search always continues with the next edge from the fixed order. +Each edge is applied to all reached states, including those of the previously applied edges. After the last edge has been considered, the first edge is considered again, then the second one, etc. +This way of applying edges is known as the chaining strategy for reachability computation. A fixed point is reached once: + ** All edges have been considered at least once. @@ -56,7 +58,7 @@ A fixed point is reached once: * _Workset algorithm_: + The order in which the edges are considered is dynamic, rather than fixed. -The algorithm works as follows: +The algorithm also follows the chaining exploration strategy, and works as follows: + -- ** Initially, all edges are in a workset. @@ -72,19 +74,32 @@ The dependencies of an edge are those other edges that may be enabled after usin The workset algorithm can only be used in combination with a 'per event' <<tools-datasynth-edge-granularity,edge granularity>>. The workset algorithm can not be used when duplicate events are allowed in a <<tools-datasynth-edge-order-custom,custom edge order>>. -Which approach to use during synthesis, can be configured using the _Edge workset algorithm_ option (see the <<tools-datasynth-options,options section>>). -By default a fixed order is used, and the workset algorithm is disabled. -By enabling the workset algorithm, it is used instead. +* _Saturation_: ++ +Saturation is a strategy for BDD-based symbolic reachability computations that exploits locality of the edges that are considered. +The edges to consider are sorted on the top-most BDD variable of their BDD representations. +The order of edges with the same such top-most BDD variable is determined based on the <<tools-datasynth-configuring-the-edge-order, configured order>>. +The saturation algorithm then uses this order to saturate the BDD representation of the set of reachable states from the bottom up. +This is done by first applying edges over the lowest part of the BDD until they no longer lead to new states, and then gradually go upward in the sorted edge order until saturation is reached for all edges. +Saturation thereby tries to reduce blow-ups of BDDs at intermediate points during reachability computations, which can sometimes be observed with other exploration strategies, like chaining. ++ +The saturation strategy can not be used when duplicate events are allowed in a <<tools-datasynth-edge-order-custom,custom edge order>>. + +Which approach to use during synthesis, can be configured using the _Exploration strategy_ option (see the <<tools-datasynth-options,options section>>). +Saturation is used by default. Which approach works best depends on the model, and this may involve a trade-off. The workset algorithm may reduce the maximum amount of memory used during synthesis, compared to using a fixed order. However, this often comes at the cost of extra computations that require more time, especially if edges have many other edges as their dependencies. +Saturation generally works best. +[[tools-datasynth-configuring-the-edge-order]] === Configuring the order The order in which the edges are considered when a fixed order is used, is determined by the _Edge order for backward reachability_ and _Edge order for forward reachability_ options (see the <<tools-datasynth-options,options section>>). If the workset algorithm is used, the edges in the workset are ordered according to the configured order. The configured order may therefore also influence the order in which edges are selected by the workset algorithm's edge selection heuristics. +And if saturation is used, the configured edge order determines the order of the edges with the same top-most BDD variable. Several predefined orders exist, and it is also possible to define a custom order. By default, the _model ordering_ is used for both backward and forward reachability computations. diff --git a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/options.asciidoc b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/options.asciidoc index a09faf9963031c8277b2845f573de038689db9fe..99705be5351145943b9749eba438b2e284b0bd60 100644 --- a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/options.asciidoc +++ b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/options.asciidoc @@ -41,6 +41,11 @@ For more information, see the <<tools-datasynth-forward-reach,section about forw This may impact the performance of synthesis. For more information, see the <<tools-datasynth-fixed-point-order,section about fixed-point computations order>>. +* _Exploration strategy_: The exploration strategy to use for symbolic reachability computations. +This strategy determines in which order the edges are to be considered. +This may impact the performance of synthesis. +For more information, see the <<tools-datasynth-edge-order,section about edge order>>. + * _Edge granularity_: Specify the granularity of edges to use during synthesis. For more information, see the <<tools-datasynth-edge-granularity,section about edge granularity>>. @@ -61,9 +66,8 @@ For more information, see the <<tools-datasynth-edge-order,section about edge or By default, duplicate events are disallowed. For more information, see the <<tools-datasynth-edge-order,section about edge order>>. -* _Edge workset algorithm_: Synthesis involves many reachability computations that involve following edges forward or backward. -The workset algorithm is one approach that determines the order in which edges are considered. -For more information, see the <<tools-datasynth-edge-order,section about edge order>>. +* _Edge workset algorithm_: This option is no longer supported. +Use the _Exploration strategy_ option instead. * _State requirement invariant enforcement_: Specify how state requirement invariants are enforced during synthesis. By default, they are all enforced via the controlled behavior. diff --git a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/performance.asciidoc b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/performance.asciidoc index 0621b8f067bc93dbc1924994c0a108d834fc166a..92e4114d7efcb06939f783c0fc9bd06ddd41c354 100644 --- a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/performance.asciidoc +++ b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth/performance.asciidoc @@ -80,6 +80,12 @@ The following <<tools-datasynth-options,options>> have an effect on the performa | Better order for less computations and smaller BDD representations | Choose the best ordering, depends on the model +| Order +| Exploration strategy +| <<tools-datasynth-edge-order>> +| Better order for less computations and smaller BDD representations +| The `saturation` strategy likely gives best performance + | Order | BDD initial variable ordering | <<tools-datasynth-var-order-initial-ordering>> @@ -134,12 +140,6 @@ The following <<tools-datasynth-options,options>> have an effect on the performa | Better order for less computations and smaller BDD representations | Choose the best order, depends on the model, custom order allows for best performance -| Order -| Edge workset algorithm -| <<tools-datasynth-edge-order>> -| Better order for less computations and smaller BDD representations -| Enable to dynamically determine the order in which edges are considered, which may improve performance - | Library | BDD library initial node table size | <<tools-datasynth-stats>> diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.BCFN.run.out index 9a1ba0e67d73509c6f9f3850baf2fea55b5afacf..17a664cb5e79edafe605938b2c31d37e373a8670 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.BCFN.run.out @@ -177,21 +177,6 @@ Checking for bounded response: Computing reachable states: Reachable states: not LampHW.bit and (LampHW.Off and Lamp.Off) and (Timer.Idle and Cycle.WaitForButtonPush and (ButtonHW.Released and Button.Released)) [initial states predicate] - Forward reachability iteration 1: - Reachable states: not LampHW.bit and (LampHW.Off and Lamp.Off) and (Timer.Idle and Cycle.WaitForButtonPush and (ButtonHW.Released and Button.Released)) -> <bdd 14n 2p> [forward reach with edge: (event: Button.u_pushed) (guard: (Cycle.WaitForButtonPush or Cycle.TurnLampOff) and ButtonHW.bit and (ButtonHW.Released and Button.Released) or (Cycle.StartTimer and ButtonHW.bit and (ButtonHW.Released and Button.Released) or (Cycle.TurnLampOn or Cycle.WaitForTimeout) and ButtonHW.bit and (ButtonHW.Released and Button.Released))) (assignments: Button := Button.Pushed, Cycle := Cycle.TurnLampOn, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed)] - Reachable states: <bdd 14n 2p> -> <bdd 19n 3p> [forward reach with edge: (event: Lamp.c_on) (guard: LampHW.Off and (Lamp.Off and Cycle.TurnLampOn)) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer, LampHW.bit := true, LampHW := LampHW.On)] - Reachable states: <bdd 19n 3p> -> <bdd 20n 4p> [forward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - Reachable states: <bdd 20n 4p> -> <bdd 22n 5p> [forward reach with edge: (event: Timer.u_timeout) (guard: Timer.Running and Cycle.WaitForTimeout) (assignments: Timer := Timer.Idle, Cycle := Cycle.TurnLampOff)] - Reachable states: <bdd 22n 5p> -> <bdd 21n 5p> [forward reach with edge: (event: ButtonHW.bit) (guard: true) (assignments: ButtonHW.bit+ != ButtonHW.bit)] - - Forward reachability iteration 2: - Reachable states: <bdd 21n 5p> -> <bdd 23n 13p> [forward reach with edge: (event: Button.u_released) (guard: not ButtonHW.bit and (ButtonHW.Pushed and Button.Pushed)) (assignments: Button := Button.Released, ButtonHW := ButtonHW.Released)] - Reachable states: <bdd 23n 13p> -> <bdd 22n 14p> [forward reach with edge: (event: Lamp.c_off) (guard: LampHW.On and (Lamp.On and Cycle.TurnLampOff)) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush, LampHW.bit := false, LampHW := LampHW.Off)] - Reachable states: <bdd 22n 14p> -> <bdd 17n 8p> [forward reach with edge: (event: ButtonHW.bit) (guard: true) (assignments: ButtonHW.bit+ != ButtonHW.bit)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: <bdd 17n 8p> [fixed point]. Computing bound for uncontrollable events: @@ -217,22 +202,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: LampHW.Off and (Lamp.Off and Timer.Idle) and (Cycle.WaitForButtonPush and (ButtonHW.Released and Button.Released)) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: LampHW.Off and (Lamp.Off and Timer.Idle) and (Cycle.WaitForButtonPush and (ButtonHW.Released and Button.Released)) -> <bdd 11n 3p> [backward reach with edge: (event: Button.u_released) (guard: not ButtonHW.bit and (ButtonHW.Pushed and Button.Pushed) -> <bdd 20n 21p>) (assignments: Button := Button.Released, ButtonHW := ButtonHW.Released)] - Controllable-complete path states: <bdd 11n 3p> -> <bdd 16n 6p> [backward reach with edge: (event: Lamp.c_off) (guard: LampHW.On and (Lamp.On and Cycle.TurnLampOff)) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush, LampHW.bit := false, LampHW := LampHW.Off)] - Controllable-complete path states: <bdd 16n 6p> -> <bdd 18n 9p> [backward reach with edge: (event: Timer.u_timeout) (guard: Timer.Running and Cycle.WaitForTimeout) (assignments: Timer := Timer.Idle, Cycle := Cycle.TurnLampOff)] - Controllable-complete path states: <bdd 18n 9p> -> <bdd 18n 7p> [backward reach with edge: (event: ButtonHW.bit) (guard: true -> <bdd 17n 21p>) (assignments: ButtonHW.bit+ != ButtonHW.bit)] - - Backward reachability iteration 2: - Controllable-complete path states: <bdd 18n 7p> -> <bdd 16n 6p> [backward reach with edge: (event: Lamp.c_off) (guard: LampHW.On and (Lamp.On and Cycle.TurnLampOff)) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush, LampHW.bit := false, LampHW := LampHW.Off)] - Controllable-complete path states: <bdd 16n 6p> -> <bdd 16n 8p> [backward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - - Backward reachability iteration 3: - Controllable-complete path states: <bdd 16n 8p> -> <bdd 15n 8p> [backward reach with edge: (event: Lamp.c_on) (guard: LampHW.Off and (Lamp.Off and Cycle.TurnLampOn)) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer, LampHW.bit := true, LampHW := LampHW.On)] - - Backward reachability iteration 4: - No change this iteration. - Controllable-complete path states: <bdd 15n 8p> [fixed point]. Controllable-complete path states: <bdd 15n 8p> @@ -240,9 +209,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: <bdd 15n 19p> [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: <bdd 15n 19p> Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.Bxxx.run.out index 152ed588cfdb6ab45bb01cd999744b823b963258..cf0e604601e42e70e8b92a6b324832c7167d058d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_button_lamp_timer_sup_hw.Bxxx.run.out @@ -126,21 +126,6 @@ Checking for bounded response: Computing reachable states: Reachable states: not LampHW.bit and (LampHW.Off and Lamp.Off) and (Timer.Idle and Cycle.WaitForButtonPush and (ButtonHW.Released and Button.Released)) [initial states predicate] - Forward reachability iteration 1: - Reachable states: not LampHW.bit and (LampHW.Off and Lamp.Off) and (Timer.Idle and Cycle.WaitForButtonPush and (ButtonHW.Released and Button.Released)) -> <bdd 14n 2p> [forward reach with edge: (event: Button.u_pushed) (guard: (Cycle.WaitForButtonPush or Cycle.TurnLampOff) and ButtonHW.bit and (ButtonHW.Released and Button.Released) or (Cycle.StartTimer and ButtonHW.bit and (ButtonHW.Released and Button.Released) or (Cycle.TurnLampOn or Cycle.WaitForTimeout) and ButtonHW.bit and (ButtonHW.Released and Button.Released))) (assignments: Button := Button.Pushed, Cycle := Cycle.TurnLampOn, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed / Button := Button.Pushed, ButtonHW := ButtonHW.Pushed)] - Reachable states: <bdd 14n 2p> -> <bdd 19n 3p> [forward reach with edge: (event: Lamp.c_on) (guard: LampHW.Off and (Lamp.Off and Cycle.TurnLampOn)) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer, LampHW.bit := true, LampHW := LampHW.On)] - Reachable states: <bdd 19n 3p> -> <bdd 20n 4p> [forward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - Reachable states: <bdd 20n 4p> -> <bdd 22n 5p> [forward reach with edge: (event: Timer.u_timeout) (guard: Timer.Running and Cycle.WaitForTimeout) (assignments: Timer := Timer.Idle, Cycle := Cycle.TurnLampOff)] - Reachable states: <bdd 22n 5p> -> <bdd 21n 5p> [forward reach with edge: (event: ButtonHW.bit) (guard: true) (assignments: ButtonHW.bit+ != ButtonHW.bit)] - - Forward reachability iteration 2: - Reachable states: <bdd 21n 5p> -> <bdd 23n 13p> [forward reach with edge: (event: Button.u_released) (guard: not ButtonHW.bit and (ButtonHW.Pushed and Button.Pushed)) (assignments: Button := Button.Released, ButtonHW := ButtonHW.Released)] - Reachable states: <bdd 23n 13p> -> <bdd 22n 14p> [forward reach with edge: (event: Lamp.c_off) (guard: LampHW.On and (Lamp.On and Cycle.TurnLampOff)) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush, LampHW.bit := false, LampHW := LampHW.Off)] - Reachable states: <bdd 22n 14p> -> <bdd 17n 8p> [forward reach with edge: (event: ButtonHW.bit) (guard: true) (assignments: ButtonHW.bit+ != ButtonHW.bit)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: <bdd 17n 8p> [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.BCFN.run.out index 851892790ad0cca64c066cd42324b17c1a676f2f..b9c5fa8206702b88939072fccb6a1a2564ff9b9a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.BCFN.run.out @@ -115,13 +115,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.Off -> p.Off or sensor [forward reach with edge: (event: u_on) (guard: p.Off and sensor) (assignments: p := p.On)] - Reachable states: p.Off or sensor -> true [forward reach with edge: (event: sensor) (guard: true) (assignments: sensor+ != sensor)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -144,13 +137,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.Off [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.Off -> p.Off or not sensor [backward reach with edge: (event: u_off) (guard: p.On and not sensor) (assignments: p := p.Off)] - Controllable-complete path states: p.Off or not sensor -> true [backward reach with edge: (event: sensor) (guard: true) (assignments: sensor+ != sensor)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -158,9 +144,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.Bxxx.run.out index 249609f98cc24589484aa03a25a18c8b63183feb..ac53e13dbe4c53d40cc01f900ab9b9740f637e37 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_by_input_var.Bxxx.run.out @@ -112,13 +112,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.Off -> p.Off or sensor [forward reach with edge: (event: u_on) (guard: p.Off and sensor) (assignments: p := p.On)] - Reachable states: p.Off or sensor -> true [forward reach with edge: (event: sensor) (guard: true) (assignments: sensor+ != sensor)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_channel_non_deterministic.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_channel_non_deterministic.Bxxx.run.out index 1d4dafed75fa140110c3f13c29dc2a5b70bab98b..401d9b3a06395020a9af549b23dbe1b3105d3f1b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_channel_non_deterministic.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_channel_non_deterministic.Bxxx.run.out @@ -137,21 +137,6 @@ Checking for bounded response: Computing reachable states: Reachable states: <bdd 14n 1p> [initial states predicate] - Forward reachability iteration 1: - Reachable states: <bdd 14n 1p> -> <bdd 28n 13p> [forward reach with edge: (event: u_chan) (guard: <bdd 12n 12p>) (assignments: usend1 := usend1.loc2, urecv1 := urecv1.loc2 / usend1 := usend1.loc2, urecv2 := urecv2.loc2 / usend1 := usend1.loc2, urecv3 := urecv3.loc2 / usend1 := usend1.loc2, urecv4 := urecv4.loc2 / usend2 := usend2.loc2, urecv1 := urecv1.loc2 / usend2 := usend2.loc2, urecv2 := urecv2.loc2 / usend2 := usend2.loc2, urecv3 := urecv3.loc2 / usend2 := usend2.loc2, urecv4 := urecv4.loc2 / usend3 := usend3.loc2, urecv1 := urecv1.loc2 / usend3 := usend3.loc2, urecv2 := urecv2.loc2 / usend3 := usend3.loc2, urecv3 := urecv3.loc2 / usend3 := usend3.loc2, urecv4 := urecv4.loc2)] - Reachable states: <bdd 28n 13p> -> <bdd 42n 169p> [forward reach with edge: (event: c_chan) (guard: <bdd 12n 12p>) (assignments: csend1 := csend1.loc2, crecv1 := crecv1.loc2 / csend1 := csend1.loc2, crecv2 := crecv2.loc2 / csend1 := csend1.loc2, crecv3 := crecv3.loc2 / csend2 := csend2.loc2, crecv1 := crecv1.loc2 / csend2 := csend2.loc2, crecv2 := crecv2.loc2 / csend2 := csend2.loc2, crecv3 := crecv3.loc2 / csend3 := csend3.loc2, crecv1 := crecv1.loc2 / csend3 := csend3.loc2, crecv2 := crecv2.loc2 / csend3 := csend3.loc2, crecv3 := crecv3.loc2 / csend4 := csend4.loc2, crecv1 := crecv1.loc2 / csend4 := csend4.loc2, crecv2 := crecv2.loc2 / csend4 := csend4.loc2, crecv3 := crecv3.loc2)] - - Forward reachability iteration 2: - Reachable states: <bdd 42n 169p> -> <bdd 46n 403p> [forward reach with edge: (event: u_chan) (guard: <bdd 12n 12p>) (assignments: usend1 := usend1.loc2, urecv1 := urecv1.loc2 / usend1 := usend1.loc2, urecv2 := urecv2.loc2 / usend1 := usend1.loc2, urecv3 := urecv3.loc2 / usend1 := usend1.loc2, urecv4 := urecv4.loc2 / usend2 := usend2.loc2, urecv1 := urecv1.loc2 / usend2 := usend2.loc2, urecv2 := urecv2.loc2 / usend2 := usend2.loc2, urecv3 := urecv3.loc2 / usend2 := usend2.loc2, urecv4 := urecv4.loc2 / usend3 := usend3.loc2, urecv1 := urecv1.loc2 / usend3 := usend3.loc2, urecv2 := urecv2.loc2 / usend3 := usend3.loc2, urecv3 := urecv3.loc2 / usend3 := usend3.loc2, urecv4 := urecv4.loc2)] - Reachable states: <bdd 46n 403p> -> <bdd 50n 961p> [forward reach with edge: (event: c_chan) (guard: <bdd 12n 12p>) (assignments: csend1 := csend1.loc2, crecv1 := crecv1.loc2 / csend1 := csend1.loc2, crecv2 := crecv2.loc2 / csend1 := csend1.loc2, crecv3 := crecv3.loc2 / csend2 := csend2.loc2, crecv1 := crecv1.loc2 / csend2 := csend2.loc2, crecv2 := crecv2.loc2 / csend2 := csend2.loc2, crecv3 := crecv3.loc2 / csend3 := csend3.loc2, crecv1 := crecv1.loc2 / csend3 := csend3.loc2, crecv2 := crecv2.loc2 / csend3 := csend3.loc2, crecv3 := crecv3.loc2 / csend4 := csend4.loc2, crecv1 := crecv1.loc2 / csend4 := csend4.loc2, crecv2 := crecv2.loc2 / csend4 := csend4.loc2, crecv3 := crecv3.loc2)] - - Forward reachability iteration 3: - Reachable states: <bdd 50n 961p> -> <bdd 44n 1,085p> [forward reach with edge: (event: u_chan) (guard: <bdd 12n 12p>) (assignments: usend1 := usend1.loc2, urecv1 := urecv1.loc2 / usend1 := usend1.loc2, urecv2 := urecv2.loc2 / usend1 := usend1.loc2, urecv3 := urecv3.loc2 / usend1 := usend1.loc2, urecv4 := urecv4.loc2 / usend2 := usend2.loc2, urecv1 := urecv1.loc2 / usend2 := usend2.loc2, urecv2 := urecv2.loc2 / usend2 := usend2.loc2, urecv3 := urecv3.loc2 / usend2 := usend2.loc2, urecv4 := urecv4.loc2 / usend3 := usend3.loc2, urecv1 := urecv1.loc2 / usend3 := usend3.loc2, urecv2 := urecv2.loc2 / usend3 := usend3.loc2, urecv3 := urecv3.loc2 / usend3 := usend3.loc2, urecv4 := urecv4.loc2)] - Reachable states: <bdd 44n 1,085p> -> <bdd 38n 1,225p> [forward reach with edge: (event: c_chan) (guard: <bdd 12n 12p>) (assignments: csend1 := csend1.loc2, crecv1 := crecv1.loc2 / csend1 := csend1.loc2, crecv2 := crecv2.loc2 / csend1 := csend1.loc2, crecv3 := crecv3.loc2 / csend2 := csend2.loc2, crecv1 := crecv1.loc2 / csend2 := csend2.loc2, crecv2 := crecv2.loc2 / csend2 := csend2.loc2, crecv3 := crecv3.loc2 / csend3 := csend3.loc2, crecv1 := crecv1.loc2 / csend3 := csend3.loc2, crecv2 := crecv2.loc2 / csend3 := csend3.loc2, crecv3 := crecv3.loc2 / csend4 := csend4.loc2, crecv1 := crecv1.loc2 / csend4 := csend4.loc2, crecv2 := crecv2.loc2 / csend4 := csend4.loc2, crecv3 := crecv3.loc2)] - - Forward reachability iteration 4: - No change this iteration. - Reachable states: <bdd 38n 1,225p> [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.BCFN.run.out index 6037373c71b155be76e7ca9758f1379d01681155..95f660c3fb8a31bb6bb12aa9771ba89a79f71095 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.BCFN.run.out @@ -165,20 +165,6 @@ Checking for bounded response: Computing reachable states: Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu1.loc1 and (pu2.loc1 and (pu3.loc1 and pu4.loc1))) [initial states predicate] - Forward reachability iteration 1: - Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu1.loc1 and (pu2.loc1 and (pu3.loc1 and pu4.loc1))) -> pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu2.loc1 and (pu3.loc1 and pu4.loc1)) [forward reach with edge: (event: u_e1) (guard: pu1.loc1) (assignments: pu1 := pu1.loc2)] - Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu2.loc1 and (pu3.loc1 and pu4.loc1)) -> pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and pc5.loc1 and (pu3.loc1 and pu4.loc1)) [forward reach with edge: (event: u_e2) (guard: pu2.loc1) (assignments: pu2 := pu2.loc2)] - Reachable states: pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and pc5.loc1 and (pu3.loc1 and pu4.loc1)) -> pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and (pc5.loc1 and pu4.loc1)) [forward reach with edge: (event: u_e3) (guard: pu3.loc1) (assignments: pu3 := pu3.loc2)] - Reachable states: pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and (pc5.loc1 and pu4.loc1)) -> pc1.loc1 and pc2.loc1 and (pc3.loc1 and (pc4.loc1 and pc5.loc1)) [forward reach with edge: (event: u_e4) (guard: pu4.loc1) (assignments: pu4 := pu4.loc2)] - Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and (pc4.loc1 and pc5.loc1)) -> pc2.loc1 and pc3.loc1 and (pc4.loc1 and pc5.loc1) [forward reach with edge: (event: c_e1) (guard: pc1.loc1) (assignments: pc1 := pc1.loc2)] - Reachable states: pc2.loc1 and pc3.loc1 and (pc4.loc1 and pc5.loc1) -> pc3.loc1 and (pc4.loc1 and pc5.loc1) [forward reach with edge: (event: c_e2) (guard: pc2.loc1) (assignments: pc2 := pc2.loc2)] - Reachable states: pc3.loc1 and (pc4.loc1 and pc5.loc1) -> pc4.loc1 and pc5.loc1 [forward reach with edge: (event: c_e3) (guard: pc3.loc1) (assignments: pc3 := pc3.loc2)] - Reachable states: pc4.loc1 and pc5.loc1 -> pc5.loc1 [forward reach with edge: (event: c_e4) (guard: pc4.loc1) (assignments: pc4 := pc4.loc2)] - Reachable states: pc5.loc1 -> true [forward reach with edge: (event: c_e5) (guard: pc5.loc1) (assignments: pc5 := pc5.loc2)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -209,20 +195,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: pc1.loc2 and pc2.loc2 and (pc3.loc2 and pc4.loc2) and (pc5.loc2 and pu1.loc2 and (pu2.loc2 and (pu3.loc2 and pu4.loc2))) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: pc1.loc2 and pc2.loc2 and (pc3.loc2 and pc4.loc2) and (pc5.loc2 and pu1.loc2 and (pu2.loc2 and (pu3.loc2 and pu4.loc2))) -> pc1.loc2 and pc2.loc2 and (pc3.loc2 and pc4.loc2) and (pc5.loc2 and pu2.loc2 and (pu3.loc2 and pu4.loc2)) [backward reach with edge: (event: u_e1) (guard: pu1.loc1 -> pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and (pc5.loc2 and pu1.loc1))) (assignments: pu1 := pu1.loc2)] - Controllable-complete path states: pc1.loc2 and pc2.loc2 and (pc3.loc2 and pc4.loc2) and (pc5.loc2 and pu2.loc2 and (pu3.loc2 and pu4.loc2)) -> pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and pc5.loc2 and (pu3.loc2 and pu4.loc2)) [backward reach with edge: (event: u_e2) (guard: pu2.loc1 -> pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and (pc5.loc2 and pu2.loc1))) (assignments: pu2 := pu2.loc2)] - Controllable-complete path states: pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and pc5.loc2 and (pu3.loc2 and pu4.loc2)) -> pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and (pc5.loc2 and pu4.loc2)) [backward reach with edge: (event: u_e3) (guard: pu3.loc1 -> pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and (pc5.loc2 and pu3.loc1))) (assignments: pu3 := pu3.loc2)] - Controllable-complete path states: pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and (pc5.loc2 and pu4.loc2)) -> pc1.loc2 and pc2.loc2 and (pc3.loc2 and (pc4.loc2 and pc5.loc2)) [backward reach with edge: (event: u_e4) (guard: pu4.loc1 -> pc1.loc2 and (pc2.loc2 and pc3.loc2) and (pc4.loc2 and (pc5.loc2 and pu4.loc1))) (assignments: pu4 := pu4.loc2)] - Controllable-complete path states: pc1.loc2 and pc2.loc2 and (pc3.loc2 and (pc4.loc2 and pc5.loc2)) -> pc2.loc2 and pc3.loc2 and (pc4.loc2 and pc5.loc2) [backward reach with edge: (event: c_e1) (guard: pc1.loc1) (assignments: pc1 := pc1.loc2)] - Controllable-complete path states: pc2.loc2 and pc3.loc2 and (pc4.loc2 and pc5.loc2) -> pc3.loc2 and (pc4.loc2 and pc5.loc2) [backward reach with edge: (event: c_e2) (guard: pc2.loc1) (assignments: pc2 := pc2.loc2)] - Controllable-complete path states: pc3.loc2 and (pc4.loc2 and pc5.loc2) -> pc4.loc2 and pc5.loc2 [backward reach with edge: (event: c_e3) (guard: pc3.loc1) (assignments: pc3 := pc3.loc2)] - Controllable-complete path states: pc4.loc2 and pc5.loc2 -> pc5.loc2 [backward reach with edge: (event: c_e4) (guard: pc4.loc1) (assignments: pc4 := pc4.loc2)] - Controllable-complete path states: pc5.loc2 -> true [backward reach with edge: (event: c_e5) (guard: pc5.loc1) (assignments: pc5 := pc5.loc2)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -230,9 +202,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.Bxxx.run.out index f3e1da5da60056d822f483edb8eac266a020879a..b683faeac5f1da39fa7ccb0d7002dab10e36693a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_diamond.Bxxx.run.out @@ -122,20 +122,6 @@ Checking for bounded response: Computing reachable states: Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu1.loc1 and (pu2.loc1 and (pu3.loc1 and pu4.loc1))) [initial states predicate] - Forward reachability iteration 1: - Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu1.loc1 and (pu2.loc1 and (pu3.loc1 and pu4.loc1))) -> pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu2.loc1 and (pu3.loc1 and pu4.loc1)) [forward reach with edge: (event: u_e1) (guard: pu1.loc1) (assignments: pu1 := pu1.loc2)] - Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and pc4.loc1) and (pc5.loc1 and pu2.loc1 and (pu3.loc1 and pu4.loc1)) -> pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and pc5.loc1 and (pu3.loc1 and pu4.loc1)) [forward reach with edge: (event: u_e2) (guard: pu2.loc1) (assignments: pu2 := pu2.loc2)] - Reachable states: pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and pc5.loc1 and (pu3.loc1 and pu4.loc1)) -> pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and (pc5.loc1 and pu4.loc1)) [forward reach with edge: (event: u_e3) (guard: pu3.loc1) (assignments: pu3 := pu3.loc2)] - Reachable states: pc1.loc1 and (pc2.loc1 and pc3.loc1) and (pc4.loc1 and (pc5.loc1 and pu4.loc1)) -> pc1.loc1 and pc2.loc1 and (pc3.loc1 and (pc4.loc1 and pc5.loc1)) [forward reach with edge: (event: u_e4) (guard: pu4.loc1) (assignments: pu4 := pu4.loc2)] - Reachable states: pc1.loc1 and pc2.loc1 and (pc3.loc1 and (pc4.loc1 and pc5.loc1)) -> pc2.loc1 and pc3.loc1 and (pc4.loc1 and pc5.loc1) [forward reach with edge: (event: c_e1) (guard: pc1.loc1) (assignments: pc1 := pc1.loc2)] - Reachable states: pc2.loc1 and pc3.loc1 and (pc4.loc1 and pc5.loc1) -> pc3.loc1 and (pc4.loc1 and pc5.loc1) [forward reach with edge: (event: c_e2) (guard: pc2.loc1) (assignments: pc2 := pc2.loc2)] - Reachable states: pc3.loc1 and (pc4.loc1 and pc5.loc1) -> pc4.loc1 and pc5.loc1 [forward reach with edge: (event: c_e3) (guard: pc3.loc1) (assignments: pc3 := pc3.loc2)] - Reachable states: pc4.loc1 and pc5.loc1 -> pc5.loc1 [forward reach with edge: (event: c_e4) (guard: pc4.loc1) (assignments: pc4 := pc4.loc2)] - Reachable states: pc5.loc1 -> true [forward reach with edge: (event: c_e5) (guard: pc5.loc1) (assignments: pc5 := pc5.loc2)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.BCFN.run.out index a2075e8601ae4e8c6095911f04b8e5a91dc471f2..3ded61b5d1b84d3786462f17e31ba6abdaec8883 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.BCFN.run.out @@ -24,52 +24,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.counter = 7 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.counter = 7 -> p.counter = 8 or p.counter = 7 [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or p.counter = 7 -> p.counter = 8 or (p.counter = 6 or p.counter = 7) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: p.counter = 8 or (p.counter = 6 or p.counter = 7) -> p.counter = 8 or p.counter = 9 or (p.counter = 6 or p.counter = 7) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or p.counter = 9 or (p.counter = 6 or p.counter = 7) -> p.counter = 8 or p.counter = 6 or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) [forward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 2: - Reachable states: p.counter = 8 or p.counter = 6 or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) -> p.counter = 8 or (p.counter = 10 or p.counter = 6) or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or (p.counter = 10 or p.counter = 6) or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) -> p.counter = 8 or (p.counter = 10 or p.counter = 4) or (p.counter = 6 or p.counter = 9 or (p.counter = 5 or p.counter = 7)) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: p.counter = 8 or (p.counter = 10 or p.counter = 4) or (p.counter = 6 or p.counter = 9 or (p.counter = 5 or p.counter = 7)) -> 8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7 [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Reachable states: 8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7 -> p.counter = 8 or p.counter = 10 or (p.counter = 4 or p.counter = 6) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 3: - Reachable states: p.counter = 8 or p.counter = 10 or (p.counter = 4 or p.counter = 6) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 10 or p.counter = 6)) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 10 or p.counter = 6)) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 9 or p.counter = 5) or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 9 or p.counter = 5) or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> p.counter = 8 or (p.counter = 9 or p.counter = 4) or (p.counter = 5 or (p.counter = 12 or p.counter = 13)) or (p.counter = 2 or (p.counter = 3 or p.counter = 10) or (p.counter = 11 or (p.counter = 6 or p.counter = 7))) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or (p.counter = 9 or p.counter = 4) or (p.counter = 5 or (p.counter = 12 or p.counter = 13)) or (p.counter = 2 or (p.counter = 3 or p.counter = 10) or (p.counter = 11 or (p.counter = 6 or p.counter = 7))) -> p.counter = 8 or (p.counter = 4 or p.counter = 12) or (p.counter = 2 or (p.counter = 10 or p.counter = 6)) or (p.counter = 1 or (p.counter = 5 or p.counter = 9) or (p.counter = 13 or p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 4: - Reachable states: p.counter = 8 or (p.counter = 4 or p.counter = 12) or (p.counter = 2 or (p.counter = 10 or p.counter = 6)) or (p.counter = 1 or (p.counter = 5 or p.counter = 9) or (p.counter = 13 or p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> not(p.counter = 0 or p.counter = 16) and p.counter != 24 and (p.counter != 20 and not(p.counter = 18 or p.counter = 22)) and (not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and p.counter != 19 and (p.counter != 23 and p.counter != 15)) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: not(p.counter = 0 or p.counter = 16) and p.counter != 24 and (p.counter != 20 and not(p.counter = 18 or p.counter = 22)) and (not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and p.counter != 19 and (p.counter != 23 and p.counter != 15)) -> not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) -> 0 <= p.counter and p.counter <= 15 [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 5: - Reachable states: 0 <= p.counter and p.counter <= 15 -> p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) -> 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 6: - Reachable states: 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) -> p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) -> 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 7: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) -> p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) -> 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 8: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) -> p.counter != 24 and (p.counter != 25 and p.counter != 23) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and (p.counter != 25 and p.counter != 23) -> 0 <= p.counter and p.counter <= 23 [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 9: - Reachable states: 0 <= p.counter and p.counter <= 23 -> p.counter != 25 [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 25 -> true [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 10: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -93,13 +47,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25))) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25))) -> true [backward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Controllable-complete path states: true -> true [backward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -107,9 +54,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.Bxxx.run.out index 78da487e10a6a2b45bdab44c34483800d5efe628..ef7d4d5e26e3bc41e189c63e32263d791acf9a12 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_7.Bxxx.run.out @@ -16,52 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.counter = 7 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.counter = 7 -> p.counter = 8 or p.counter = 7 [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or p.counter = 7 -> p.counter = 8 or (p.counter = 6 or p.counter = 7) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: p.counter = 8 or (p.counter = 6 or p.counter = 7) -> p.counter = 8 or p.counter = 9 or (p.counter = 6 or p.counter = 7) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or p.counter = 9 or (p.counter = 6 or p.counter = 7) -> p.counter = 8 or p.counter = 6 or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) [forward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 2: - Reachable states: p.counter = 8 or p.counter = 6 or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) -> p.counter = 8 or (p.counter = 10 or p.counter = 6) or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or (p.counter = 10 or p.counter = 6) or (p.counter = 9 or (p.counter = 5 or p.counter = 7)) -> p.counter = 8 or (p.counter = 10 or p.counter = 4) or (p.counter = 6 or p.counter = 9 or (p.counter = 5 or p.counter = 7)) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: p.counter = 8 or (p.counter = 10 or p.counter = 4) or (p.counter = 6 or p.counter = 9 or (p.counter = 5 or p.counter = 7)) -> 8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7 [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Reachable states: 8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7 -> p.counter = 8 or p.counter = 10 or (p.counter = 4 or p.counter = 6) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 3: - Reachable states: p.counter = 8 or p.counter = 10 or (p.counter = 4 or p.counter = 6) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 10 or p.counter = 6)) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 10 or p.counter = 6)) or (p.counter = 9 or p.counter = 5 or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 9 or p.counter = 5) or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: p.counter = 8 or p.counter = 4 or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 9 or p.counter = 5) or (p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> p.counter = 8 or (p.counter = 9 or p.counter = 4) or (p.counter = 5 or (p.counter = 12 or p.counter = 13)) or (p.counter = 2 or (p.counter = 3 or p.counter = 10) or (p.counter = 11 or (p.counter = 6 or p.counter = 7))) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 8 or (p.counter = 9 or p.counter = 4) or (p.counter = 5 or (p.counter = 12 or p.counter = 13)) or (p.counter = 2 or (p.counter = 3 or p.counter = 10) or (p.counter = 11 or (p.counter = 6 or p.counter = 7))) -> p.counter = 8 or (p.counter = 4 or p.counter = 12) or (p.counter = 2 or (p.counter = 10 or p.counter = 6)) or (p.counter = 1 or (p.counter = 5 or p.counter = 9) or (p.counter = 13 or p.counter = 3 or (p.counter = 11 or p.counter = 7))) [forward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 4: - Reachable states: p.counter = 8 or (p.counter = 4 or p.counter = 12) or (p.counter = 2 or (p.counter = 10 or p.counter = 6)) or (p.counter = 1 or (p.counter = 5 or p.counter = 9) or (p.counter = 13 or p.counter = 3 or (p.counter = 11 or p.counter = 7))) -> not(p.counter = 0 or p.counter = 16) and p.counter != 24 and (p.counter != 20 and not(p.counter = 18 or p.counter = 22)) and (not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and p.counter != 19 and (p.counter != 23 and p.counter != 15)) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: not(p.counter = 0 or p.counter = 16) and p.counter != 24 and (p.counter != 20 and not(p.counter = 18 or p.counter = 22)) and (not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and p.counter != 19 and (p.counter != 23 and p.counter != 15)) -> not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) [forward reach with edge: (event: u_dec_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25)))) (assignments: p.counter := p.counter - 1)] - Reachable states: not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) -> 0 <= p.counter and p.counter <= 15 [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 5: - Reachable states: 0 <= p.counter and p.counter <= 15 -> p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) -> 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 6: - Reachable states: 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) -> p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) -> 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 7: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) -> p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) -> 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 8: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) -> p.counter != 24 and (p.counter != 25 and p.counter != 23) [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 24 and (p.counter != 25 and p.counter != 23) -> 0 <= p.counter and p.counter <= 23 [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 9: - Reachable states: 0 <= p.counter and p.counter <= 23 -> p.counter != 25 [forward reach with edge: (event: u_inc_odd) (guard: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 17 or p.counter = 19)) or (p.counter = 21 or (p.counter = 23 or p.counter = 9) or (p.counter = 11 or (p.counter = 13 or p.counter = 15)))) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter != 25 -> true [forward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 10: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.BCFN.run.out index c85d88eb50f5b0ab1a1d39d25110d64ac0c01100..fdfef699a598dbe730146c5e11075588757214c3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.BCFN.run.out @@ -24,9 +24,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). Bounded response check round 2 (states before round: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))). @@ -48,13 +45,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25))) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.counter = 1 or (p.counter = 3 or p.counter = 5) or (p.counter = 7 or (p.counter = 9 or p.counter = 11)) or (p.counter = 13 or (p.counter = 15 or p.counter = 17) or (p.counter = 19 or p.counter = 21 or (p.counter = 23 or p.counter = 25))) -> true [backward reach with edge: (event: c_inc_even) (guard: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))) (assignments: p.counter := p.counter + 1)] - Controllable-complete path states: true -> true [backward reach with edge: (event: c_dec_even) (guard: p.counter = 16 or (p.counter = 8 or p.counter = 24) or (p.counter = 4 or (p.counter = 12 or p.counter = 20)) or (p.counter = 2 or (p.counter = 6 or p.counter = 10) or (p.counter = 14 or (p.counter = 18 or p.counter = 22)))) (assignments: p.counter := p.counter - 1)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -62,9 +52,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.Bxxx.run.out index 8b902e925acfcc7e6751855a10a715749531ac5a..5baaaa535115dd674e72504aa16cba582402fecf 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_even_odd_any.Bxxx.run.out @@ -16,9 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). Bounded response check round 2 (states before round: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or (p.counter = 8 or p.counter = 10)) or (p.counter = 12 or (p.counter = 14 or p.counter = 16) or (p.counter = 18 or p.counter = 20 or (p.counter = 22 or p.counter = 24)))). diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.BCFN.run.out index 7b2a1451026ef01a733aa971d0b0747389e7d79f..28d1f1e85452bea4083a0142b1029b6fdce35976 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.BCFN.run.out @@ -127,28 +127,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.xc = 0 and p.xu = 0 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.xc = 0 and p.xu = 0 -> p.xc = 0 and (p.xu = 0 or p.xu = 1) [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: p.xc = 0 and (p.xu = 0 or p.xu = 1) -> (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 1) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 2: - Reachable states: (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 1) -> (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 1) and p.xu = 1 [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 1) and p.xu = 1 -> (p.xc = 0 or p.xc = 2) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 2) and p.xu = 1 or (p.xc = 1 and (p.xu = 0 or p.xu = 2) or p.xc = 1 and p.xu = 1) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 3: - Reachable states: (p.xc = 0 or p.xc = 2) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 2) and p.xu = 1 or (p.xc = 1 and (p.xu = 0 or p.xu = 2) or p.xc = 1 and p.xu = 1) -> (p.xc = 0 or p.xc = 2) and (0 <= p.xu and p.xu <= 3) or p.xc = 1 and (0 <= p.xu and p.xu <= 3) [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: (p.xc = 0 or p.xc = 2) and (0 <= p.xu and p.xu <= 3) or p.xc = 1 and (0 <= p.xu and p.xu <= 3) -> 0 <= p.xc and p.xc <= 3 and (0 <= p.xu and p.xu <= 3) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 4: - Reachable states: 0 <= p.xc and p.xc <= 3 and (0 <= p.xu and p.xu <= 3) -> (4 <= p.xc and p.xc <= 7 or p.xu != 6) and (4 <= p.xc and p.xc <= 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 3) [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: (4 <= p.xc and p.xc <= 7 or p.xu != 6) and (4 <= p.xc and p.xc <= 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 3) -> (not(p.xc = 0 or p.xc = 4) or p.xu != 6) and (not(p.xc = 0 or p.xc = 4) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and ((p.xc != 2 or p.xu != 6) and (p.xc != 2 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (p.xc != 6 and (not(p.xc = 1 or p.xc = 3) or p.xu != 6) and ((not(p.xc = 1 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 4 or p.xc = 6))) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 5: - Reachable states: (not(p.xc = 0 or p.xc = 4) or p.xu != 6) and (not(p.xc = 0 or p.xc = 4) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and ((p.xc != 2 or p.xu != 6) and (p.xc != 2 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (p.xc != 6 and (not(p.xc = 1 or p.xc = 3) or p.xu != 6) and ((not(p.xc = 1 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 4 or p.xc = 6))) -> (p.xc = 2 or p.xc = 3 or (p.xc = 6 or (p.xc = 7 or p.xu != 6))) and ((p.xc = 2 or (p.xc = 3 or p.xc = 6) or (p.xc = 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (not(p.xc = 2 or p.xc = 3) or p.xu != 6)) and ((not(p.xc = 2 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 5)) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 6: - No change this iteration. - Reachable states: (p.xc = 2 or p.xc = 3 or (p.xc = 6 or (p.xc = 7 or p.xu != 6))) and ((p.xc = 2 or (p.xc = 3 or p.xc = 6) or (p.xc = 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (not(p.xc = 2 or p.xc = 3) or p.xu != 6)) and ((not(p.xc = 2 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 5)) [fixed point]. Computing bound for uncontrollable events: @@ -179,24 +157,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.xc = 6 or (p.xc = 5 or p.xc = 7) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.xc = 6 or (p.xc = 5 or p.xc = 7) -> 4 <= p.xc and p.xc <= 7 [backward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Backward reachability iteration 2: - Controllable-complete path states: 4 <= p.xc and p.xc <= 7 -> (p.xc = 1 or 3 <= p.xc and p.xc <= 7) and p.xc != 1 [backward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Backward reachability iteration 3: - Controllable-complete path states: (p.xc = 1 or 3 <= p.xc and p.xc <= 7) and p.xc != 1 -> 2 <= p.xc and p.xc <= 7 [backward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Backward reachability iteration 4: - Controllable-complete path states: 2 <= p.xc and p.xc <= 7 -> p.xc != 0 [backward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Backward reachability iteration 5: - Controllable-complete path states: p.xc != 0 -> true [backward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Backward reachability iteration 6: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -204,9 +164,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.Bxxx.run.out index 1c5ae243cfa4c25161a2b997d8e7b761d572eda7..74f18023c517b3205517d04ceee97b9c838b6f99 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_state_evt_excl_inv.Bxxx.run.out @@ -113,28 +113,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.xc = 0 and p.xu = 0 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.xc = 0 and p.xu = 0 -> p.xc = 0 and (p.xu = 0 or p.xu = 1) [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: p.xc = 0 and (p.xu = 0 or p.xu = 1) -> (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 1) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 2: - Reachable states: (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 1) -> (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 1) and p.xu = 1 [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: (p.xc = 0 or p.xc = 1) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 1) and p.xu = 1 -> (p.xc = 0 or p.xc = 2) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 2) and p.xu = 1 or (p.xc = 1 and (p.xu = 0 or p.xu = 2) or p.xc = 1 and p.xu = 1) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 3: - Reachable states: (p.xc = 0 or p.xc = 2) and (p.xu = 0 or p.xu = 2) or (p.xc = 0 or p.xc = 2) and p.xu = 1 or (p.xc = 1 and (p.xu = 0 or p.xu = 2) or p.xc = 1 and p.xu = 1) -> (p.xc = 0 or p.xc = 2) and (0 <= p.xu and p.xu <= 3) or p.xc = 1 and (0 <= p.xu and p.xu <= 3) [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: (p.xc = 0 or p.xc = 2) and (0 <= p.xu and p.xu <= 3) or p.xc = 1 and (0 <= p.xu and p.xu <= 3) -> 0 <= p.xc and p.xc <= 3 and (0 <= p.xu and p.xu <= 3) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 4: - Reachable states: 0 <= p.xc and p.xc <= 3 and (0 <= p.xu and p.xu <= 3) -> (4 <= p.xc and p.xc <= 7 or p.xu != 6) and (4 <= p.xc and p.xc <= 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 3) [forward reach with edge: (event: u) (guard: true -> 0 <= p.xu and p.xu <= 3) (assignments: p.xu := p.xu + 1)] - Reachable states: (4 <= p.xc and p.xc <= 7 or p.xu != 6) and (4 <= p.xc and p.xc <= 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 3) -> (not(p.xc = 0 or p.xc = 4) or p.xu != 6) and (not(p.xc = 0 or p.xc = 4) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and ((p.xc != 2 or p.xu != 6) and (p.xc != 2 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (p.xc != 6 and (not(p.xc = 1 or p.xc = 3) or p.xu != 6) and ((not(p.xc = 1 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 4 or p.xc = 6))) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 5: - Reachable states: (not(p.xc = 0 or p.xc = 4) or p.xu != 6) and (not(p.xc = 0 or p.xc = 4) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and ((p.xc != 2 or p.xu != 6) and (p.xc != 2 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (p.xc != 6 and (not(p.xc = 1 or p.xc = 3) or p.xu != 6) and ((not(p.xc = 1 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 4 or p.xc = 6))) -> (p.xc = 2 or p.xc = 3 or (p.xc = 6 or (p.xc = 7 or p.xu != 6))) and ((p.xc = 2 or (p.xc = 3 or p.xc = 6) or (p.xc = 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (not(p.xc = 2 or p.xc = 3) or p.xu != 6)) and ((not(p.xc = 2 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 5)) [forward reach with edge: (event: c) (guard: true -> p.xc != 6 and (0 <= p.xc and p.xc <= 4 or p.xc = 6)) (assignments: p.xc := p.xc + 1)] - - Forward reachability iteration 6: - No change this iteration. - Reachable states: (p.xc = 2 or p.xc = 3 or (p.xc = 6 or (p.xc = 7 or p.xu != 6))) and ((p.xc = 2 or (p.xc = 3 or p.xc = 6) or (p.xc = 7 or (0 <= p.xu and p.xu <= 4 or p.xu = 6))) and (not(p.xc = 2 or p.xc = 3) or p.xu != 6)) and ((not(p.xc = 2 or p.xc = 3) or (0 <= p.xu and p.xu <= 4 or p.xu = 6)) and (0 <= p.xc and p.xc <= 5)) [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.BCFN.run.out index d820e037af11d89c7dfda2d6a2bfeef5aad2e77c..b22ec98f76490ff5c0c7c8f665148d5d5572c382 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.BCFN.run.out @@ -46,14 +46,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.x = 0 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.x = 0 -> p.x = 0 or p.x = 1 [forward reach with edge: (event: u_a) (guard: p.x = 0) (assignments: p.x := p.x + 1)] - Reachable states: p.x = 0 or p.x = 1 -> p.x != 4 and (p.x != 5 and p.x != 3) [forward reach with edge: (event: u_b) (guard: p.x = 1) (assignments: p.x := p.x + 1)] - Reachable states: p.x != 4 and (p.x != 5 and p.x != 3) -> 0 <= p.x and p.x <= 3 [forward reach with edge: (event: u_c) (guard: p.x = 2) (assignments: p.x := p.x + 1)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: 0 <= p.x and p.x <= 3 [fixed point]. Computing bound for uncontrollable events: @@ -79,17 +71,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.Bxxx.run.out index 0c591a74117b07ae05fe658bbc2b98896fd136a9..477932892ffc3b37cb3b0d4f851bb14d86947bcc 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_supervised_counter.Bxxx.run.out @@ -26,14 +26,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.x = 0 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.x = 0 -> p.x = 0 or p.x = 1 [forward reach with edge: (event: u_a) (guard: p.x = 0) (assignments: p.x := p.x + 1)] - Reachable states: p.x = 0 or p.x = 1 -> p.x != 4 and (p.x != 5 and p.x != 3) [forward reach with edge: (event: u_b) (guard: p.x = 1) (assignments: p.x := p.x + 1)] - Reachable states: p.x != 4 and (p.x != 5 and p.x != 3) -> 0 <= p.x and p.x <= 3 [forward reach with edge: (event: u_c) (guard: p.x = 2) (assignments: p.x := p.x + 1)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: 0 <= p.x and p.x <= 3 [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.BCFN.run.out index dd5e71a6bc9228ed220118149530b2363c71aa14..9fce22b65a82b6dcb012bde70a2b2e3690802fd0 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.BCFN.run.out @@ -132,20 +132,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p2.loc1 and p1.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p2.loc1 and p1.loc1 -> p2.loc1 and (p1.loc1 or p1.loc2) [forward reach with edge: (event: u_a) (guard: p1.loc1) (assignments: p1 := p1.loc2)] - Reachable states: p2.loc1 and (p1.loc1 or p1.loc2) -> p2.loc1 and (p1.loc1 or p1.loc5) or p2.loc1 and p1.loc2 [forward reach with edge: (event: u_d) (guard: p1.loc1) (assignments: p1 := p1.loc5)] - Reachable states: p2.loc1 and (p1.loc1 or p1.loc5) or p2.loc1 and p1.loc2 -> p2.loc1 and (p1.loc1 or p1.loc5) or (p2.loc1 and p1.loc3 or p2.loc1 and p1.loc2) [forward reach with edge: (event: u_b) (guard: p1.loc2) (assignments: p1 := p1.loc3)] - Reachable states: p2.loc1 and (p1.loc1 or p1.loc5) or (p2.loc1 and p1.loc3 or p2.loc1 and p1.loc2) -> not p2.loc5 and (not p2.loc3 and (p2.loc1 or (p2.loc3 or p2.loc5))) [forward reach with edge: (event: u_c) (guard: p1.loc2) (assignments: p1 := p1.loc4)] - Reachable states: not p2.loc5 and (not p2.loc3 and (p2.loc1 or (p2.loc3 or p2.loc5))) -> not p2.loc5 and not p2.loc6 and (not p2.loc3 and not p2.loc4) [forward reach with edge: (event: c_a) (guard: p2.loc1) (assignments: p2 := p2.loc2)] - Reachable states: not p2.loc5 and not p2.loc6 and (not p2.loc3 and not p2.loc4) -> not p2.loc5 and (not p2.loc6 and not p2.loc4) [forward reach with edge: (event: c_b) (guard: p2.loc2) (assignments: p2 := p2.loc3)] - Reachable states: not p2.loc5 and (not p2.loc6 and not p2.loc4) -> not p2.loc6 and not p2.loc4 [forward reach with edge: (event: c_d) (guard: p2.loc2) (assignments: p2 := p2.loc5)] - Reachable states: not p2.loc6 and not p2.loc4 -> not p2.loc6 [forward reach with edge: (event: c_c) (guard: p2.loc3) (assignments: p2 := p2.loc4)] - Reachable states: not p2.loc6 -> true [forward reach with edge: (event: c_e) (guard: p2.loc3) (assignments: p2 := p2.loc6)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -172,18 +158,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p2.loc5 and p1.loc5 or p2.loc5 and p1.loc3 or (p2.loc5 and p1.loc4 or p2.loc6 and p1.loc5) or (p2.loc6 and p1.loc3 or p2.loc6 and p1.loc4 or (p2.loc4 and p1.loc5 or (p2.loc4 and p1.loc3 or p2.loc4 and p1.loc4))) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p2.loc5 and p1.loc5 or p2.loc5 and p1.loc3 or (p2.loc5 and p1.loc4 or p2.loc6 and p1.loc5) or (p2.loc6 and p1.loc3 or p2.loc6 and p1.loc4 or (p2.loc4 and p1.loc5 or (p2.loc4 and p1.loc3 or p2.loc4 and p1.loc4))) -> not p2.loc1 and ((not p2.loc5 or not p1.loc2) and not p2.loc3) and (not p2.loc2 and ((not p2.loc6 or not p1.loc2) and (not p2.loc4 or not p1.loc2))) [backward reach with edge: (event: u_d) (guard: p1.loc1 -> p2.loc5 and p1.loc1 or (p2.loc6 and p1.loc1 or p2.loc4 and p1.loc1)) (assignments: p1 := p1.loc5)] - Controllable-complete path states: not p2.loc1 and ((not p2.loc5 or not p1.loc2) and not p2.loc3) and (not p2.loc2 and ((not p2.loc6 or not p1.loc2) and (not p2.loc4 or not p1.loc2))) -> not p2.loc1 and (not p2.loc3 and not p2.loc2) [backward reach with edge: (event: u_b) (guard: p1.loc2 -> p2.loc5 and p1.loc2 or (p2.loc6 and p1.loc2 or p2.loc4 and p1.loc2)) (assignments: p1 := p1.loc3)] - Controllable-complete path states: not p2.loc1 and (not p2.loc3 and not p2.loc2) -> not p2.loc1 and not p2.loc3 [backward reach with edge: (event: c_d) (guard: p2.loc2) (assignments: p2 := p2.loc5)] - Controllable-complete path states: not p2.loc1 and not p2.loc3 -> <bdd 8n 12p> [backward reach with edge: (event: c_c) (guard: p2.loc3) (assignments: p2 := p2.loc4)] - - Backward reachability iteration 2: - Controllable-complete path states: <bdd 8n 12p> -> true [backward reach with edge: (event: c_a) (guard: p2.loc1) (assignments: p2 := p2.loc2)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -191,9 +165,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.Bxxx.run.out index ab80aa1cd089f56af3b9ca06c285b9a3a40b539c..a509602dc88418882230a86e7e571246266c88dc 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/bounded_tree.Bxxx.run.out @@ -110,20 +110,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p2.loc1 and p1.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p2.loc1 and p1.loc1 -> p2.loc1 and (p1.loc1 or p1.loc2) [forward reach with edge: (event: u_a) (guard: p1.loc1) (assignments: p1 := p1.loc2)] - Reachable states: p2.loc1 and (p1.loc1 or p1.loc2) -> p2.loc1 and (p1.loc1 or p1.loc5) or p2.loc1 and p1.loc2 [forward reach with edge: (event: u_d) (guard: p1.loc1) (assignments: p1 := p1.loc5)] - Reachable states: p2.loc1 and (p1.loc1 or p1.loc5) or p2.loc1 and p1.loc2 -> p2.loc1 and (p1.loc1 or p1.loc5) or (p2.loc1 and p1.loc3 or p2.loc1 and p1.loc2) [forward reach with edge: (event: u_b) (guard: p1.loc2) (assignments: p1 := p1.loc3)] - Reachable states: p2.loc1 and (p1.loc1 or p1.loc5) or (p2.loc1 and p1.loc3 or p2.loc1 and p1.loc2) -> not p2.loc5 and (not p2.loc3 and (p2.loc1 or (p2.loc3 or p2.loc5))) [forward reach with edge: (event: u_c) (guard: p1.loc2) (assignments: p1 := p1.loc4)] - Reachable states: not p2.loc5 and (not p2.loc3 and (p2.loc1 or (p2.loc3 or p2.loc5))) -> not p2.loc5 and not p2.loc6 and (not p2.loc3 and not p2.loc4) [forward reach with edge: (event: c_a) (guard: p2.loc1) (assignments: p2 := p2.loc2)] - Reachable states: not p2.loc5 and not p2.loc6 and (not p2.loc3 and not p2.loc4) -> not p2.loc5 and (not p2.loc6 and not p2.loc4) [forward reach with edge: (event: c_b) (guard: p2.loc2) (assignments: p2 := p2.loc3)] - Reachable states: not p2.loc5 and (not p2.loc6 and not p2.loc4) -> not p2.loc6 and not p2.loc4 [forward reach with edge: (event: c_d) (guard: p2.loc2) (assignments: p2 := p2.loc5)] - Reachable states: not p2.loc6 and not p2.loc4 -> not p2.loc6 [forward reach with edge: (event: c_c) (guard: p2.loc3) (assignments: p2 := p2.loc4)] - Reachable states: not p2.loc6 -> true [forward reach with edge: (event: c_e) (guard: p2.loc3) (assignments: p2 := p2.loc6)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.BCFN.run.out index 202d56d11ffc20397b06d6479273ea639b17dceb..ac6a0b0711d5628f0c8c658486fffda53f50cd12 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.BCFN.run.out @@ -24,78 +24,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.counter = 3 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.counter = 3 -> p.counter = 4 or p.counter = 3 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 4 or p.counter = 3 -> p.counter = 4 or (p.counter = 2 or p.counter = 3) [forward reach with edge: (event: c_dec) (guard: p.counter != 0) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 2: - Reachable states: p.counter = 4 or (p.counter = 2 or p.counter = 3) -> p.counter = 4 or p.counter = 5 or (p.counter = 2 or p.counter = 3) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 4 or p.counter = 5 or (p.counter = 2 or p.counter = 3) -> p.counter = 4 or p.counter = 2 or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) [forward reach with edge: (event: c_dec) (guard: p.counter != 0) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 3: - Reachable states: p.counter = 4 or p.counter = 2 or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) -> p.counter = 4 or (p.counter = 2 or p.counter = 6) or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 4 or (p.counter = 2 or p.counter = 6) or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) -> p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or p.counter = 1 or (p.counter = 5 or p.counter = 3)) [forward reach with edge: (event: c_dec) (guard: p.counter != 0) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 4: - Reachable states: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or p.counter = 1 or (p.counter = 5 or p.counter = 3)) -> 0 <= p.counter and p.counter <= 7 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 5: - Reachable states: 0 <= p.counter and p.counter <= 7 -> p.counter = 0 or p.counter = 8 or (p.counter = 4 or p.counter = 2) or (p.counter = 6 or p.counter = 1 or (p.counter = 3 or (p.counter = 5 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 6: - Reachable states: p.counter = 0 or p.counter = 8 or (p.counter = 4 or p.counter = 2) or (p.counter = 6 or p.counter = 1 or (p.counter = 3 or (p.counter = 5 or p.counter = 7))) -> p.counter = 0 or p.counter = 1 or (p.counter = 8 or (p.counter = 9 or p.counter = 4)) or (p.counter = 5 or p.counter = 2 or (p.counter = 3 or (p.counter = 6 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 7: - Reachable states: p.counter = 0 or p.counter = 1 or (p.counter = 8 or (p.counter = 9 or p.counter = 4)) or (p.counter = 5 or p.counter = 2 or (p.counter = 3 or (p.counter = 6 or p.counter = 7))) -> p.counter = 0 or p.counter = 2 or (p.counter = 8 or (p.counter = 10 or p.counter = 4)) or (p.counter = 6 or (p.counter = 1 or p.counter = 9) or (p.counter = 5 or (p.counter = 3 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 8: - Reachable states: p.counter = 0 or p.counter = 2 or (p.counter = 8 or (p.counter = 10 or p.counter = 4)) or (p.counter = 6 or (p.counter = 1 or p.counter = 9) or (p.counter = 5 or (p.counter = 3 or p.counter = 7))) -> 0 <= p.counter and p.counter <= 3 or (8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 9: - Reachable states: 0 <= p.counter and p.counter <= 3 or (8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7) -> p.counter = 0 or (p.counter = 4 or p.counter = 8) or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 1 or p.counter = 3) or (p.counter = 9 or p.counter = 11 or (p.counter = 5 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 10: - Reachable states: p.counter = 0 or (p.counter = 4 or p.counter = 8) or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 1 or p.counter = 3) or (p.counter = 9 or p.counter = 11 or (p.counter = 5 or p.counter = 7))) -> (0 <= p.counter and p.counter <= 15 or p.counter = 18 or (p.counter = 19 or (p.counter = 22 or p.counter = 23))) and not(p.counter = 18 or p.counter = 19) and (not(p.counter = 22 or p.counter = 23) and not(p.counter = 14 or p.counter = 15)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 11: - Reachable states: (0 <= p.counter and p.counter <= 15 or p.counter = 18 or (p.counter = 19 or (p.counter = 22 or p.counter = 23))) and not(p.counter = 18 or p.counter = 19) and (not(p.counter = 22 or p.counter = 23) and not(p.counter = 14 or p.counter = 15)) -> not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 12: - Reachable states: not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) -> 0 <= p.counter and p.counter <= 15 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 13: - Reachable states: 0 <= p.counter and p.counter <= 15 -> p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 14: - Reachable states: p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) -> 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 15: - Reachable states: 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) -> p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 16: - Reachable states: p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) -> 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 17: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) -> p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 18: - Reachable states: p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) -> 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 19: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) -> p.counter != 24 and (p.counter != 25 and p.counter != 23) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 20: - Reachable states: p.counter != 24 and (p.counter != 25 and p.counter != 23) -> 0 <= p.counter and p.counter <= 23 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 21: - Reachable states: 0 <= p.counter and p.counter <= 23 -> p.counter != 25 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 22: - Reachable states: p.counter != 25 -> true [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 23: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -117,17 +45,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.Bxxx.run.out index abb7bc3a762360854268522567d38832ace518f9..d02d14e2757645a2a4635557a93037cb27008ba9 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_3.Bxxx.run.out @@ -16,78 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.counter = 3 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.counter = 3 -> p.counter = 4 or p.counter = 3 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 4 or p.counter = 3 -> p.counter = 4 or (p.counter = 2 or p.counter = 3) [forward reach with edge: (event: c_dec) (guard: p.counter != 0) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 2: - Reachable states: p.counter = 4 or (p.counter = 2 or p.counter = 3) -> p.counter = 4 or p.counter = 5 or (p.counter = 2 or p.counter = 3) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 4 or p.counter = 5 or (p.counter = 2 or p.counter = 3) -> p.counter = 4 or p.counter = 2 or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) [forward reach with edge: (event: c_dec) (guard: p.counter != 0) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 3: - Reachable states: p.counter = 4 or p.counter = 2 or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) -> p.counter = 4 or (p.counter = 2 or p.counter = 6) or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - Reachable states: p.counter = 4 or (p.counter = 2 or p.counter = 6) or (p.counter = 1 or (p.counter = 5 or p.counter = 3)) -> p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or p.counter = 1 or (p.counter = 5 or p.counter = 3)) [forward reach with edge: (event: c_dec) (guard: p.counter != 0) (assignments: p.counter := p.counter - 1)] - - Forward reachability iteration 4: - Reachable states: p.counter = 0 or (p.counter = 2 or p.counter = 4) or (p.counter = 6 or p.counter = 1 or (p.counter = 5 or p.counter = 3)) -> 0 <= p.counter and p.counter <= 7 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 5: - Reachable states: 0 <= p.counter and p.counter <= 7 -> p.counter = 0 or p.counter = 8 or (p.counter = 4 or p.counter = 2) or (p.counter = 6 or p.counter = 1 or (p.counter = 3 or (p.counter = 5 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 6: - Reachable states: p.counter = 0 or p.counter = 8 or (p.counter = 4 or p.counter = 2) or (p.counter = 6 or p.counter = 1 or (p.counter = 3 or (p.counter = 5 or p.counter = 7))) -> p.counter = 0 or p.counter = 1 or (p.counter = 8 or (p.counter = 9 or p.counter = 4)) or (p.counter = 5 or p.counter = 2 or (p.counter = 3 or (p.counter = 6 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 7: - Reachable states: p.counter = 0 or p.counter = 1 or (p.counter = 8 or (p.counter = 9 or p.counter = 4)) or (p.counter = 5 or p.counter = 2 or (p.counter = 3 or (p.counter = 6 or p.counter = 7))) -> p.counter = 0 or p.counter = 2 or (p.counter = 8 or (p.counter = 10 or p.counter = 4)) or (p.counter = 6 or (p.counter = 1 or p.counter = 9) or (p.counter = 5 or (p.counter = 3 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 8: - Reachable states: p.counter = 0 or p.counter = 2 or (p.counter = 8 or (p.counter = 10 or p.counter = 4)) or (p.counter = 6 or (p.counter = 1 or p.counter = 9) or (p.counter = 5 or (p.counter = 3 or p.counter = 7))) -> 0 <= p.counter and p.counter <= 3 or (8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 9: - Reachable states: 0 <= p.counter and p.counter <= 3 or (8 <= p.counter and p.counter <= 11 or 4 <= p.counter and p.counter <= 7) -> p.counter = 0 or (p.counter = 4 or p.counter = 8) or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 1 or p.counter = 3) or (p.counter = 9 or p.counter = 11 or (p.counter = 5 or p.counter = 7))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 10: - Reachable states: p.counter = 0 or (p.counter = 4 or p.counter = 8) or (p.counter = 12 or (p.counter = 2 or p.counter = 10)) or (p.counter = 6 or (p.counter = 1 or p.counter = 3) or (p.counter = 9 or p.counter = 11 or (p.counter = 5 or p.counter = 7))) -> (0 <= p.counter and p.counter <= 15 or p.counter = 18 or (p.counter = 19 or (p.counter = 22 or p.counter = 23))) and not(p.counter = 18 or p.counter = 19) and (not(p.counter = 22 or p.counter = 23) and not(p.counter = 14 or p.counter = 15)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 11: - Reachable states: (0 <= p.counter and p.counter <= 15 or p.counter = 18 or (p.counter = 19 or (p.counter = 22 or p.counter = 23))) and not(p.counter = 18 or p.counter = 19) and (not(p.counter = 22 or p.counter = 23) and not(p.counter = 14 or p.counter = 15)) -> not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 12: - Reachable states: not(p.counter = 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24))) and not(p.counter = 17 or (p.counter = 21 or p.counter = 25)) and (p.counter != 19 and (p.counter != 23 and p.counter != 15)) -> 0 <= p.counter and p.counter <= 15 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 13: - Reachable states: 0 <= p.counter and p.counter <= 15 -> p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 14: - Reachable states: p.counter != 24 and p.counter != 20 and (not(p.counter = 18 or p.counter = 22) and (0 <= p.counter and p.counter <= 16 or p.counter = 18 or (p.counter = 20 or (p.counter = 22 or p.counter = 24)))) -> 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 15: - Reachable states: 0 <= p.counter and p.counter <= 23 and (not(p.counter = 20 or p.counter = 21) and not(p.counter = 18 or p.counter = 19 or (p.counter = 22 or p.counter = 23))) -> p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 16: - Reachable states: p.counter != 24 and not(p.counter = 20 or p.counter = 22) and (p.counter != 25 and (p.counter != 21 and not(p.counter = 19 or p.counter = 23))) -> 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 17: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(20 <= p.counter and p.counter <= 23)) -> p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 18: - Reachable states: p.counter != 24 and p.counter != 22 and (p.counter != 25 and not(p.counter = 21 or p.counter = 23)) -> 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 19: - Reachable states: 0 <= p.counter and (p.counter <= 23 and not(p.counter = 22 or p.counter = 23)) -> p.counter != 24 and (p.counter != 25 and p.counter != 23) [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 20: - Reachable states: p.counter != 24 and (p.counter != 25 and p.counter != 23) -> 0 <= p.counter and p.counter <= 23 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 21: - Reachable states: 0 <= p.counter and p.counter <= 23 -> p.counter != 25 [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 22: - Reachable states: p.counter != 25 -> true [forward reach with edge: (event: c_inc) (guard: p.counter != 25) (assignments: p.counter := p.counter + 1)] - - Forward reachability iteration 23: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.BCFN.run.out index 9f0bafef9f04ebba253898495663902ca3ac2eb4..850614d177bcfee1bbd74cbb6f70d7628800b797 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.BCFN.run.out @@ -24,9 +24,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). @@ -46,17 +43,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.Bxxx.run.out index df1692bfd15db0f9065ea125b2c80de154fb301d..006ab768435315ee33d63d05a2ee6918b0beefa2 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_counter_any.Bxxx.run.out @@ -16,9 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.BCFN.run.out index eb1c32d9d09b306a024fdc28411b9f5ae9f49250..a29b097756c41694f9c858361ec280339f038a6f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.BCFN.run.out @@ -25,12 +25,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.Off -> true [forward reach with edge: (event: c_on) (guard: p.Off) (assignments: p := p.On)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -52,17 +46,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.Bxxx.run.out index b5c66a79c6d251600255212cab4c1664c0507c31..9c85f0fb0d51e12b5e47fbb98db607b82536151b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_ctrl.Bxxx.run.out @@ -16,12 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.Off -> true [forward reach with edge: (event: c_on) (guard: p.Off) (assignments: p := p.On)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.BCFN.run.out index 2c7528665d2dbb20e72cf3b3a0b8d804b02f3142..cb31366d13051a1aaa3bb1ed1ddfdf017a221358 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.BCFN.run.out @@ -119,16 +119,6 @@ Checking for bounded response: Computing reachable states: Reachable states: pu.loc1 and pc.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: pu.loc1 and pc.loc1 -> (pu.loc1 or pu.loc2) and pc.loc1 [forward reach with edge: (event: u_e1) (guard: pu.loc1) (assignments: pu := pu.loc2)] - Reachable states: (pu.loc1 or pu.loc2) and pc.loc1 -> (pu.loc1 or pu.loc3) and pc.loc1 or pu.loc2 and pc.loc1 [forward reach with edge: (event: u_e2) (guard: pu.loc2) (assignments: pu := pu.loc3)] - Reachable states: (pu.loc1 or pu.loc3) and pc.loc1 or pu.loc2 and pc.loc1 -> pc.loc1 [forward reach with edge: (event: u_e4) (guard: pu.loc3) (assignments: pu := pu.loc4)] - Reachable states: pc.loc1 -> not pc.loc3 [forward reach with edge: (event: c_e1) (guard: pc.loc1) (assignments: pc := pc.loc2)] - Reachable states: not pc.loc3 -> true [forward reach with edge: (event: c_e3) (guard: pc.loc2) (assignments: pc := pc.loc3)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -150,17 +140,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.Bxxx.run.out index 866dffd1d237f5a2b30278b1334c32c9247f75a9..2e35a6bcd9bb0026910bacd2d9618d153b1f8e59 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_in_cycle.Bxxx.run.out @@ -102,16 +102,6 @@ Checking for bounded response: Computing reachable states: Reachable states: pu.loc1 and pc.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: pu.loc1 and pc.loc1 -> (pu.loc1 or pu.loc2) and pc.loc1 [forward reach with edge: (event: u_e1) (guard: pu.loc1) (assignments: pu := pu.loc2)] - Reachable states: (pu.loc1 or pu.loc2) and pc.loc1 -> (pu.loc1 or pu.loc3) and pc.loc1 or pu.loc2 and pc.loc1 [forward reach with edge: (event: u_e2) (guard: pu.loc2) (assignments: pu := pu.loc3)] - Reachable states: (pu.loc1 or pu.loc3) and pc.loc1 or pu.loc2 and pc.loc1 -> pc.loc1 [forward reach with edge: (event: u_e4) (guard: pu.loc3) (assignments: pu := pu.loc4)] - Reachable states: pc.loc1 -> not pc.loc3 [forward reach with edge: (event: c_e1) (guard: pc.loc1) (assignments: pc := pc.loc2)] - Reachable states: not pc.loc3 -> true [forward reach with edge: (event: c_e3) (guard: pc.loc2) (assignments: pc := pc.loc3)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.BCFN.run.out index d83ff07464be685ff0e7b760eb03b17138946c51..6f5d8ecd956fc8fdf5284ad5e3679240ae72ec49 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.BCFN.run.out @@ -37,18 +37,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 -> p.loc1 or p.loc3 [forward reach with edge: (event: u_e1) (guard: p.loc1) (assignments: p := p.loc3)] - Reachable states: p.loc1 or p.loc3 -> p.loc1 or (p.loc3 or p.loc2) [forward reach with edge: (event: c_c1) (guard: p.loc1) (assignments: p := p.loc2)] - Reachable states: p.loc1 or (p.loc3 or p.loc2) -> p.loc1 or p.loc2 or (p.loc3 or p.loc4) [forward reach with edge: (event: u_c1) (guard: p.loc3) (assignments: p := p.loc4)] - Reachable states: p.loc1 or p.loc2 or (p.loc3 or p.loc4) -> not p.loc7 and (not p.loc6 and not p.loc8) [forward reach with edge: (event: u_e2) (guard: p.loc3) (assignments: p := p.loc5)] - Reachable states: not p.loc7 and (not p.loc6 and not p.loc8) -> not p.loc7 and not p.loc8 [forward reach with edge: (event: u_e3) (guard: p.loc5) (assignments: p := p.loc6)] - Reachable states: not p.loc7 and not p.loc8 -> not p.loc8 [forward reach with edge: (event: c_e2) (guard: p.loc6) (assignments: p := p.loc7)] - Reachable states: not p.loc8 -> true [forward reach with edge: (event: c_e3) (guard: p.loc7) (assignments: p := p.loc8)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -74,18 +62,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.loc8 [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.loc8 -> p.loc7 or p.loc8 [backward reach with edge: (event: c_e3) (guard: p.loc7) (assignments: p := p.loc8)] - - Backward reachability iteration 2: - Controllable-complete path states: p.loc7 or p.loc8 -> p.loc7 or (p.loc6 or p.loc8) [backward reach with edge: (event: c_e2) (guard: p.loc6) (assignments: p := p.loc7)] - - Backward reachability iteration 3: - Controllable-complete path states: p.loc7 or (p.loc6 or p.loc8) -> p.loc5 or p.loc6 or (p.loc7 or p.loc8) [backward reach with edge: (event: u_e3) (guard: p.loc5) (assignments: p := p.loc6)] - - Backward reachability iteration 4: - No change this iteration. - Controllable-complete path states: p.loc5 or p.loc6 or (p.loc7 or p.loc8) [fixed point]. Controllable-complete path states: p.loc5 or p.loc6 or (p.loc7 or p.loc8) @@ -93,9 +69,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: p.loc1 or p.loc2 or (p.loc3 or p.loc4) [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: p.loc1 or p.loc2 or (p.loc3 or p.loc4) Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.Bxxx.run.out index 81afdb1fc96ac30db6d7dade5d51559d636080c3..90a17a6416ac440e5fa181c3b54ede7c6a21aa43 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_mix.Bxxx.run.out @@ -16,18 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 -> p.loc1 or p.loc3 [forward reach with edge: (event: u_e1) (guard: p.loc1) (assignments: p := p.loc3)] - Reachable states: p.loc1 or p.loc3 -> p.loc1 or (p.loc3 or p.loc2) [forward reach with edge: (event: c_c1) (guard: p.loc1) (assignments: p := p.loc2)] - Reachable states: p.loc1 or (p.loc3 or p.loc2) -> p.loc1 or p.loc2 or (p.loc3 or p.loc4) [forward reach with edge: (event: u_c1) (guard: p.loc3) (assignments: p := p.loc4)] - Reachable states: p.loc1 or p.loc2 or (p.loc3 or p.loc4) -> not p.loc7 and (not p.loc6 and not p.loc8) [forward reach with edge: (event: u_e2) (guard: p.loc3) (assignments: p := p.loc5)] - Reachable states: not p.loc7 and (not p.loc6 and not p.loc8) -> not p.loc7 and not p.loc8 [forward reach with edge: (event: u_e3) (guard: p.loc5) (assignments: p := p.loc6)] - Reachable states: not p.loc7 and not p.loc8 -> not p.loc8 [forward reach with edge: (event: c_e2) (guard: p.loc6) (assignments: p := p.loc7)] - Reachable states: not p.loc8 -> true [forward reach with edge: (event: c_e3) (guard: p.loc7) (assignments: p := p.loc8)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.BCFN.run.out index 1716656b04827e418ca99f3749e10203e3ab5c1f..423ba2da142f72cc9d166bea45a85506fcf3033a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.BCFN.run.out @@ -12,9 +12,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). @@ -34,17 +31,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: true [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: true Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.Bxxx.run.out index 6250e06e265fea73ae05e3a6dfdc81ad80e2652f..dd9c15b404096c0f81296330f13df366acec0010 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_self_loop.Bxxx.run.out @@ -9,9 +9,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.BCFN.run.out index 57710f376f8b2999e4b8de270679c5c14f012037..1f410cc278ea1acca8388a45ae600331bcf02b6e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.BCFN.run.out @@ -19,12 +19,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.Off -> true [forward reach with edge: (event: u_on) (guard: p.Off) (assignments: p := p.On)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -46,12 +40,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.Off [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.Off -> true [backward reach with edge: (event: u_off) (guard: p.On) (assignments: p := p.Off)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -59,9 +47,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.Bxxx.run.out index e1e5f5f3003245244eb4b7d68a6034fa581c4601..8ddf0ba786efd23aaafbe89371112f4c0c53197d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/cycle_unctrl.Bxxx.run.out @@ -16,12 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.Off -> true [forward reach with edge: (event: u_on) (guard: p.Off) (assignments: p := p.On)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.BCFN.run.out index 4e307350bfa17e147c3a6f08487e2750c140cbb0..52901ed90bae7cebc501024e249700f0a61967bb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.BCFN.run.out @@ -15,9 +15,6 @@ Checking for bounded response: Computing reachable states: Reachable states: false [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bound: 0. @@ -33,17 +30,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.Bxxx.run.out index 65007ba736fccb6daa8f340ac16163254a25108d..746eaa39bf279a672e06da195c2043e484c657c5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/no_init.Bxxx.run.out @@ -9,9 +9,6 @@ Checking for bounded response: Computing reachable states: Reachable states: false [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bound: 0. diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.BCFN.run.out index 6014df086506284978531e9aef2bdd43040dfb23..9dab45ca3a99a1713148a20e80bee649df3e211f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.BCFN.run.out @@ -15,9 +15,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). @@ -37,17 +34,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.Bxxx.run.out index 0a23b910367681d5b4e2ff90183ee37c4d77f6c7..879dee29435f8df78cf8c00b02b1bcc52c8f81df 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/bounded_response/svgin_remove.Bxxx.run.out @@ -9,9 +9,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.BCFN.run.out index e311c827ca9c3ca7e4f6d7d6f1f30afb8e633aea..762b35196a8605eb0363f805243c8bd8f04c0f1e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.BCFN.run.out @@ -24,13 +24,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 -> not p.loc3 [forward reach with edge: (event: c) (guard: p.loc1) (assignments: p := p.loc2)] - Reachable states: not p.loc3 -> true [forward reach with edge: (event: u) (guard: p.loc2) (assignments: p := p.loc3)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -54,15 +47,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.loc3 [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.loc3 -> not p.loc1 [backward reach with edge: (event: u) (guard: p.loc2) (assignments: p := p.loc3)] - - Backward reachability iteration 2: - Controllable-complete path states: not p.loc1 -> true [backward reach with edge: (event: c) (guard: p.loc1) (assignments: p := p.loc2)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -70,9 +54,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.Bxxx.run.out index fe1596c44eff0b68d6170ad63bd68e3e9a9dda7e..e30b9fa9928f29c5358ee6184b5cc938a301e74c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.Bxxx.run.out @@ -16,13 +16,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 -> not p.loc3 [forward reach with edge: (event: c) (guard: p.loc1) (assignments: p := p.loc2)] - Reachable states: not p.loc3 -> true [forward reach with edge: (event: u) (guard: p.loc2) (assignments: p := p.loc3)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.xxxN.run.out index 6635f07a7a29ca7b79f2aaf4c15a2e36bb28377e..4f2d1ea9e17d4cc7189aee7452ef8037c4172aa1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_false_to_true.xxxN.run.out @@ -19,15 +19,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: p.loc3 [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: p.loc3 -> not p.loc1 [backward reach with edge: (event: u) (guard: p.loc2) (assignments: p := p.loc3)] - - Backward reachability iteration 2: - Controllable-complete path states: not p.loc1 -> true [backward reach with edge: (event: c) (guard: p.loc1) (assignments: p := p.loc2)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -35,9 +26,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.BCFN.run.out index 626bce1d242b97222d07d47e82ddf62092c794bf..cbf5008dca5f3e7b451fc548e3fc58ea2f06938b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.BCFN.run.out @@ -115,13 +115,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 and not p.v [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 and not p.v -> not p.v [forward reach with edge: (event: a) (guard: p.loc1) (assignments: p.v := p.v, p := p.loc2)] - Reachable states: not p.v -> p.loc2 or not p.v [forward reach with edge: (event: b) (guard: p.loc1) (assignments: p.v := not p.v, p := p.loc2)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: p.loc2 or not p.v [fixed point]. Computing bound for uncontrollable events: @@ -144,17 +137,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.Bxxx.run.out index 75083554109134fd99f0463b53c7af4e835f2d5d..f672a57abb25bc023ef060f038464c1e975eb765 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.Bxxx.run.out @@ -104,13 +104,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 and not p.v [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 and not p.v -> not p.v [forward reach with edge: (event: a) (guard: p.loc1) (assignments: p.v := p.v, p := p.loc2)] - Reachable states: not p.v -> p.loc2 or not p.v [forward reach with edge: (event: b) (guard: p.loc1) (assignments: p.v := not p.v, p := p.loc2)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: p.loc2 or not p.v [fixed point]. Computing bound for uncontrollable events: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.xxxN.run.out index 12d41e40c9794067d3d999b4aa607e7624c119aa..04fdb69258a5233c7ce4337825d244dbe9e1c2be 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/anno_true_to_false.xxxN.run.out @@ -107,17 +107,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.BCFN.run.out index 4329c1efdbdd47719aa7dad75e12d14c3914faf9..b8c3e6cf1b0ccc326495406e3fd8bc4a2c45bbe1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.BCFN.run.out @@ -15,9 +15,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). @@ -37,17 +34,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.Bxxx.run.out index 931e6e81b1d09441e8f9eed4fd873c9f938e2cca..32cd79fbf5c430f892f045d5e453a609d8926ab8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.Bxxx.run.out @@ -9,9 +9,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.xxxN.run.out index 4189cca43e2c7a17ab3c24823d20f737d5470475..27cf56d427bbbf58c3a992bd0c1514c3b35f437b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/common/svg_input_decl_removed.xxxN.run.out @@ -12,17 +12,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/independence1.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/independence1.BCFN.run.out index 533799c0e7d97090af4c7a3a8d16dbabc16d30ec..348e1983bb8139fd9993da6afd534f38182422b5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/independence1.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/independence1.BCFN.run.out @@ -125,13 +125,6 @@ Checking for bounded response: Computing reachable states: Reachable states: not AutDifferenLocs.z and (AutDifferenLocs.p and AutDifferenLocs.v = 0) [initial states predicate] - Forward reachability iteration 1: - Reachable states: not AutDifferenLocs.z and (AutDifferenLocs.p and AutDifferenLocs.v = 0) -> not AutDifferenLocs.z and (AutDifferenLocs.p and AutDifferenLocs.v = 0) or AutDifferenLocs.z and (AutDifferenLocs.q and AutDifferenLocs.v = 0) [forward reach with edge: (event: AutDifferenLocs.a) (guard: AutDifferenLocs.p or AutDifferenLocs.r) (assignments: AutDifferenLocs.z := true, AutDifferenLocs := AutDifferenLocs.q / AutDifferenLocs.z := true, AutDifferenLocs := AutDifferenLocs.s)] - Reachable states: not AutDifferenLocs.z and (AutDifferenLocs.p and AutDifferenLocs.v = 0) or AutDifferenLocs.z and (AutDifferenLocs.q and AutDifferenLocs.v = 0) -> not AutDifferenLocs.z and (AutDifferenLocs.p and AutDifferenLocs.v = 0) or not AutDifferenLocs.z and (AutDifferenLocs.r and AutDifferenLocs.v = 2) or (AutDifferenLocs.z and (AutDifferenLocs.q and AutDifferenLocs.v = 0) or AutDifferenLocs.z and (AutDifferenLocs.s and AutDifferenLocs.v = 2)) [forward reach with edge: (event: AutDifferenLocs.b) (guard: AutDifferenLocs.p or AutDifferenLocs.q) (assignments: AutDifferenLocs.v := 2, AutDifferenLocs := AutDifferenLocs.r / AutDifferenLocs.v := 2, AutDifferenLocs := AutDifferenLocs.s)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: not AutDifferenLocs.z and (AutDifferenLocs.p and AutDifferenLocs.v = 0) or not AutDifferenLocs.z and (AutDifferenLocs.r and AutDifferenLocs.v = 2) or (AutDifferenLocs.z and (AutDifferenLocs.q and AutDifferenLocs.v = 0) or AutDifferenLocs.z and (AutDifferenLocs.s and AutDifferenLocs.v = 2)) [fixed point]. Computing bound for uncontrollable events: @@ -155,13 +148,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: AutDifferenLocs.s [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: AutDifferenLocs.s -> AutDifferenLocs.r or AutDifferenLocs.s [backward reach with edge: (event: AutDifferenLocs.a) (guard: AutDifferenLocs.p or AutDifferenLocs.r) (assignments: AutDifferenLocs.z := true, AutDifferenLocs := AutDifferenLocs.q / AutDifferenLocs.z := true, AutDifferenLocs := AutDifferenLocs.s)] - Controllable-complete path states: AutDifferenLocs.r or AutDifferenLocs.s -> true [backward reach with edge: (event: AutDifferenLocs.b) (guard: AutDifferenLocs.p or AutDifferenLocs.q) (assignments: AutDifferenLocs.v := 2, AutDifferenLocs := AutDifferenLocs.r / AutDifferenLocs.v := 2, AutDifferenLocs := AutDifferenLocs.s)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -169,9 +155,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive1.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive1.BCFN.run.out index 0b93432e6e619c2bcd1740aa2f2dd17a33238cea..09bf85df8768dd03447c45fbb74247c81c098074 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive1.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive1.BCFN.run.out @@ -26,13 +26,6 @@ Checking for bounded response: Computing reachable states: Reachable states: DifferentLocs.p [initial states predicate] - Forward reachability iteration 1: - Reachable states: DifferentLocs.p -> not DifferentLocs.q [forward reach with edge: (event: DifferentLocs.a) (guard: DifferentLocs.p) (assignments: DifferentLocs := DifferentLocs.r)] - Reachable states: not DifferentLocs.q -> true [forward reach with edge: (event: DifferentLocs.u) (guard: DifferentLocs.p) (assignments: DifferentLocs := DifferentLocs.q)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -56,13 +49,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: DifferentLocs.r [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: DifferentLocs.r -> not DifferentLocs.q [backward reach with edge: (event: DifferentLocs.a) (guard: DifferentLocs.p) (assignments: DifferentLocs := DifferentLocs.r)] - Controllable-complete path states: not DifferentLocs.q -> true [backward reach with edge: (event: DifferentLocs.b) (guard: DifferentLocs.q) (assignments: DifferentLocs := DifferentLocs.r)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -70,9 +56,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive2.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive2.BCFN.run.out index 594132242c59d7172b9615b971d2af2a1a7a9459..5c30fc73bd6f7d777907b96033d96d1d4eb163b0 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive2.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/mutual_exclusive2.BCFN.run.out @@ -113,12 +113,6 @@ Checking for bounded response: Computing reachable states: Reachable states: DifferentConditions.p and not DifferentConditions.z [initial states predicate] - Forward reachability iteration 1: - Reachable states: DifferentConditions.p and not DifferentConditions.z -> not DifferentConditions.z [forward reach with edge: (event: DifferentConditions.b) (guard: DifferentConditions.p and not DifferentConditions.z) (assignments: DifferentConditions := DifferentConditions.q)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: not DifferentConditions.z [fixed point]. Computing bound for uncontrollable events: @@ -141,13 +135,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: DifferentConditions.q [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: DifferentConditions.q -> DifferentConditions.q or DifferentConditions.z [backward reach with edge: (event: DifferentConditions.a) (guard: DifferentConditions.p and DifferentConditions.z) (assignments: DifferentConditions := DifferentConditions.q)] - Controllable-complete path states: DifferentConditions.q or DifferentConditions.z -> true [backward reach with edge: (event: DifferentConditions.b) (guard: DifferentConditions.p and not DifferentConditions.z) (assignments: DifferentConditions := DifferentConditions.q)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -155,9 +142,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/not_confluent.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/not_confluent.BCFN.run.out index b1c17877ed99e0daba3700e5bc39c83a4949db3e..f34aec252719079762a78e286a8ed681366fddbf 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/not_confluent.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/not_confluent.BCFN.run.out @@ -123,13 +123,6 @@ Checking for bounded response: Computing reachable states: Reachable states: not SingleAut.z and SingleAut.p [initial states predicate] - Forward reachability iteration 1: - Reachable states: not SingleAut.z and SingleAut.p -> not SingleAut.z [forward reach with edge: (event: SingleAut.a) (guard: SingleAut.p) (assignments: SingleAut.z := SingleAut.z, SingleAut := SingleAut.q)] - Reachable states: not SingleAut.z -> not SingleAut.z or SingleAut.q [forward reach with edge: (event: SingleAut.b) (guard: SingleAut.p) (assignments: SingleAut.z := not SingleAut.z, SingleAut := SingleAut.q)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: not SingleAut.z or SingleAut.q [fixed point]. Computing bound for uncontrollable events: @@ -152,12 +145,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: SingleAut.q [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: SingleAut.q -> true [backward reach with edge: (event: SingleAut.a) (guard: SingleAut.p) (assignments: SingleAut.z := SingleAut.z, SingleAut := SingleAut.q)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -165,9 +152,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/partial_independence.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/partial_independence.BCFN.run.out index da4db342e70931e5577753c7180384178c8d8689..eb8c608dc70ebea9cc55243953ce446d7e85a1fa 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/partial_independence.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/partial_independence.BCFN.run.out @@ -124,17 +124,6 @@ Checking for bounded response: Computing reachable states: Reachable states: not A.z and (A.p and A.v = 0) [initial states predicate] - Forward reachability iteration 1: - Reachable states: not A.z and (A.p and A.v = 0) -> not A.z and (A.p and A.v = 0) or A.z and (A.q and A.v = 0) [forward reach with edge: (event: A.a) (guard: not A.s) (assignments: A.z := true, A := A.q / A.z := true, A := A.s)] - Reachable states: not A.z and (A.p and A.v = 0) or A.z and (A.q and A.v = 0) -> not A.z and (A.p and A.v = 0) or not A.z and (A.q and A.v = 2) or (A.z and (A.s and A.v = 2) or A.z and (A.q and A.v = 0)) [forward reach with edge: (event: A.b) (guard: not A.s) (assignments: A.v := 2, A := A.q / A.v := 2, A := A.s)] - - Forward reachability iteration 2: - Reachable states: not A.z and (A.p and A.v = 0) or not A.z and (A.q and A.v = 2) or (A.z and (A.s and A.v = 2) or A.z and (A.q and A.v = 0)) -> <bdd 11n 4p> [forward reach with edge: (event: A.a) (guard: not A.s) (assignments: A.z := true, A := A.q / A.z := true, A := A.s)] - Reachable states: <bdd 11n 4p> -> <bdd 12n 5p> [forward reach with edge: (event: A.b) (guard: not A.s) (assignments: A.v := 2, A := A.q / A.v := 2, A := A.s)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: <bdd 12n 5p> [fixed point]. Computing bound for uncontrollable events: @@ -158,13 +147,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: A.s [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: A.s -> not A.p [backward reach with edge: (event: A.a) (guard: not A.s) (assignments: A.z := true, A := A.q / A.z := true, A := A.s)] - Controllable-complete path states: not A.p -> true [backward reach with edge: (event: A.b) (guard: not A.s) (assignments: A.v := 2, A := A.q / A.v := 2, A := A.s)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -172,9 +154,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/reversible1.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/reversible1.BCFN.run.out index f5bc3ce8973a234b79c8aa8cb42fda9098bc4907..00a92e87677888bf15240e89416253df2a7bc615 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/reversible1.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/reversible1.BCFN.run.out @@ -133,16 +133,6 @@ Checking for bounded response: Computing reachable states: Reachable states: B.v = 0 and (B.p and A.p) [initial states predicate] - Forward reachability iteration 1: - Reachable states: B.v = 0 and (B.p and A.p) -> B.v = 0 and B.p [forward reach with edge: (event: a) (guard: A.p) (assignments: A := A.q)] - Reachable states: B.v = 0 and B.p -> B.v = 0 and B.p or B.v = 2 and (B.q and A.p) [forward reach with edge: (event: b) (guard: B.v = 0 and (B.p and A.p)) (assignments: B.v := B.v + 2, B := B.q)] - - Forward reachability iteration 2: - Reachable states: B.v = 0 and B.p or B.v = 2 and (B.q and A.p) -> B.v = 0 and B.p or B.v = 2 and B.q [forward reach with edge: (event: a) (guard: A.p) (assignments: A := A.q)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: B.v = 0 and B.p or B.v = 2 and B.q [fixed point]. Computing bound for uncontrollable events: @@ -167,16 +157,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: B.p and A.q [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: B.p and A.q -> B.p [backward reach with edge: (event: a) (guard: A.p) (assignments: A := A.q)] - Controllable-complete path states: B.p -> (B.v = 2 or B.p) and (B.v != 2 or (B.p or A.q)) [backward reach with edge: (event: c) (guard: B.q and A.q -> B.v = 2 and (B.q and A.q)) (assignments: B.v := B.v - 2, B := B.p)] - - Backward reachability iteration 2: - Controllable-complete path states: (B.v = 2 or B.p) and (B.v != 2 or (B.p or A.q)) -> B.v = 2 or B.p [backward reach with edge: (event: a) (guard: A.p) (assignments: A := A.q)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: B.v = 2 or B.p [fixed point]. Controllable-complete path states: B.v = 2 or B.p @@ -184,9 +164,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: B.v != 2 and B.q [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: B.v != 2 and B.q Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/skippable1.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/skippable1.BCFN.run.out index 1571f7f4828370dc1266a9211a34999e48dcef7f..f7cd47732efa41891e75ee8c6cc0b1414624e356 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/skippable1.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/skippable1.BCFN.run.out @@ -124,13 +124,6 @@ Checking for bounded response: Computing reachable states: Reachable states: OptionalChangeBool.v = 0 and OptionalChangeBool.p [initial states predicate] - Forward reachability iteration 1: - Reachable states: OptionalChangeBool.v = 0 and OptionalChangeBool.p -> OptionalChangeBool.v = 0 and OptionalChangeBool.p or OptionalChangeBool.v = 1 and OptionalChangeBool.q [forward reach with edge: (event: OptionalChangeBool.a) (guard: OptionalChangeBool.p) (assignments: OptionalChangeBool.v := 1, OptionalChangeBool := OptionalChangeBool.q)] - Reachable states: OptionalChangeBool.v = 0 and OptionalChangeBool.p or OptionalChangeBool.v = 1 and OptionalChangeBool.q -> OptionalChangeBool.v = 0 and OptionalChangeBool.p or (OptionalChangeBool.v = 2 and OptionalChangeBool.r or OptionalChangeBool.v = 1 and OptionalChangeBool.q) [forward reach with edge: (event: OptionalChangeBool.b) (guard: not OptionalChangeBool.r) (assignments: OptionalChangeBool.v := 2, OptionalChangeBool := OptionalChangeBool.r / OptionalChangeBool.v := 2, OptionalChangeBool := OptionalChangeBool.r)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: OptionalChangeBool.v = 0 and OptionalChangeBool.p or (OptionalChangeBool.v = 2 and OptionalChangeBool.r or OptionalChangeBool.v = 1 and OptionalChangeBool.q) [fixed point]. Computing bound for uncontrollable events: @@ -154,12 +147,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: OptionalChangeBool.r [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: OptionalChangeBool.r -> true [backward reach with edge: (event: OptionalChangeBool.b) (guard: not OptionalChangeBool.r) (assignments: OptionalChangeBool.v := 2, OptionalChangeBool := OptionalChangeBool.r / OptionalChangeBool.v := 2, OptionalChangeBool := OptionalChangeBool.r)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -167,9 +154,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/update_equivalent1.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/update_equivalent1.BCFN.run.out index 1695d7a1b5f9dff25471639679e81c623ebfb91a..9e96b10b62ffa559711279c4bf7bb5c7d15c1873 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/update_equivalent1.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/confluence/update_equivalent1.BCFN.run.out @@ -123,12 +123,6 @@ Checking for bounded response: Computing reachable states: Reachable states: not SingleAut.z and SingleAut.p [initial states predicate] - Forward reachability iteration 1: - Reachable states: not SingleAut.z and SingleAut.p -> (SingleAut.z or SingleAut.p) and (not SingleAut.z or SingleAut.q) [forward reach with edge: (event: SingleAut.a) (guard: SingleAut.p) (assignments: SingleAut.z := true, SingleAut := SingleAut.q)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: (SingleAut.z or SingleAut.p) and (not SingleAut.z or SingleAut.q) [fixed point]. Computing bound for uncontrollable events: @@ -151,12 +145,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: SingleAut.q [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: SingleAut.q -> true [backward reach with edge: (event: SingleAut.a) (guard: SingleAut.p) (assignments: SingleAut.z := true, SingleAut := SingleAut.q)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -164,9 +152,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_auts.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_auts.BCFN.run.out index deec5d97949f2ddf3d02f5e7aa70a87065c16d69..d338c2d30beb7cb3f9846c5a4f47e2d2bb5863ad 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_auts.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_auts.BCFN.run.out @@ -134,16 +134,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Actuator.Off and (sup.Off and Sensor.Off) [initial states predicate] - Forward reachability iteration 1: - Reachable states: Actuator.Off and (sup.Off and Sensor.Off) -> Actuator.Off and (sup.Off and Sensor.Off) or Actuator.Off and (sup.On and Sensor.On) [forward reach with edge: (event: Sensor.u_on) (guard: sup.Off and Sensor.Off) (assignments: Sensor := Sensor.On, sup := sup.On)] - - Forward reachability iteration 2: - Reachable states: Actuator.Off and (sup.Off and Sensor.Off) or Actuator.Off and (sup.On and Sensor.On) -> Actuator.Off and (sup.Off and Sensor.Off) or (Actuator.Off and (sup.On and Sensor.On) or Actuator.On and (sup.On and Sensor.On)) [forward reach with edge: (event: Actuator.c_on) (guard: Actuator.Off and sup.On) (assignments: Actuator := Actuator.On)] - Reachable states: Actuator.Off and (sup.Off and Sensor.Off) or (Actuator.Off and (sup.On and Sensor.On) or Actuator.On and (sup.On and Sensor.On)) -> (sup.On or Sensor.Off) and (sup.Off or Sensor.On) [forward reach with edge: (event: Sensor.u_off) (guard: sup.On and Sensor.On) (assignments: Sensor := Sensor.Off, sup := sup.Off)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: (sup.On or Sensor.Off) and (sup.Off or Sensor.On) [fixed point]. Computing bound for uncontrollable events: @@ -166,17 +156,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_invs.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_invs.BCFN.run.out index a03264fa21ee497b37a31eb3b64856b036472927..df3cbd70a59e303933ccc0a12287d67a483df482 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_invs.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/has_finite_response_invs.BCFN.run.out @@ -136,16 +136,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Sensor.Off and Actuator.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: Sensor.Off and Actuator.Off -> Actuator.Off [forward reach with edge: (event: Sensor.u_on) (guard: Sensor.Off) (assignments: Sensor := Sensor.On)] - - Forward reachability iteration 2: - Reachable states: Actuator.Off -> Sensor.On or Actuator.Off [forward reach with edge: (event: Actuator.c_on) (guard: Actuator.Off -> Sensor.On and Actuator.Off) (assignments: Actuator := Actuator.On)] - Reachable states: Sensor.On or Actuator.Off -> true [forward reach with edge: (event: Sensor.u_off) (guard: Sensor.On) (assignments: Sensor := Sensor.Off)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -168,17 +158,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/if_switch_expressions.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/if_switch_expressions.BCFN.run.out index e861f6abd46e1486615c3d4f18898b1e0beb8f9d..b3badf65f3c509641da4546d5fb818b929e9af5b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/if_switch_expressions.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/if_switch_expressions.BCFN.run.out @@ -215,16 +215,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Aut1.l1 and (Aut2.l1 and Aut3.l1) and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) [initial states predicate] - Forward reachability iteration 1: - Reachable states: Aut1.l1 and (Aut2.l1 and Aut3.l1) and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) -> Aut2.l1 and Aut3.l1 and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) [forward reach with edge: (event: Aut1.c_a) (guard: Aut1.l1) (assignments: Aut1 := Aut1.l2)] - Reachable states: Aut2.l1 and Aut3.l1 and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) -> Aut2.l1 and Aut3.l1 and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) or Aut2.l1 and (Aut3.l2 and A) and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) [forward reach with edge: (event: Aut3.c_a) (guard: Aut3.l1 -> Aut3.l1 and A) (assignments: Aut3 := Aut3.l2)] - Reachable states: Aut2.l1 and Aut3.l1 and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) or Aut2.l1 and (Aut3.l2 and A) and (Aut6.l1 and (Aut4.l1 and Aut5.l1)) -> Aut2.l1 and Aut3.l1 and (Aut6.l1 and Aut5.l1) or Aut2.l1 and Aut3.l2 and (A and (Aut6.l1 and Aut5.l1)) [forward reach with edge: (event: Aut4.c_a) (guard: Aut4.l1) (assignments: Aut4 := Aut4.l2)] - Reachable states: Aut2.l1 and Aut3.l1 and (Aut6.l1 and Aut5.l1) or Aut2.l1 and Aut3.l2 and (A and (Aut6.l1 and Aut5.l1)) -> Aut2.l1 and Aut3.l1 and (not A and (Aut6.l1 and Aut5.l1)) or (Aut2.l1 and Aut3.l1 and (A and Aut5.l1) or Aut2.l1 and Aut3.l2 and (A and Aut5.l1)) [forward reach with edge: (event: Aut6.c_a) (guard: Aut6.l1 -> A and Aut6.l1) (assignments: Aut6 := Aut6.l2)] - Reachable states: Aut2.l1 and Aut3.l1 and (not A and (Aut6.l1 and Aut5.l1)) or (Aut2.l1 and Aut3.l1 and (A and Aut5.l1) or Aut2.l1 and Aut3.l2 and (A and Aut5.l1)) -> Aut2.l1 and Aut5.l1 [forward reach with edge: (event: A) (guard: true) (assignments: A+ != A)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: Aut2.l1 and Aut5.l1 [fixed point]. Computing bound for uncontrollable events: @@ -246,17 +236,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/input_variable.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/input_variable.BCFN.run.out index bd15d8c155decdcf89b0aba82c0832d7fa99ee07..0d184c7a9f07f7d2ba1accfdcf20adff15b32371 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/input_variable.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/input_variable.BCFN.run.out @@ -130,13 +130,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Actuator.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: Actuator.Off -> Actuator.Off or Sensor [forward reach with edge: (event: Actuator.c_on) (guard: Actuator.Off -> Actuator.Off and Sensor) (assignments: Actuator := Actuator.On)] - Reachable states: Actuator.Off or Sensor -> true [forward reach with edge: (event: Sensor) (guard: true) (assignments: Sensor+ != Sensor)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -159,17 +152,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_events_edge.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_events_edge.BCFN.run.out index f10e42a8de85901ea14d55c472f880cccf26edd8..05ed79b2ff1b71bf8157719e08c4b9948279a6f1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_events_edge.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_events_edge.BCFN.run.out @@ -32,13 +32,6 @@ Checking for bounded response: Computing reachable states: Reachable states: A.l0 [initial states predicate] - Forward reachability iteration 1: - Reachable states: A.l0 -> not A.l2 [forward reach with edge: (event: A.a) (guard: A.l0) (assignments: A := A.l1)] - Reachable states: not A.l2 -> true [forward reach with edge: (event: A.c) (guard: A.l1) (assignments: A := A.l2)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -61,17 +54,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_iterations.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_iterations.BCFN.run.out index 57c7669b0156fa1f9a96b41a88efdfd23402f2a5..81d5d0cfa48018042832bfbb99cfbe21ac44ced6 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_iterations.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/mult_iterations.BCFN.run.out @@ -149,18 +149,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Actuator2.Off and Actuator1.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: Actuator2.Off and Actuator1.Off -> (Actuator2.On or (Actuator1.Off or Sensor)) and Actuator2.Off [forward reach with edge: (event: Actuator1.c_on) (guard: Actuator1.Off -> Actuator1.Off and Sensor) (assignments: Actuator1 := Actuator1.On)] - Reachable states: (Actuator2.On or (Actuator1.Off or Sensor)) and Actuator2.Off -> Actuator2.Off [forward reach with edge: (event: Sensor) (guard: true) (assignments: Sensor+ != Sensor)] - - Forward reachability iteration 2: - Reachable states: Actuator2.Off -> Actuator2.Off or Actuator1.On [forward reach with edge: (event: Actuator2.c_on) (guard: Actuator2.Off -> Actuator2.Off and Actuator1.On) (assignments: Actuator2 := Actuator2.On)] - Reachable states: Actuator2.Off or Actuator1.On -> Actuator2.Off or (Actuator1.On or not Sensor) [forward reach with edge: (event: Actuator1.c_off) (guard: Actuator1.On -> Actuator1.On and not Sensor) (assignments: Actuator1 := Actuator1.Off)] - Reachable states: Actuator2.Off or (Actuator1.On or not Sensor) -> true [forward reach with edge: (event: Sensor) (guard: true) (assignments: Sensor+ != Sensor)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -185,17 +173,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/no_finite_response.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/no_finite_response.BCFN.run.out index 11b1d18536c367f1115eaa2c5453e94141653b4a..b0868174727287c14f49b1269ed6d0db1db06e46 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/no_finite_response.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/no_finite_response.BCFN.run.out @@ -144,17 +144,6 @@ Checking for bounded response: Computing reachable states: Reachable states: StopButton.Released and (Actuator.Off and StartButton.Released) [initial states predicate] - Forward reachability iteration 1: - Reachable states: StopButton.Released and (Actuator.Off and StartButton.Released) -> StopButton.Released and Actuator.Off [forward reach with edge: (event: StartButton.u_pushed) (guard: StartButton.Released) (assignments: StartButton := StartButton.Pushed)] - Reachable states: StopButton.Released and Actuator.Off -> Actuator.Off [forward reach with edge: (event: StopButton.u_pushed) (guard: StopButton.Released) (assignments: StopButton := StopButton.Pushed)] - - Forward reachability iteration 2: - Reachable states: Actuator.Off -> Actuator.Off or StartButton.Pushed [forward reach with edge: (event: Actuator.c_on) (guard: Actuator.Off -> Actuator.Off and StartButton.Pushed) (assignments: Actuator := Actuator.On)] - Reachable states: Actuator.Off or StartButton.Pushed -> true [forward reach with edge: (event: StartButton.u_released) (guard: StartButton.Pushed) (assignments: StartButton := StartButton.Released)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -178,17 +167,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_off.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_off.BCFN.run.out index df84fe519ed720fe4a02d362ab09a98a07606a13..feb8f1dffcb6324c9ac052ca9c3b4a5344a09a7f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_off.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_off.BCFN.run.out @@ -25,12 +25,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 -> true [forward reach with edge: (event: p.c1) (guard: p.loc1) (assignments: p := p.loc2)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -52,17 +46,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_on.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_on.BCFN.run.out index 460440cac02b1be0349129b2cafafc1aa21e6432..d66b2f066a850fe5f8a05a866e7002a2695d23fe 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_on.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/print_control_loops_on.BCFN.run.out @@ -25,12 +25,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.loc1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: p.loc1 -> true [forward reach with edge: (event: p.c1) (guard: p.loc1) (assignments: p := p.loc2)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -52,17 +46,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/self_loop.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/self_loop.BCFN.run.out index 3bf6e31f9587a0f890fdb937db86e48fb75d823e..a7bce8f55c126dcea03d56cfb398bda76662e1b3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/self_loop.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/self_loop.BCFN.run.out @@ -15,9 +15,6 @@ Checking for bounded response: Computing reachable states: Reachable states: true [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: true). @@ -37,17 +34,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/special_loops.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/special_loops.BCFN.run.out index f0c97afecf0fea179e6c78b054a72322994337ba..e4f47af643a96c86b2a54dee175dbc9bd1737e38 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/special_loops.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/special_loops.BCFN.run.out @@ -118,18 +118,6 @@ Checking for bounded response: Computing reachable states: Reachable states: A.l0 and B.l0 [initial states predicate] - Forward reachability iteration 1: - Reachable states: A.l0 and B.l0 -> (A.l0 or A.l1) and B.l0 [forward reach with edge: (event: A.a) (guard: not A.l2 and not A.l3) (assignments: A := A.l1 / A := A.l2 / A := A.l3)] - Reachable states: (A.l0 or A.l1) and B.l0 -> A.l0 and B.l0 or (A.l1 or A.l3) and B.l0 [forward reach with edge: (event: A.b) (guard: not A.l4 and not A.l1) (assignments: A := A.l3 / A := A.l1 / A := A.l4)] - Reachable states: A.l0 and B.l0 or (A.l1 or A.l3) and B.l0 -> not A.l4 and not A.l2 [forward reach with edge: (event: B.a) (guard: true) (assignments: B := B.l1 / B := B.l0)] - - Forward reachability iteration 2: - Reachable states: not A.l4 and not A.l2 -> not A.l4 [forward reach with edge: (event: A.a) (guard: not A.l2 and not A.l3) (assignments: A := A.l1 / A := A.l2 / A := A.l3)] - Reachable states: not A.l4 -> true [forward reach with edge: (event: A.b) (guard: not A.l4 and not A.l1) (assignments: A := A.l3 / A := A.l1 / A := A.l4)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -151,17 +139,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component1.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component1.BCFN.run.out index d82077d89253f883a10c5bb651c47937ddad623e..a9b4fdf8c29bb3198d4cb565dfa0fe8554594f47 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component1.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component1.BCFN.run.out @@ -57,18 +57,6 @@ Checking for bounded response: Computing reachable states: Reachable states: A.l0 [initial states predicate] - Forward reachability iteration 1: - Reachable states: A.l0 -> A.l0 or A.l1 [forward reach with edge: (event: A.a) (guard: A.l0) (assignments: A := A.l1)] - Reachable states: A.l0 or A.l1 -> A.l0 or (A.l2 or A.l1) [forward reach with edge: (event: A.b) (guard: A.l1) (assignments: A := A.l2)] - Reachable states: A.l0 or (A.l2 or A.l1) -> A.l0 or A.l4 or (A.l2 or A.l1) [forward reach with edge: (event: A.c) (guard: A.l1) (assignments: A := A.l4)] - Reachable states: A.l0 or A.l4 or (A.l2 or A.l1) -> not A.l6 and (not A.l3 and not A.l7) [forward reach with edge: (event: A.d) (guard: A.l1) (assignments: A := A.l5)] - Reachable states: not A.l6 and (not A.l3 and not A.l7) -> not A.l6 and not A.l7 [forward reach with edge: (event: A.e) (guard: A.l2) (assignments: A := A.l3)] - Reachable states: not A.l6 and not A.l7 -> not A.l7 [forward reach with edge: (event: A.f) (guard: A.l2) (assignments: A := A.l6)] - Reachable states: not A.l7 -> true [forward reach with edge: (event: A.h) (guard: A.l3) (assignments: A := A.l7)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -90,17 +78,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component2.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component2.BCFN.run.out index 288edd522badb756dcf3e6f8d82c956b89679823..05d61011f577eb509f1b7e77099bb2ab3c53a71d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component2.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component2.BCFN.run.out @@ -71,22 +71,6 @@ Checking for bounded response: Computing reachable states: Reachable states: A.l1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: A.l1 -> A.l1 or A.l2 [forward reach with edge: (event: A.a) (guard: A.l1) (assignments: A := A.l2)] - Reachable states: A.l1 or A.l2 -> A.l1 or (A.l3 or A.l2) [forward reach with edge: (event: A.b) (guard: A.l2) (assignments: A := A.l3)] - Reachable states: A.l1 or (A.l3 or A.l2) -> A.l1 or A.l2 or (A.l3 or A.l4) [forward reach with edge: (event: A.c) (guard: A.l2) (assignments: A := A.l4)] - Reachable states: A.l1 or A.l2 or (A.l3 or A.l4) -> A.l1 or A.l5 or (A.l3 or (A.l2 or A.l4)) [forward reach with edge: (event: A.d) (guard: A.l2) (assignments: A := A.l5)] - Reachable states: A.l1 or A.l5 or (A.l3 or (A.l2 or A.l4)) -> A.l1 or (A.l2 or A.l5) or (A.l6 or (A.l3 or A.l4)) [forward reach with edge: (event: A.e) (guard: A.l3) (assignments: A := A.l6)] - Reachable states: A.l1 or (A.l2 or A.l5) or (A.l6 or (A.l3 or A.l4)) -> A.l1 or (A.l3 or A.l5) or (A.l7 or A.l2 or (A.l6 or A.l4)) [forward reach with edge: (event: A.g) (guard: A.l4) (assignments: A := A.l7)] - Reachable states: A.l1 or (A.l3 or A.l5) or (A.l7 or A.l2 or (A.l6 or A.l4)) -> not A.l9 and not A.l10 and (not A.l11 and not A.l12) [forward reach with edge: (event: A.l) (guard: A.l6) (assignments: A := A.l8)] - Reachable states: not A.l9 and not A.l10 and (not A.l11 and not A.l12) -> not A.l9 and (not A.l11 and not A.l12) [forward reach with edge: (event: A.n) (guard: A.l7) (assignments: A := A.l10)] - Reachable states: not A.l9 and (not A.l11 and not A.l12) -> not A.l11 and not A.l12 [forward reach with edge: (event: A.q) (guard: A.l10) (assignments: A := A.l9)] - Reachable states: not A.l11 and not A.l12 -> not A.l12 [forward reach with edge: (event: A.r) (guard: A.l10) (assignments: A := A.l11)] - Reachable states: not A.l12 -> true [forward reach with edge: (event: A.s) (guard: A.l11) (assignments: A := A.l12)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -109,17 +93,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component3.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component3.BCFN.run.out index 4fcc4af2cea28be5ea9a9a770812ba6074a8ab59..72809f50e9f1865cc8f191cb4bd1e365066094e6 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component3.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/strongly_connected_component3.BCFN.run.out @@ -69,22 +69,6 @@ Checking for bounded response: Computing reachable states: Reachable states: A.l1 [initial states predicate] - Forward reachability iteration 1: - Reachable states: A.l1 -> A.l1 or A.l2 [forward reach with edge: (event: A.a) (guard: A.l1) (assignments: A := A.l2)] - Reachable states: A.l1 or A.l2 -> A.l1 or (A.l3 or A.l2) [forward reach with edge: (event: A.b) (guard: A.l2) (assignments: A := A.l3)] - Reachable states: A.l1 or (A.l3 or A.l2) -> A.l1 or A.l2 or (A.l3 or A.l4) [forward reach with edge: (event: A.c) (guard: A.l2) (assignments: A := A.l4)] - Reachable states: A.l1 or A.l2 or (A.l3 or A.l4) -> A.l1 or A.l5 or (A.l3 or (A.l2 or A.l4)) [forward reach with edge: (event: A.d) (guard: A.l2) (assignments: A := A.l5)] - Reachable states: A.l1 or A.l5 or (A.l3 or (A.l2 or A.l4)) -> A.l1 or (A.l2 or A.l5) or (A.l6 or (A.l3 or A.l4)) [forward reach with edge: (event: A.e) (guard: A.l3) (assignments: A := A.l6)] - Reachable states: A.l1 or (A.l2 or A.l5) or (A.l6 or (A.l3 or A.l4)) -> A.l1 or (A.l3 or A.l5) or (A.l7 or A.l2 or (A.l6 or A.l4)) [forward reach with edge: (event: A.g) (guard: A.l4) (assignments: A := A.l7)] - Reachable states: A.l1 or (A.l3 or A.l5) or (A.l7 or A.l2 or (A.l6 or A.l4)) -> not A.l9 and not A.l10 and (not A.l11 and not A.l12) [forward reach with edge: (event: A.l) (guard: A.l6) (assignments: A := A.l8)] - Reachable states: not A.l9 and not A.l10 and (not A.l11 and not A.l12) -> not A.l9 and (not A.l11 and not A.l12) [forward reach with edge: (event: A.n) (guard: A.l7) (assignments: A := A.l10)] - Reachable states: not A.l9 and (not A.l11 and not A.l12) -> not A.l11 and not A.l12 [forward reach with edge: (event: A.q) (guard: A.l10) (assignments: A := A.l9)] - Reachable states: not A.l11 and not A.l12 -> not A.l12 [forward reach with edge: (event: A.r) (guard: A.l10) (assignments: A := A.l11)] - Reachable states: not A.l12 -> true [forward reach with edge: (event: A.s) (guard: A.l11) (assignments: A := A.l12)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -108,17 +92,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/three_part_loop.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/three_part_loop.BCFN.run.out index 7e5d06f6a8687bb497ec2c44e046785746bb34fb..23adff9a5b83bf2f75b2db5328ea9ca5ea7f322b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/three_part_loop.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/finite_response/three_part_loop.BCFN.run.out @@ -137,14 +137,6 @@ Checking for bounded response: Computing reachable states: Reachable states: X.A [initial states predicate] - Forward reachability iteration 1: - Reachable states: X.A -> X.A or X.B and Y != 1 [forward reach with edge: (event: X.a) (guard: X.A -> X.A and Y != 1) (assignments: X := X.B)] - Reachable states: X.A or X.B and Y != 1 -> X.A or (X.C and Y = 0 or X.B and Y != 1) [forward reach with edge: (event: X.b) (guard: X.B -> X.B and Y != 2) (assignments: X := X.C)] - Reachable states: X.A or (X.C and Y = 0 or X.B and Y != 1) -> true [forward reach with edge: (event: Y) (guard: true) (assignments: Y+ != Y)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -168,17 +160,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.Bxxx.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.Bxxx.run.out index cdb3748f8ee8109112dffa94c2b24b7c8d8f8afd..8925ab27049a5da7a83138b2747309afa078b9ca 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.Bxxx.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.Bxxx.run.out @@ -116,9 +116,6 @@ Checking for bounded response: Computing reachable states: Reachable states: p.v = 0 [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bounded response check round 1 (states before round: p.v = 0). diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.xxxN.run.out index 2d1ae28eeef23d90db0ff50662430a75262bf138..171abcce955aea63c900409c12a3884fd981e7ad 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/mdd/non_determinism.xxxN.run.out @@ -119,17 +119,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.BCFN.run.out index 8477f2a775ab2249ece53654d0faeef28b62cdd4..ef0d64662bd0437e4b1c7ba6dd08025cc4715115 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.BCFN.run.out @@ -28,13 +28,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor.Start -> not Supervisor.BothDone [forward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.Done1)] - Reachable states: not Supervisor.BothDone -> true [forward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Done1) (assignments: Supervisor := Supervisor.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -56,17 +49,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.xxxN.run.out index e13e612f65c52ea751864c358a695dfdeb7da3bd..438c562135fc9473f85fa928381556a1420b7a81 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_ctrl_cycle.xxxN.run.out @@ -19,17 +19,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.BCFN.run.out index a3c78b08b9dd0fedc9289acd9ee8bf88f272d980..4430f22365b53a98413e85527f12243212bf7df7 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.BCFN.run.out @@ -26,13 +26,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor.Start -> not Supervisor.BothDone [forward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.Done1)] - Reachable states: not Supervisor.BothDone -> true [forward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Done1) (assignments: Supervisor := Supervisor.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -57,17 +50,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.xxxN.run.out index 6a1af5917a62e0592fbfcd0ade735b5621ebd92f..2c344667b02ffe851c5de58a434c4845f2033276 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_marked.xxxN.run.out @@ -19,17 +19,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.BCFN.run.out index 076b496c52f6c53725b255b68b326d073ead4b03..97dff60290ad773109f54598c9972bc89049715b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.BCFN.run.out @@ -27,14 +27,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor.Start -> Supervisor.Start or Supervisor.Done1 [forward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.Done1)] - Reachable states: Supervisor.Start or Supervisor.Done1 -> not Supervisor.Halt [forward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Done1) (assignments: Supervisor := Supervisor.BothDone)] - Reachable states: not Supervisor.Halt -> true [forward reach with edge: (event: Supervisor.u_button_pushed) (guard: Supervisor.BothDone or Supervisor.Done1) (assignments: Supervisor := Supervisor.Halt / Supervisor := Supervisor.Start)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -59,17 +51,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor.Halt [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: Supervisor.Halt Computing the bad states: Bad states: not Supervisor.Halt [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: not Supervisor.Halt Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.xxxN.run.out index f906203bd0cc70e993522b8be33c844e44f62a6d..a1e1d3612a0bd16625eb42c7b24898fee058361f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_intermediate_unctrl.xxxN.run.out @@ -19,17 +19,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor.Halt [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: Supervisor.Halt Computing the bad states: Bad states: not Supervisor.Halt [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: not Supervisor.Halt Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.BCFN.run.out index e2e2c163b44fd5403f96164c4c23c7f1b538541b..add0d063cfda6a43bb9a50d15d727646a14ed726 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.BCFN.run.out @@ -26,13 +26,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor.Start -> not Supervisor.BothDone [forward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.Done1)] - Reachable states: not Supervisor.BothDone -> true [forward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Done1) (assignments: Supervisor := Supervisor.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -57,17 +50,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.xxxN.run.out index e148f4a8c964755f64dcca727f04052d3b062c25..3fc83426fa257d2c697003167f7821d352084e36 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_no_marked.xxxN.run.out @@ -19,17 +19,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.BCFN.run.out index 2a53ab3b7bfa1c1e44816e26671786372237fb81..dc1afed821bdff700fabfe3c72f479e842ffbbc5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.BCFN.run.out @@ -27,13 +27,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor.Start -> Supervisor.Start or Supervisor.Done1 [forward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start or Supervisor.Done2) (assignments: Supervisor := Supervisor.Done1 / Supervisor := Supervisor.BothDone)] - Reachable states: Supervisor.Start or Supervisor.Done1 -> true [forward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Start or Supervisor.Done1) (assignments: Supervisor := Supervisor.Done2 / Supervisor := Supervisor.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -58,17 +51,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.xxxN.run.out index 4093f7908ecc7f4cdf79d9275c5260cfe14271ff..88811dbef223acc2b17e0a6ded380575c91f17e9 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/buc_not_chosen_path.xxxN.run.out @@ -19,17 +19,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.BCFN.run.out index f96910e3489b673255b2529c7ab731ab5f8203df..ff65143698aada69884a01be83a6a432c438e75f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.BCFN.run.out @@ -133,18 +133,6 @@ Checking for bounded response: Computing reachable states: Reachable states: button.Released and lamp.Off [initial states predicate] - Forward reachability iteration 1: - Reachable states: button.Released and lamp.Off -> not button.b and (button.Released and lamp.Off) or button.b and lamp.Off [forward reach with edge: (event: button.u_pushed) (guard: button.b and button.Released) (assignments: button := button.Pushed)] - Reachable states: not button.b and (button.Released and lamp.Off) or button.b and lamp.Off -> (button.b or (button.Pushed or lamp.Off)) and ((button.b or button.Released) and (not button.b or (button.Pushed or lamp.Off))) [forward reach with edge: (event: lamp.c_on) (guard: button.Pushed and lamp.Off) (assignments: lamp := lamp.On)] - Reachable states: (button.b or (button.Pushed or lamp.Off)) and ((button.b or button.Released) and (not button.b or (button.Pushed or lamp.Off))) -> button.Pushed or lamp.Off [forward reach with edge: (event: button.b) (guard: true) (assignments: button.b+ != button.b)] - - Forward reachability iteration 2: - Reachable states: button.Pushed or lamp.Off -> not button.b or (button.Pushed or lamp.Off) [forward reach with edge: (event: button.u_released) (guard: not button.b and button.Pushed) (assignments: button := button.Released)] - Reachable states: not button.b or (button.Pushed or lamp.Off) -> true [forward reach with edge: (event: button.b) (guard: true) (assignments: button.b+ != button.b)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -168,18 +156,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: not button.b and (button.Released and lamp.Off) or button.b and (button.Pushed and lamp.On) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: not button.b and (button.Released and lamp.Off) or button.b and (button.Pushed and lamp.On) -> not button.b and (button.Released and lamp.Off) or button.b and button.Pushed [backward reach with edge: (event: lamp.c_on) (guard: button.Pushed and lamp.Off) (assignments: lamp := lamp.On)] - Controllable-complete path states: not button.b and (button.Released and lamp.Off) or button.b and button.Pushed -> (button.b or button.Released) and (not button.b or button.Pushed) [backward reach with edge: (event: lamp.c_off) (guard: button.Released and lamp.On) (assignments: lamp := lamp.Off)] - Controllable-complete path states: (button.b or button.Released) and (not button.b or button.Pushed) -> (button.b or (button.Released or lamp.On)) and (not button.b or (button.Pushed or lamp.Off)) [backward reach with edge: (event: button.b) (guard: true -> (button.Pushed or lamp.Off) and (button.Released or lamp.On)) (assignments: button.b+ != button.b)] - - Backward reachability iteration 2: - Controllable-complete path states: (button.b or (button.Released or lamp.On)) and (not button.b or (button.Pushed or lamp.Off)) -> not button.b or (button.Pushed or lamp.Off) [backward reach with edge: (event: lamp.c_on) (guard: button.Pushed and lamp.Off) (assignments: lamp := lamp.On)] - Controllable-complete path states: not button.b or (button.Pushed or lamp.Off) -> true [backward reach with edge: (event: lamp.c_off) (guard: button.Released and lamp.On) (assignments: lamp := lamp.Off)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -187,9 +163,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.xxxN.run.out index fdcf2d73cc2240e40f696b6b00601831e3792372..5f3fed30720dea229796e2b95c69478823095350 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp.xxxN.run.out @@ -117,18 +117,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: not button.b and (button.Released and lamp.Off) or button.b and (button.Pushed and lamp.On) [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: not button.b and (button.Released and lamp.Off) or button.b and (button.Pushed and lamp.On) -> not button.b and (button.Released and lamp.Off) or button.b and button.Pushed [backward reach with edge: (event: lamp.c_on) (guard: button.Pushed and lamp.Off) (assignments: lamp := lamp.On)] - Controllable-complete path states: not button.b and (button.Released and lamp.Off) or button.b and button.Pushed -> (button.b or button.Released) and (not button.b or button.Pushed) [backward reach with edge: (event: lamp.c_off) (guard: button.Released and lamp.On) (assignments: lamp := lamp.Off)] - Controllable-complete path states: (button.b or button.Released) and (not button.b or button.Pushed) -> (button.b or (button.Released or lamp.On)) and (not button.b or (button.Pushed or lamp.Off)) [backward reach with edge: (event: button.b) (guard: true -> (button.Pushed or lamp.Off) and (button.Released or lamp.On)) (assignments: button.b+ != button.b)] - - Backward reachability iteration 2: - Controllable-complete path states: (button.b or (button.Released or lamp.On)) and (not button.b or (button.Pushed or lamp.Off)) -> not button.b or (button.Pushed or lamp.Off) [backward reach with edge: (event: lamp.c_on) (guard: button.Pushed and lamp.Off) (assignments: lamp := lamp.On)] - Controllable-complete path states: not button.b or (button.Pushed or lamp.Off) -> true [backward reach with edge: (event: lamp.c_off) (guard: button.Released and lamp.On) (assignments: lamp := lamp.Off)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -136,9 +124,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.BCFN.run.out index 9a1d2c4e1fac38f0ca642ff2021142dbf5f77d35..5ca0351243c35b5ab2a0fd9730d5683689d5261c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.BCFN.run.out @@ -160,21 +160,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Lamp.Off and Timer.Idle and (Cycle.WaitForButtonPush and Button.Released) [initial states predicate] - Forward reachability iteration 1: - Reachable states: Lamp.Off and Timer.Idle and (Cycle.WaitForButtonPush and Button.Released) -> Lamp.Off and Timer.Idle and (Cycle.WaitForButtonPush and Button.Released) or Lamp.Off and Timer.Idle and (Cycle.TurnLampOn and (Button.b and Button.Pushed)) [forward reach with edge: (event: Button.u_pushed) (guard: (Cycle.WaitForButtonPush or Cycle.TurnLampOff) and (Button.b and Button.Released) or (Cycle.StartTimer and (Button.b and Button.Released) or (Cycle.TurnLampOn or Cycle.WaitForTimeout) and (Button.b and Button.Released))) (assignments: Button := Button.Pushed, Cycle := Cycle.TurnLampOn / Button := Button.Pushed / Button := Button.Pushed / Button := Button.Pushed / Button := Button.Pushed)] - Reachable states: Lamp.Off and Timer.Idle and (Cycle.WaitForButtonPush and Button.Released) or Lamp.Off and Timer.Idle and (Cycle.TurnLampOn and (Button.b and Button.Pushed)) -> <bdd 13n 3p> [forward reach with edge: (event: Lamp.c_on) (guard: Lamp.Off and Cycle.TurnLampOn) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer)] - Reachable states: <bdd 13n 3p> -> <bdd 14n 4p> [forward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - Reachable states: <bdd 14n 4p> -> <bdd 16n 5p> [forward reach with edge: (event: Timer.u_timeout) (guard: Timer.Running and Cycle.WaitForTimeout) (assignments: Timer := Timer.Idle, Cycle := Cycle.TurnLampOff)] - Reachable states: <bdd 16n 5p> -> <bdd 15n 5p> [forward reach with edge: (event: Button.b) (guard: true) (assignments: Button.b+ != Button.b)] - - Forward reachability iteration 2: - Reachable states: <bdd 15n 5p> -> <bdd 16n 9p> [forward reach with edge: (event: Button.u_released) (guard: not Button.b and Button.Pushed) (assignments: Button := Button.Released)] - Reachable states: <bdd 16n 9p> -> <bdd 15n 9p> [forward reach with edge: (event: Lamp.c_off) (guard: Lamp.On and Cycle.TurnLampOff) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush)] - Reachable states: <bdd 15n 9p> -> Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) [forward reach with edge: (event: Button.b) (guard: true) (assignments: Button.b+ != Button.b)] - - Forward reachability iteration 3: - No change this iteration. - Reachable states: Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) [fixed point]. Computing bound for uncontrollable events: @@ -200,25 +185,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: <bdd 13n 3p> [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: <bdd 13n 3p> -> <bdd 13n 3p> [backward reach with edge: (event: Button.u_pushed) (guard: (Cycle.WaitForButtonPush or Cycle.TurnLampOff) and (Button.b and Button.Released) or (Cycle.StartTimer and (Button.b and Button.Released) or (Cycle.TurnLampOn or Cycle.WaitForTimeout) and (Button.b and Button.Released)) -> <bdd 13n 8p>) (assignments: Button := Button.Pushed, Cycle := Cycle.TurnLampOn / Button := Button.Pushed / Button := Button.Pushed / Button := Button.Pushed / Button := Button.Pushed)] - Controllable-complete path states: <bdd 13n 3p> -> <bdd 12n 3p> [backward reach with edge: (event: Button.u_released) (guard: not Button.b and Button.Pushed -> <bdd 15n 13p>) (assignments: Button := Button.Released)] - Controllable-complete path states: <bdd 12n 3p> -> <bdd 15n 5p> [backward reach with edge: (event: Lamp.c_off) (guard: Lamp.On and Cycle.TurnLampOff) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush)] - Controllable-complete path states: <bdd 15n 5p> -> <bdd 15n 6p> [backward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - Controllable-complete path states: <bdd 15n 6p> -> <bdd 16n 6p> [backward reach with edge: (event: Timer.u_timeout) (guard: Timer.Running and Cycle.WaitForTimeout) (assignments: Timer := Timer.Idle, Cycle := Cycle.TurnLampOff)] - Controllable-complete path states: <bdd 16n 6p> -> <bdd 15n 5p> [backward reach with edge: (event: Button.b) (guard: true -> <bdd 13n 13p>) (assignments: Button.b+ != Button.b)] - - Backward reachability iteration 2: - Controllable-complete path states: <bdd 15n 5p> -> <bdd 16n 6p> [backward reach with edge: (event: Lamp.c_on) (guard: Lamp.Off and Cycle.TurnLampOn) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer)] - Controllable-complete path states: <bdd 16n 6p> -> <bdd 14n 5p> [backward reach with edge: (event: Lamp.c_off) (guard: Lamp.On and Cycle.TurnLampOff) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush)] - Controllable-complete path states: <bdd 14n 5p> -> <bdd 14n 5p> [backward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - - Backward reachability iteration 3: - Controllable-complete path states: <bdd 14n 5p> -> Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) [backward reach with edge: (event: Lamp.c_on) (guard: Lamp.Off and Cycle.TurnLampOn) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer)] - - Backward reachability iteration 4: - No change this iteration. - Controllable-complete path states: Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) [fixed point]. Controllable-complete path states: Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) @@ -226,9 +192,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: (Lamp.On or (Timer.Running or not Cycle.WaitForButtonPush and not Cycle.TurnLampOn)) and (Lamp.Off or (Timer.Running or not Cycle.TurnLampOff)) and ((Lamp.Off or (Timer.Running or not Cycle.StartTimer)) and (Lamp.Off or (Timer.Idle or not Cycle.WaitForTimeout))) [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: (Lamp.On or (Timer.Running or not Cycle.WaitForButtonPush and not Cycle.TurnLampOn)) and (Lamp.Off or (Timer.Running or not Cycle.TurnLampOff)) and ((Lamp.Off or (Timer.Running or not Cycle.StartTimer)) and (Lamp.Off or (Timer.Idle or not Cycle.WaitForTimeout))) Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.xxxN.run.out index 65861d144cd65ca5bed9769fc0b9a8354ddae699..ee880597e82363c2e632f1e917f8730fd54c6e07 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/button_lamp_timer.xxxN.run.out @@ -123,25 +123,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: <bdd 13n 3p> [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: <bdd 13n 3p> -> <bdd 13n 3p> [backward reach with edge: (event: Button.u_pushed) (guard: (Cycle.WaitForButtonPush or Cycle.TurnLampOff) and (Button.b and Button.Released) or (Cycle.StartTimer and (Button.b and Button.Released) or (Cycle.TurnLampOn or Cycle.WaitForTimeout) and (Button.b and Button.Released)) -> <bdd 13n 8p>) (assignments: Button := Button.Pushed, Cycle := Cycle.TurnLampOn / Button := Button.Pushed / Button := Button.Pushed / Button := Button.Pushed / Button := Button.Pushed)] - Controllable-complete path states: <bdd 13n 3p> -> <bdd 12n 3p> [backward reach with edge: (event: Button.u_released) (guard: not Button.b and Button.Pushed -> <bdd 15n 13p>) (assignments: Button := Button.Released)] - Controllable-complete path states: <bdd 12n 3p> -> <bdd 15n 5p> [backward reach with edge: (event: Lamp.c_off) (guard: Lamp.On and Cycle.TurnLampOff) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush)] - Controllable-complete path states: <bdd 15n 5p> -> <bdd 15n 6p> [backward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - Controllable-complete path states: <bdd 15n 6p> -> <bdd 16n 6p> [backward reach with edge: (event: Timer.u_timeout) (guard: Timer.Running and Cycle.WaitForTimeout) (assignments: Timer := Timer.Idle, Cycle := Cycle.TurnLampOff)] - Controllable-complete path states: <bdd 16n 6p> -> <bdd 15n 5p> [backward reach with edge: (event: Button.b) (guard: true -> <bdd 13n 13p>) (assignments: Button.b+ != Button.b)] - - Backward reachability iteration 2: - Controllable-complete path states: <bdd 15n 5p> -> <bdd 16n 6p> [backward reach with edge: (event: Lamp.c_on) (guard: Lamp.Off and Cycle.TurnLampOn) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer)] - Controllable-complete path states: <bdd 16n 6p> -> <bdd 14n 5p> [backward reach with edge: (event: Lamp.c_off) (guard: Lamp.On and Cycle.TurnLampOff) (assignments: Lamp := Lamp.Off, Cycle := Cycle.WaitForButtonPush)] - Controllable-complete path states: <bdd 14n 5p> -> <bdd 14n 5p> [backward reach with edge: (event: Timer.c_start) (guard: Timer.Idle and Cycle.StartTimer) (assignments: Timer := Timer.Running, Cycle := Cycle.WaitForTimeout)] - - Backward reachability iteration 3: - Controllable-complete path states: <bdd 14n 5p> -> Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) [backward reach with edge: (event: Lamp.c_on) (guard: Lamp.Off and Cycle.TurnLampOn) (assignments: Lamp := Lamp.On, Cycle := Cycle.StartTimer)] - - Backward reachability iteration 4: - No change this iteration. - Controllable-complete path states: Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) [fixed point]. Controllable-complete path states: Lamp.Off and (Timer.Idle and (Cycle.WaitForButtonPush or Cycle.TurnLampOn)) or Lamp.On and (Timer.Idle and Cycle.TurnLampOff) or (Lamp.On and (Timer.Idle and Cycle.StartTimer) or Lamp.On and (Timer.Running and Cycle.WaitForTimeout)) @@ -149,9 +130,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: (Lamp.On or (Timer.Running or not Cycle.WaitForButtonPush and not Cycle.TurnLampOn)) and (Lamp.Off or (Timer.Running or not Cycle.TurnLampOff)) and ((Lamp.Off or (Timer.Running or not Cycle.StartTimer)) and (Lamp.Off or (Timer.Idle or not Cycle.WaitForTimeout))) [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: (Lamp.On or (Timer.Running or not Cycle.WaitForButtonPush and not Cycle.TurnLampOn)) and (Lamp.Off or (Timer.Running or not Cycle.TurnLampOff)) and ((Lamp.Off or (Timer.Running or not Cycle.StartTimer)) and (Lamp.Off or (Timer.Idle or not Cycle.WaitForTimeout))) Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.BCFN.run.out index d8511436468184ee13287ed080fb282d99f149ee..72bccd4b10c50fdb52ca43b6e64143f574d4b03f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.BCFN.run.out @@ -27,13 +27,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor1a.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor1a.Start -> Supervisor1a.Start or Supervisor1a.Done1 [forward reach with edge: (event: Supervisor1a.c_act1) (guard: Supervisor1a.Start or Supervisor1a.Done2) (assignments: Supervisor1a := Supervisor1a.Done1 / Supervisor1a := Supervisor1a.BothDone)] - Reachable states: Supervisor1a.Start or Supervisor1a.Done1 -> true [forward reach with edge: (event: Supervisor1a.c_act2) (guard: Supervisor1a.Start or Supervisor1a.Done1) (assignments: Supervisor1a := Supervisor1a.Done2 / Supervisor1a := Supervisor1a.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -58,13 +51,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor1a.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor1a.BothDone -> Supervisor1a.Done2 or Supervisor1a.BothDone [backward reach with edge: (event: Supervisor1a.c_act1) (guard: Supervisor1a.Start or Supervisor1a.Done2) (assignments: Supervisor1a := Supervisor1a.Done1 / Supervisor1a := Supervisor1a.BothDone)] - Controllable-complete path states: Supervisor1a.Done2 or Supervisor1a.BothDone -> true [backward reach with edge: (event: Supervisor1a.c_act2) (guard: Supervisor1a.Start or Supervisor1a.Done1) (assignments: Supervisor1a := Supervisor1a.Done2 / Supervisor1a := Supervisor1a.BothDone)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -72,9 +58,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.xxxN.run.out index 1bcbcc6fa47f242aff769302358c6c6dd9ff50ad..2cbbea366b2caad1674fd4067295b65fdb01a20c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1a.xxxN.run.out @@ -19,13 +19,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor1a.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor1a.BothDone -> Supervisor1a.Done2 or Supervisor1a.BothDone [backward reach with edge: (event: Supervisor1a.c_act1) (guard: Supervisor1a.Start or Supervisor1a.Done2) (assignments: Supervisor1a := Supervisor1a.Done1 / Supervisor1a := Supervisor1a.BothDone)] - Controllable-complete path states: Supervisor1a.Done2 or Supervisor1a.BothDone -> true [backward reach with edge: (event: Supervisor1a.c_act2) (guard: Supervisor1a.Start or Supervisor1a.Done1) (assignments: Supervisor1a := Supervisor1a.Done2 / Supervisor1a := Supervisor1a.BothDone)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -33,9 +26,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.BCFN.run.out index 5c8d54542775cc2b5d15f1a006e65dfa783a5d61..d25312f4c944531f9d1cbb3fdd5354de19ed4888 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.BCFN.run.out @@ -27,13 +27,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor1b.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor1b.Start -> Supervisor1b.Start or Supervisor1b.Done1 [forward reach with edge: (event: Supervisor1b.c_act1) (guard: Supervisor1b.Start or Supervisor1b.Done2) (assignments: Supervisor1b := Supervisor1b.Done1 / Supervisor1b := Supervisor1b.BothDone)] - Reachable states: Supervisor1b.Start or Supervisor1b.Done1 -> true [forward reach with edge: (event: Supervisor1b.c_act2) (guard: Supervisor1b.Start or Supervisor1b.Done1) (assignments: Supervisor1b := Supervisor1b.Done2 / Supervisor1b := Supervisor1b.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -58,17 +51,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.xxxN.run.out index d7b1b184ebd713122322f97791fd2ec073d95d6d..edf66a35c4bcdcfdfd0aef82fa4f74145bc547f3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_1b.xxxN.run.out @@ -19,17 +19,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.BCFN.run.out index c15ad5d95b1b0204ea228dd3f77090ae1bd25eb1..856d735f7c61600036837e67a05982815f9f6f54 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.BCFN.run.out @@ -26,13 +26,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor2a.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor2a.Start -> not Supervisor2a.BothDone [forward reach with edge: (event: Supervisor2a.c_act1) (guard: Supervisor2a.Start) (assignments: Supervisor2a := Supervisor2a.Done1)] - Reachable states: not Supervisor2a.BothDone -> true [forward reach with edge: (event: Supervisor2a.c_act2) (guard: Supervisor2a.Done1) (assignments: Supervisor2a := Supervisor2a.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -57,15 +50,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor2a.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor2a.BothDone -> not Supervisor2a.Start [backward reach with edge: (event: Supervisor2a.c_act2) (guard: Supervisor2a.Done1) (assignments: Supervisor2a := Supervisor2a.BothDone)] - - Backward reachability iteration 2: - Controllable-complete path states: not Supervisor2a.Start -> true [backward reach with edge: (event: Supervisor2a.c_act1) (guard: Supervisor2a.Start) (assignments: Supervisor2a := Supervisor2a.Done1)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -73,9 +57,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.xxxN.run.out index b250129c01f1c05b59f243e7b7e868d60231af23..f39491980057df2df930b965bb9d2c8b24bcc459 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2a.xxxN.run.out @@ -19,15 +19,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor2a.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor2a.BothDone -> not Supervisor2a.Start [backward reach with edge: (event: Supervisor2a.c_act2) (guard: Supervisor2a.Done1) (assignments: Supervisor2a := Supervisor2a.BothDone)] - - Backward reachability iteration 2: - Controllable-complete path states: not Supervisor2a.Start -> true [backward reach with edge: (event: Supervisor2a.c_act1) (guard: Supervisor2a.Start) (assignments: Supervisor2a := Supervisor2a.Done1)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -35,9 +26,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.BCFN.run.out index d919da5c745c4e4fbca715c2feabf61e4e84efb1..6bf9d18cd677b52946815ac0cf36598e400db68e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.BCFN.run.out @@ -27,14 +27,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor2b.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor2b.Start -> Supervisor2b.Start or Supervisor2b.Done1 [forward reach with edge: (event: Supervisor2b.c_act1) (guard: Supervisor2b.Start) (assignments: Supervisor2b := Supervisor2b.Done1)] - Reachable states: Supervisor2b.Start or Supervisor2b.Done1 -> not Supervisor2b.Halt [forward reach with edge: (event: Supervisor2b.c_act2) (guard: Supervisor2b.Done1) (assignments: Supervisor2b := Supervisor2b.BothDone)] - Reachable states: not Supervisor2b.Halt -> true [forward reach with edge: (event: Supervisor2b.u_button_pushed) (guard: true) (assignments: Supervisor2b := Supervisor2b.Halt / Supervisor2b := Supervisor2b.Start / none)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -59,17 +51,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor2b.Halt [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: Supervisor2b.Halt Computing the bad states: Bad states: not Supervisor2b.Halt [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: not Supervisor2b.Halt Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.xxxN.run.out index 91a40e1413c5506f9a921f0234d08cbe4adba9df..7ad5f53c6f8b77cdcb38e01d15d79f8f59cc4666 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/docs_example_2b.xxxN.run.out @@ -19,17 +19,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor2b.Halt [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: Supervisor2b.Halt Computing the bad states: Bad states: not Supervisor2b.Halt [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: not Supervisor2b.Halt Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.BCFN.run.out index d4a07e95e01de5eba67e6c49db9c17e3fce38228..0532512f5acc0605a9ea394e38b6c2764215e51d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.BCFN.run.out @@ -112,13 +112,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor.Start -> (not Supervisor.DoneFalse or not Supervisor.i) and (not Supervisor.DoneTrue or Supervisor.i) [forward reach with edge: (event: Supervisor.c_act) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.DoneTrue / Supervisor := Supervisor.DoneFalse)] - Reachable states: (not Supervisor.DoneFalse or not Supervisor.i) and (not Supervisor.DoneTrue or Supervisor.i) -> true [forward reach with edge: (event: Supervisor.i) (guard: true) (assignments: Supervisor.i+ != Supervisor.i)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -142,17 +135,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor.DoneTrue [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor.DoneTrue -> Supervisor.Start and Supervisor.i or Supervisor.DoneTrue [backward reach with edge: (event: Supervisor.c_act) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.DoneTrue / Supervisor := Supervisor.DoneFalse)] - Controllable-complete path states: Supervisor.Start and Supervisor.i or Supervisor.DoneTrue -> Supervisor.DoneTrue or Supervisor.i [backward reach with edge: (event: Supervisor.u_back) (guard: not Supervisor.Start) (assignments: Supervisor := Supervisor.Start / Supervisor := Supervisor.Start)] - Controllable-complete path states: Supervisor.DoneTrue or Supervisor.i -> not Supervisor.Start or Supervisor.i [backward reach with edge: (event: Supervisor.i) (guard: true -> not Supervisor.Start) (assignments: Supervisor.i+ != Supervisor.i)] - - Backward reachability iteration 2: - Controllable-complete path states: not Supervisor.Start or Supervisor.i -> true [backward reach with edge: (event: Supervisor.c_act) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.DoneTrue / Supervisor := Supervisor.DoneFalse)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -160,9 +142,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.xxxN.run.out index 9bc290f657c1c4bf560cfa787d1d7400cd1450fa..0118967925f2f19d878830c40e259700f58e6a91 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_init_guard.xxxN.run.out @@ -107,17 +107,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor.DoneTrue [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor.DoneTrue -> Supervisor.Start and Supervisor.i or Supervisor.DoneTrue [backward reach with edge: (event: Supervisor.c_act) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.DoneTrue / Supervisor := Supervisor.DoneFalse)] - Controllable-complete path states: Supervisor.Start and Supervisor.i or Supervisor.DoneTrue -> Supervisor.DoneTrue or Supervisor.i [backward reach with edge: (event: Supervisor.u_back) (guard: not Supervisor.Start) (assignments: Supervisor := Supervisor.Start / Supervisor := Supervisor.Start)] - Controllable-complete path states: Supervisor.DoneTrue or Supervisor.i -> not Supervisor.Start or Supervisor.i [backward reach with edge: (event: Supervisor.i) (guard: true -> not Supervisor.Start) (assignments: Supervisor.i+ != Supervisor.i)] - - Backward reachability iteration 2: - Controllable-complete path states: not Supervisor.Start or Supervisor.i -> true [backward reach with edge: (event: Supervisor.c_act) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.DoneTrue / Supervisor := Supervisor.DoneFalse)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -125,9 +114,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.BCFN.run.out index adb510d34e2eb1d14f127c76e08913ad68369fbe..43dd4adb0d3ab22a3cdcde6b589a86c4eaba4cdb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.BCFN.run.out @@ -26,13 +26,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor.Start -> not Supervisor.BothDone [forward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.Done1)] - Reachable states: not Supervisor.BothDone -> true [forward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Done1) (assignments: Supervisor := Supervisor.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -57,15 +50,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor.BothDone -> not Supervisor.Start [backward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Done1) (assignments: Supervisor := Supervisor.BothDone)] - - Backward reachability iteration 2: - Controllable-complete path states: not Supervisor.Start -> true [backward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.Done1)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -73,9 +57,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.xxxN.run.out index c04ed23108ce1516b7e8820fd7f57f38bfdab23f..c94516d2ed78be78c43bc2bad48d23b7ccac5ab8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_one_path.xxxN.run.out @@ -19,15 +19,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor.BothDone -> not Supervisor.Start [backward reach with edge: (event: Supervisor.c_act2) (guard: Supervisor.Done1) (assignments: Supervisor := Supervisor.BothDone)] - - Backward reachability iteration 2: - Controllable-complete path states: not Supervisor.Start -> true [backward reach with edge: (event: Supervisor.c_act1) (guard: Supervisor.Start) (assignments: Supervisor := Supervisor.Done1)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -35,9 +26,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.BCFN.run.out index 0c6f33d4e911ebbcff83c630316fcad5c78fb09e..e1ab651106543fceb7a18d2939487ebb95af9e9e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.BCFN.run.out @@ -27,13 +27,6 @@ Checking for bounded response: Computing reachable states: Reachable states: Supervisor1.Start [initial states predicate] - Forward reachability iteration 1: - Reachable states: Supervisor1.Start -> Supervisor1.Start or Supervisor1.Done1 [forward reach with edge: (event: Supervisor1.c_act1) (guard: Supervisor1.Start or Supervisor1.Done2) (assignments: Supervisor1 := Supervisor1.Done1 / Supervisor1 := Supervisor1.BothDone)] - Reachable states: Supervisor1.Start or Supervisor1.Done1 -> true [forward reach with edge: (event: Supervisor1.c_act2) (guard: Supervisor1.Start or Supervisor1.Done1) (assignments: Supervisor1 := Supervisor1.Done2 / Supervisor1 := Supervisor1.BothDone)] - - Forward reachability iteration 2: - No change this iteration. - Reachable states: true [fixed point]. Computing bound for uncontrollable events: @@ -58,13 +51,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor1.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor1.BothDone -> Supervisor1.Done2 or Supervisor1.BothDone [backward reach with edge: (event: Supervisor1.c_act1) (guard: Supervisor1.Start or Supervisor1.Done2) (assignments: Supervisor1 := Supervisor1.Done1 / Supervisor1 := Supervisor1.BothDone)] - Controllable-complete path states: Supervisor1.Done2 or Supervisor1.BothDone -> true [backward reach with edge: (event: Supervisor1.c_act2) (guard: Supervisor1.Start or Supervisor1.Done1) (assignments: Supervisor1 := Supervisor1.Done2 / Supervisor1 := Supervisor1.BothDone)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -72,9 +58,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.xxxN.run.out index 24d123be56a26ee46784633ec68ee82740023583..29c2c78c37122c24420efa7167c279483153a90b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_two_paths.xxxN.run.out @@ -19,13 +19,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor1.BothDone [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor1.BothDone -> Supervisor1.Done2 or Supervisor1.BothDone [backward reach with edge: (event: Supervisor1.c_act1) (guard: Supervisor1.Start or Supervisor1.Done2) (assignments: Supervisor1 := Supervisor1.Done1 / Supervisor1 := Supervisor1.BothDone)] - Controllable-complete path states: Supervisor1.Done2 or Supervisor1.BothDone -> true [backward reach with edge: (event: Supervisor1.c_act2) (guard: Supervisor1.Start or Supervisor1.Done1) (assignments: Supervisor1 := Supervisor1.Done2 / Supervisor1 := Supervisor1.BothDone)] - - Backward reachability iteration 2: - No change this iteration. - Controllable-complete path states: true [fixed point]. Controllable-complete path states: true @@ -33,9 +26,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: false [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: false Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_unreach.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_unreach.xxxN.run.out index b315cf8171ad7953d1769746d2b72f7498f8743c..59ae43e50720c4d850db491493857fd4c2682ff3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_unreach.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/nbuc_unreach.xxxN.run.out @@ -19,15 +19,6 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: Supervisor.Done [controllable-complete path end states predicate] - Backward reachability iteration 1: - Controllable-complete path states: Supervisor.Done -> not Supervisor.Unreach3 and not Supervisor.Unreach1 [backward reach with edge: (event: Supervisor.c_act) (guard: not Supervisor.Unreach3 and not Supervisor.Done) (assignments: Supervisor := Supervisor.Done / Supervisor := Supervisor.Unreach2 / Supervisor := Supervisor.Unreach3 / Supervisor := Supervisor.Done)] - - Backward reachability iteration 2: - Controllable-complete path states: not Supervisor.Unreach3 and not Supervisor.Unreach1 -> not Supervisor.Unreach3 [backward reach with edge: (event: Supervisor.c_act) (guard: not Supervisor.Unreach3 and not Supervisor.Done) (assignments: Supervisor := Supervisor.Done / Supervisor := Supervisor.Unreach2 / Supervisor := Supervisor.Unreach3 / Supervisor := Supervisor.Done)] - - Backward reachability iteration 3: - No change this iteration. - Controllable-complete path states: not Supervisor.Unreach3 [fixed point]. Controllable-complete path states: not Supervisor.Unreach3 @@ -35,15 +26,6 @@ Checking for non-blocking under control: Computing the bad states: Bad states: Supervisor.Unreach3 [not controllable-complete path states predicate] - Backward reachability iteration 1: - Bad states: Supervisor.Unreach3 -> Supervisor.Unreach3 or Supervisor.Unreach2 [backward reach with edge: (event: Supervisor.c_act) (guard: not Supervisor.Unreach3 and not Supervisor.Done) (assignments: Supervisor := Supervisor.Done / Supervisor := Supervisor.Unreach2 / Supervisor := Supervisor.Unreach3 / Supervisor := Supervisor.Done)] - - Backward reachability iteration 2: - Bad states: Supervisor.Unreach3 or Supervisor.Unreach2 -> not Supervisor.Start and not Supervisor.Done [backward reach with edge: (event: Supervisor.c_act) (guard: not Supervisor.Unreach3 and not Supervisor.Done) (assignments: Supervisor := Supervisor.Done / Supervisor := Supervisor.Unreach2 / Supervisor := Supervisor.Unreach3 / Supervisor := Supervisor.Done)] - - Backward reachability iteration 3: - No change this iteration. - Bad states: not Supervisor.Start and not Supervisor.Done [fixed point]. Bad states: not Supervisor.Start and not Supervisor.Done diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.BCFN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.BCFN.run.out index 99ca588f90c8401615c73af036d7161ba3d35088..f57f923601fcdf3cd4c5a100b8aedeaf93bc00dc 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.BCFN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.BCFN.run.out @@ -15,9 +15,6 @@ Checking for bounded response: Computing reachable states: Reachable states: false [initial states predicate] - Forward reachability iteration 1: - No change this iteration. - Computing bound for uncontrollable events: Bound: 0. @@ -33,17 +30,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.xxxN.run.out b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.xxxN.run.out index c9efc69f71d344d88d9f9f94659d3c436ce7cf50..b95be61ff54bc8131f9f66527cde42d8d931994a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.xxxN.run.out +++ b/cif/org.eclipse.escet.cif.tests/tests/controllercheck/non_blocking_under_control/no_init.xxxN.run.out @@ -12,17 +12,11 @@ Checking for non-blocking under control: Computing the controllable-complete path states: Controllable-complete path states: false [controllable-complete path end states predicate] - Backward reachability iteration 1: - No change this iteration. - Controllable-complete path states: false Computing the bad states: Bad states: true [not controllable-complete path states predicate] - Backward reachability iteration 1: - No change this iteration. - Bad states: true Computing the result of the non-blocking under control check: diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out index 594472cd91db4003fd979e7aa27c2ce87798affb..dcd5d9ef2d9215efa2e62417017de54e4a15dd45 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out @@ -234,15 +234,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: r1.inactive and r2.inactive and (r3.inactive and q.l1) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: r1.inactive and r2.inactive and (r3.inactive and q.l1) -> r1.inactive and (r2.inactive and r3.inactive) [backward reach with edge: (event: move) (guard: q.l2) (assignments: q := q.l1), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - Backward controlled-behavior: r1.inactive and (r2.inactive and r3.inactive) -> r2.inactive and r3.inactive [backward reach with edge: (event: r1.deactivate) (guard: r1.active) (assignments: r1 := r1.inactive), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - Backward controlled-behavior: r2.inactive and r3.inactive -> r3.inactive [backward reach with edge: (event: r2.deactivate) (guard: r2.active) (assignments: r2 := r2.inactive), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - Backward controlled-behavior: r3.inactive -> r1.inactive or r3.inactive [backward reach with edge: (event: r3.deactivate) (guard: r3.active) (assignments: r3 := r3.inactive), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: r1.inactive or r3.inactive [fixed point]. Controlled behavior not changed. @@ -255,15 +246,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: r1.inactive and r2.inactive and (r3.inactive and q.l1) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: r1.inactive and r2.inactive and (r3.inactive and q.l1) -> r1.inactive and (r2.inactive and r3.inactive) [forward reach with edge: (event: move) (guard: q.l1) (assignments: q := q.l2), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - Forward controlled-behavior: r1.inactive and (r2.inactive and r3.inactive) -> r2.inactive and r3.inactive [forward reach with edge: (event: r1.activate) (guard: r1.inactive) (assignments: r1 := r1.active), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - Forward controlled-behavior: r2.inactive and r3.inactive -> r3.inactive [forward reach with edge: (event: r2.activate) (guard: r2.inactive) (assignments: r2 := r2.active), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - Forward controlled-behavior: r3.inactive -> r1.inactive or r3.inactive [forward reach with edge: (event: r3.activate) (guard: r3.inactive) (assignments: r3 := r3.active), restricted to current/previous controlled-behavior predicate: r1.inactive or r3.inactive] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: r1.inactive or r3.inactive [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/annos.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/annos.cif.out index 9e55f7aef2ba2c0b90e7644d96de90dbe1ef9a7a..dc81d9b124bb18c998e82d48d49e6da057080285 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/annos.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/annos.cif.out @@ -78,9 +78,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -91,9 +88,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out index 113b920b7f1ac602a0cfbed7bdb18d1aa74df0ac..5e544a93246b67cd7ba39babcc03c47c58d1f234 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out @@ -205,15 +205,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.d1 = 1 and (p.d2 = 1 and p.loc2) and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.d1 = 1 and (p.d2 = 1 and p.loc2) and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) -> p.d1 = 1 and p.d2 = 1 and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) [backward reach with edge: (event: p.ed1) (guard: p.loc1) (assignments: p.d1 := p.d1 div 1, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 15n 243p>] - Backward controlled-behavior: p.d1 = 1 and p.d2 = 1 and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) -> p.d1 = 1 and (p.d2 = 2 and p.loc1) and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) or (p.d1 = 1 and p.d2 = 1 and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) or p.d1 = 1 and (p.d2 = 3 and p.loc1) and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1))) [backward reach with edge: (event: p.ed2) (guard: p.loc1) (assignments: p.d2 := p.d2 div 2, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 15n 243p>] - Backward controlled-behavior: p.d1 = 1 and (p.d2 = 2 and p.loc1) and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) or (p.d1 = 1 and p.d2 = 1 and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1)) or p.d1 = 1 and (p.d2 = 3 and p.loc1) and (p.d3 = 1 and (p.d4 = 1 and p.d5 = 1))) -> <bdd 22n 5p> [backward reach with edge: (event: p.ed3) (guard: p.loc1) (assignments: p.d3 := p.d3 div 3, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 15n 243p>] - Backward controlled-behavior: <bdd 22n 5p> -> <bdd 27n 7p> [backward reach with edge: (event: p.ed4) (guard: p.loc1) (assignments: p.d4 := p.d4 div 4, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 15n 243p>] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 27n 7p> [fixed point]. Controlled behavior: <bdd 15n 243p> -> <bdd 27n 7p>. @@ -227,12 +218,6 @@ Synthesis round 1: Forward controlled-behavior: <bdd 16n 243p> [initialization predicate] Forward controlled-behavior: <bdd 16n 243p> -> <bdd 27n 6p> [restricted to current/previous controlled-behavior predicate: <bdd 27n 7p>] - Forward reachability iteration 1: - Forward controlled-behavior: <bdd 27n 6p> -> <bdd 27n 7p> [forward reach with edge: (event: p.ed1) (guard: p.loc1) (assignments: p.d1 := p.d1 div 1, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 27n 7p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 27n 7p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_inc_mod.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_inc_mod.cif.out index 792990833191825bdb0bb6576d0da68eb8bdb309..07341f0e35368377e3d924c4eef1159042483111 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_inc_mod.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_inc_mod.cif.out @@ -90,9 +90,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x = 0 or (p.x = 2 or p.x = 4) [restricted to current/previous controlled-behavior predicate: p.x = 0 or (p.x = 2 or p.x = 4)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 0 or (p.x = 2 or p.x = 4) [fixed point]. Controlled behavior not changed. @@ -105,9 +102,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 2 [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior: p.x = 0 or (p.x = 2 or p.x = 4) -> p.x = 2. Need another round. @@ -117,9 +111,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x = 2 [restricted to current/previous controlled-behavior predicate: p.x = 2] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 2 [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out index 72f92c586cd78bd8af740143d44c01bae4285783..b08e58e3e35d4a4c002f7467a5875f974a043482 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out @@ -205,13 +205,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.m1 = 1 and (p.m2 = 1 and p.loc2) and (p.m3 = 1 and (p.m4 = 1 and p.m5 = 1)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.m1 = 1 and (p.m2 = 1 and p.loc2) and (p.m3 = 1 and (p.m4 = 1 and p.m5 = 1)) -> p.m1 = 1 and p.m2 = 1 and (p.m3 = 1 and (p.m4 = 1 and p.m5 = 1)) or p.m1 = 1 and (p.m2 = 3 and p.loc1) and (p.m3 = 1 and (p.m4 = 1 and p.m5 = 1)) [backward reach with edge: (event: p.em2) (guard: p.loc1) (assignments: p.m2 := p.m2 mod 2, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 15n 243p>] - Backward controlled-behavior: p.m1 = 1 and p.m2 = 1 and (p.m3 = 1 and (p.m4 = 1 and p.m5 = 1)) or p.m1 = 1 and (p.m2 = 3 and p.loc1) and (p.m3 = 1 and (p.m4 = 1 and p.m5 = 1)) -> <bdd 21n 4p> [backward reach with edge: (event: p.em3) (guard: p.loc1) (assignments: p.m3 := p.m3 mod 3, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 15n 243p>] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 21n 4p> [fixed point]. Controlled behavior: <bdd 15n 243p> -> <bdd 21n 4p>. @@ -225,12 +218,6 @@ Synthesis round 1: Forward controlled-behavior: <bdd 16n 243p> [initialization predicate] Forward controlled-behavior: <bdd 16n 243p> -> <bdd 21n 3p> [restricted to current/previous controlled-behavior predicate: <bdd 21n 4p>] - Forward reachability iteration 1: - Forward controlled-behavior: <bdd 21n 3p> -> <bdd 21n 4p> [forward reach with edge: (event: p.em2) (guard: p.loc1) (assignments: p.m2 := p.m2 mod 2, p := p.loc2), restricted to current/previous controlled-behavior predicate: <bdd 21n 4p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 21n 4p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out index 545121191a96b38d0f6598df92cd29f320d8d4ba..6c4f59afb71d937ab64ba538305a7ee1a26d2197 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out @@ -208,9 +208,6 @@ Synthesis round 1: Backward controlled-behavior: p.y != 3 [marker predicate] Backward controlled-behavior: p.y != 3 -> <bdd 14n 54p> [restricted to current/previous controlled-behavior predicate: <bdd 13n 54p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 54p> [fixed point]. Controlled behavior: <bdd 13n 54p> -> <bdd 14n 54p>. @@ -224,9 +221,6 @@ Synthesis round 1: Forward controlled-behavior: <bdd 14n 81p> [initialization predicate] Forward controlled-behavior: <bdd 14n 81p> -> <bdd 12n 27p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 54p>] - Forward reachability iteration 1: - No change this iteration. - Forward controlled-behavior: <bdd 12n 27p> [fixed point]. Controlled behavior: <bdd 14n 54p> -> <bdd 12n 27p>. @@ -238,9 +232,6 @@ Synthesis round 2: Backward controlled-behavior: p.y != 3 [marker predicate] Backward controlled-behavior: p.y != 3 -> <bdd 12n 27p> [restricted to current/previous controlled-behavior predicate: <bdd 12n 27p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 12n 27p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out index 1695a439f8ee7b48299e2dad563742a75dcc01e8..6019c5b686d9baa097b7199a2a64d2eb5fbc6c08 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out @@ -199,9 +199,6 @@ Synthesis round 1: Backward controlled-behavior: not p.l4 and (not p.l5 and not p.l6) [marker predicate] Backward controlled-behavior: not p.l4 and (not p.l5 and not p.l6) -> (p.x = 0 or p.x = 8) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 4 and not p.l4 and (not p.l5 and not p.l6) or (p.x = 2 or p.x = 6) and not p.l4 and (not p.l5 and not p.l6)) or ((p.x = 1 or p.x = 9) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 5 and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and not p.l4 and (not p.l5 and not p.l6))) [restricted to current/previous controlled-behavior predicate: p.x != 5 or not p.l1 and (not p.l3 and not p.l5)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 8) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 4 and not p.l4 and (not p.l5 and not p.l6) or (p.x = 2 or p.x = 6) and not p.l4 and (not p.l5 and not p.l6)) or ((p.x = 1 or p.x = 9) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 5 and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and not p.l4 and (not p.l5 and not p.l6))) [fixed point]. Controlled behavior: p.x != 5 or not p.l1 and (not p.l3 and not p.l5) -> (p.x = 0 or p.x = 8) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 4 and not p.l4 and (not p.l5 and not p.l6) or (p.x = 2 or p.x = 6) and not p.l4 and (not p.l5 and not p.l6)) or ((p.x = 1 or p.x = 9) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 5 and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and not p.l4 and (not p.l5 and not p.l6))). @@ -209,12 +206,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 8) and (p.l4 or (p.l5 or p.l6)) or (p.x = 4 and (p.l4 or (p.l5 or p.l6)) or (p.x = 2 or p.x = 6) and (p.l4 or (p.l5 or p.l6))) or ((p.x = 1 or p.x = 9) and (p.l4 or (p.l5 or p.l6)) or p.x = 5 and (p.l4 or p.l6) or (p.x = 5 and (p.l1 or (p.l3 or p.l5)) or (p.x = 3 or p.x = 7) and (p.l4 or (p.l5 or p.l6)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.x = 0 or p.x = 8) and (p.l4 or (p.l5 or p.l6)) or (p.x = 4 and (p.l4 or (p.l5 or p.l6)) or (p.x = 2 or p.x = 6) and (p.l4 or (p.l5 or p.l6))) or ((p.x = 1 or p.x = 9) and (p.l4 or (p.l5 or p.l6)) or p.x = 5 and (p.l4 or p.l6) or (p.x = 5 and (p.l1 or (p.l3 or p.l5)) or (p.x = 3 or p.x = 7) and (p.l4 or (p.l5 or p.l6)))) -> <bdd 11n 21p> [backward reach with edge: (event: u) (guard: p.l3) (assignments: p.x := 4, p := p.l4)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: <bdd 11n 21p> [fixed point]. Controlled behavior: (p.x = 0 or p.x = 8) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 4 and not p.l4 and (not p.l5 and not p.l6) or (p.x = 2 or p.x = 6) and not p.l4 and (not p.l5 and not p.l6)) or ((p.x = 1 or p.x = 9) and not p.l4 and (not p.l5 and not p.l6) or (p.x = 5 and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and not p.l4 and (not p.l5 and not p.l6))) -> (p.x = 0 or p.x = 8) and (p.l0 or p.l2) or (p.x = 0 or p.x = 8) and p.l1 or (p.x = 4 and (p.l0 or p.l2) or (p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and (p.l0 or p.l2))) or ((p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 9) and (p.l0 or p.l2) or (p.x = 1 or p.x = 9) and p.l1) or (p.x = 5 and (p.l0 or p.l2) or ((p.x = 3 or p.x = 7) and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and p.l1))). @@ -222,13 +213,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and p.l0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and p.l0 -> p.x = 0 and p.l0 or p.x = 1 and p.l1 [forward reach with edge: (event: c) (guard: p.l0) (assignments: p.x := 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and (p.l0 or p.l2) or (p.x = 0 or p.x = 8) and p.l1 or (p.x = 4 and (p.l0 or p.l2) or (p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and (p.l0 or p.l2))) or ((p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 9) and (p.l0 or p.l2) or (p.x = 1 or p.x = 9) and p.l1) or (p.x = 5 and (p.l0 or p.l2) or ((p.x = 3 or p.x = 7) and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and p.l1)))] - Forward controlled-behavior: p.x = 0 and p.l0 or p.x = 1 and p.l1 -> p.x = 0 and p.l0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1) [forward reach with edge: (event: u) (guard: p.l1) (assignments: p.x := 2, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and (p.l0 or p.l2) or (p.x = 0 or p.x = 8) and p.l1 or (p.x = 4 and (p.l0 or p.l2) or (p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and (p.l0 or p.l2))) or ((p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 9) and (p.l0 or p.l2) or (p.x = 1 or p.x = 9) and p.l1) or (p.x = 5 and (p.l0 or p.l2) or ((p.x = 3 or p.x = 7) and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and p.l1)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 and p.l0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 8) and (p.l0 or p.l2) or (p.x = 0 or p.x = 8) and p.l1 or (p.x = 4 and (p.l0 or p.l2) or (p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and (p.l0 or p.l2))) or ((p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 9) and (p.l0 or p.l2) or (p.x = 1 or p.x = 9) and p.l1) or (p.x = 5 and (p.l0 or p.l2) or ((p.x = 3 or p.x = 7) and (p.l0 or p.l2) or (p.x = 3 or p.x = 7) and p.l1))) -> p.x = 0 and p.l0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1). @@ -240,9 +224,6 @@ Synthesis round 2: Backward controlled-behavior: not p.l4 and (not p.l5 and not p.l6) [marker predicate] Backward controlled-behavior: not p.l4 and (not p.l5 and not p.l6) -> p.x = 0 and p.l0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1) [restricted to current/previous controlled-behavior predicate: p.x = 0 and p.l0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 0 and p.l0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1) [fixed point]. Controlled behavior not changed. @@ -250,9 +231,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 0 or not p.l0) and ((p.x != 2 or not p.l2) and (p.x != 1 or not p.l1)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_cnf.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_cnf.cif.out index a0d492e0ec6f0a41e1f30638c6d2d3e019f048c5..9cbaa4420843c7ce545b6070add050f832cfe447 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_cnf.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_cnf.cif.out @@ -201,12 +201,6 @@ Synthesis round 1: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) [restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [fixed point]. Controlled behavior: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q))))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))). @@ -214,21 +208,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 10n 22p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) [initialization predicate] Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [forward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)). @@ -240,12 +225,6 @@ Synthesis round 2: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior not changed. @@ -253,9 +232,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 4 or p.x != 2 or (not p.b or p.v = p.Q)) and ((p.y != 2 or p.x != 2 or (not p.b or p.v = p.Q)) and (p.y != 3 or p.x != 2 or (not p.b or p.v = p.Q))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_dnf.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_dnf.cif.out index 357370c66bfe3ee23c586207275d989fb073b881..eea32c4c41de399e06d9c7492088938dab601c14 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_dnf.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_dnf.cif.out @@ -201,12 +201,6 @@ Synthesis round 1: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) [restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [fixed point]. Controlled behavior: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q))))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))). @@ -214,21 +208,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 10n 22p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) [initialization predicate] Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [forward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)). @@ -240,12 +225,6 @@ Synthesis round 2: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior not changed. @@ -253,9 +232,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 4 or p.x != 2 or (not p.b or p.v = p.Q)) and ((p.y != 2 or p.x != 2 or (not p.b or p.v = p.Q)) and (p.y != 3 or p.x != 2 or (not p.b or p.v = p.Q))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out index 7e82c71d7b4913e4f5525f2126aae06107794f99..a7629a9e8ac1fc5e8c20edc74dacd2001a993643 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out @@ -201,12 +201,6 @@ Synthesis round 1: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) [restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [fixed point]. Controlled behavior: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q))))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))). @@ -214,21 +208,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 10n 22p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) [initialization predicate] Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [forward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)). @@ -240,12 +225,6 @@ Synthesis round 2: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior not changed. @@ -253,9 +232,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 4 or p.x != 2 or (not p.b or p.v = p.Q)) and ((p.y != 2 or p.x != 2 or (not p.b or p.v = p.Q)) and (p.y != 3 or p.x != 2 or (not p.b or p.v = p.Q))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_normal.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_normal.cif.out index d93e1d93235181cde2f16d9df6b66f7e9db8a0bf..d5ef9642bd3585ecb03ee7be5562cd36d4ff4a38 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_normal.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_normal.cif.out @@ -201,12 +201,6 @@ Synthesis round 1: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) [restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.b and p.v != p.Q) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q)))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) [fixed point]. Controlled behavior: (p.y = 2 or p.y = 3 or (p.L2 or p.b)) and ((p.y = 2 or p.y = 3 or (p.L1 or p.b)) and (p.y = 2 or p.y = 3 or (p.L1 or (not p.b or p.v != p.Q)))) and ((p.y = 4 or p.y = 5 or (p.L2 or p.b)) and ((p.y = 4 or p.y = 5 or (p.L1 or p.b)) and (p.y = 4 or p.y = 5 or (p.L1 or (not p.b or p.v != p.Q))))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))). @@ -214,21 +208,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 10n 22p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) [initialization predicate] Forward controlled-behavior: (p.y = 2 or p.y = 3 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 2 or (p.y = 3 or p.L1)) and ((p.y = 4 or p.y = 5 or (p.L2 or (p.x = 2 or p.x = 3))) and (p.y = 4 or (p.y = 5 or p.L1))) -> p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [forward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior: p.y = 4 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 4 and p.L2 and (p.b and p.v != p.Q) or p.y = 2 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q))) or (p.y = 2 and p.L2 and (p.b and p.v != p.Q) or (p.y = 3 and p.L1 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)). @@ -240,12 +225,6 @@ Synthesis round 2: Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 [marker predicate] Backward controlled-behavior: (p.y = 2 or p.y = 4) and p.L2 or p.y = 3 and p.L2 -> p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) [restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 4 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or (p.y = 2 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q)) or p.y = 3 and p.L2 and (p.x = 2 and (p.b and p.v != p.Q))) -> p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [backward reach with edge: (event: p.e1) (guard: p.L1 and p.x = 2) (assignments: p := p.L2), restricted to current/previous controlled-behavior predicate: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 4 and p.x = 2 and (p.b and p.v != p.Q) or (p.y = 2 and p.x = 2 and (p.b and p.v != p.Q) or p.y = 3 and p.x = 2 and (p.b and p.v != p.Q)) [fixed point]. Controlled behavior not changed. @@ -253,9 +232,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 4 or p.x != 2 or (not p.b or p.v = p.Q)) and ((p.y != 2 or p.x != 2 or (not p.b or p.v = p.Q)) and (p.y != 3 or p.x != 2 or (not p.b or p.v = p.Q))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out index 9e42bc7a44abbff5ea89970592e260487b02a483..7a44505378f5b1cb3e0b36f23715338b3c8e2f60 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out @@ -199,12 +199,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: g.p.b0 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: g.p.b0 -> true [backward reach with edge: (event: g.e1) (guard: true) (assignments: g.p.b0 := not g.p.b0), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -217,12 +211,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: not g.p.b0 and not g.p.b2 and (g.p.b1 and (g.p.b3 and g.p.b4)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: not g.p.b0 and not g.p.b2 and (g.p.b1 and (g.p.b3 and g.p.b4)) -> not g.p.b2 and g.p.b1 and (g.p.b3 and g.p.b4) [forward reach with edge: (event: g.e1) (guard: true) (assignments: g.p.b0 := not g.p.b0), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: not g.p.b2 and g.p.b1 and (g.p.b3 and g.p.b4) [fixed point]. Controlled behavior: true -> not g.p.b2 and g.p.b1 and (g.p.b3 and g.p.b4). @@ -234,12 +222,6 @@ Synthesis round 2: Backward controlled-behavior: g.p.b0 [marker predicate] Backward controlled-behavior: g.p.b0 -> g.p.b0 and not g.p.b2 and (g.p.b1 and (g.p.b3 and g.p.b4)) [restricted to current/previous controlled-behavior predicate: not g.p.b2 and g.p.b1 and (g.p.b3 and g.p.b4)] - Backward reachability iteration 1: - Backward controlled-behavior: g.p.b0 and not g.p.b2 and (g.p.b1 and (g.p.b3 and g.p.b4)) -> not g.p.b2 and g.p.b1 and (g.p.b3 and g.p.b4) [backward reach with edge: (event: g.e1) (guard: true) (assignments: g.p.b0 := not g.p.b0), restricted to current/previous controlled-behavior predicate: not g.p.b2 and g.p.b1 and (g.p.b3 and g.p.b4)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: not g.p.b2 and g.p.b1 and (g.p.b3 and g.p.b4) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_ctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_ctrl.cif.out index bdc4879c6320cf21c1348d571ecb1dce36dcb004..33d03150828c22fd0ad9d9aadee8b33ff78ad967 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_ctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_ctrl.cif.out @@ -246,9 +246,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 11n 32p> [restricted to current/previous controlled-behavior predicate: <bdd 11n 32p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 11n 32p> [fixed point]. Controlled behavior not changed. @@ -261,9 +258,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: <bdd 11n 32p> [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_unctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_unctrl.cif.out index d9011f06313c2b2c320134b32f134b395c399eda..8cdb2b755630fbd62dcb1a6e41122f5541398af6 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_unctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/buffer_unctrl.cif.out @@ -255,9 +255,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> false [restricted to current/previous controlled-behavior predicate: false] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: false [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_forward.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.cif similarity index 100% rename from cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_forward.cif rename to cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.cif diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.cif.out new file mode 100644 index 0000000000000000000000000000000000000000..6a514446452a98dde81bd2a10fd778c4553e67bd --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.cif.out @@ -0,0 +1,271 @@ +Reading CIF file "datasynth/chaining_fixed.cif". + +Preprocessing CIF specification (includes checking that the specification is supported). + +Converting CIF specification to internal format (BDDs): + CIF variables and location pointers: + Nr Kind Type Name Group BDD vars CIF values BDD values Values used + ----- ----------------- --------- ---- ----- -------- ---------- ---------- ----------- + 1 discrete variable int[0..3] p1.c 0 2 * 2 4 * 2 4 * 2 100% + 2 discrete variable bool p2.b 1 1 * 2 2 * 2 2 * 2 100% + ----- ----------------- --------- ---- ----- -------- ---------- ---------- ----------- + Total 2 6 12 12 100% + + Applying variable ordering: + Applying 4 orderers, sequentially: + Applying model variable order: + Effect: both + + Applying DCSH algorithm: + Metric: wes + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Applying Weighted Cuthill-McKee algorithm: + Node finder: george-liu + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Found new best variable order. + + Applying Sloan algorithm: + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Applying 2 orderers, sequentially: + Applying Weighted Cuthill-McKee algorithm: + Node finder: george-liu + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Reversing the variable order: + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [reversed] + + Applying 2 orderers, sequentially: + Applying Sloan algorithm: + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Reversing the variable order: + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [reversed] + + Applying FORCE algorithm: + Metric: total-span + Relations: linearized + Effect: var-order + Number of hyper-edges: 2 + Maximum number of iterations: 10 + + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] + + Applying sliding window algorithm: + Size: 4 + Metric: total-span + Relations: linearized + Effect: var-order + Number of hyper-edges: 2 + Window length: 2 + + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] + + Variable order unchanged. + +Starting data-based synthesis. + +Synthesis input: + Invariant (components state plant inv): true + Invariant (locations state plant invariant): true + Invariant (system state plant invariant): true + + Invariant (components state req invariant): true + Invariant (locations state req invariant): true + Invariant (system state req invariant): true + + Initial (discrete variable 0): p1.c = 0 + Initial (discrete variable 1): not p2.b + Initial (discrete variables): p1.c = 0 and not p2.b + Initial (components init predicate): true + Initial (aut/locs init predicate): true + Initial (aut/locs init predicate): true + Initial (auts/locs init predicate): true + Initial (uncontrolled system): p1.c = 0 and not p2.b + Initial (system, combined init/plant inv): p1.c = 0 and not p2.b + Initial (system, combined init/state inv): p1.c = 0 and not p2.b + + Marked (components marker predicate): true + Marked (aut/locs marker predicate): true + Marked (aut/locs marker predicate): true + Marked (auts/locs marker predicate): true + Marked (uncontrolled system): true + Marked (system, combined mark/plant inv): true + Marked (system, combined mark/state inv): true + + State/event exclusion plants: + None + + State/event exclusion requirements: + None + + Uncontrolled system: + State: (controlled-behavior: ?) + Edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1) + Edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true) + +Checking input for potential problems. + +Restricting edge guards to prevent runtime errors: + No guards changed. + +Restricting uncontrolled system behavior using state/event exclusion plant invariants: + No guards changed. + +Initializing edges for being applied. + +Restricting uncontrolled system behavior using state plant invariants: + No restrictions needed. + +Initializing controlled behavior: + Controlled-behavior predicate: true. + Controlled-initialization predicate: p1.c = 0 and not p2.b. + +Restricting behavior using state requirements: + Controlled behavior not changed. + +Extending controlled-behavior predicate using variable ranges: + Controlled behavior not changed. + +Restricting behavior using state/event exclusion requirements: + Guards and controlled behavior not changed. + +Restricting behavior using implicit runtime error requirements: + Controlled behavior not changed. + +Re-initializing edges for being applied. + +Checking pre-synthesis for events that are never enabled. + +Synthesis round 1: + Computing backward controlled-behavior predicate: + Backward controlled-behavior: true [marker predicate] + + Backward reachability iteration 1: + No change this iteration. + + Controlled behavior not changed. + + Computing backward uncontrolled bad-state predicate: + Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] + + Controlled behavior not changed. + + Computing forward controlled-behavior predicate: + Forward controlled-behavior: p1.c = 0 and not p2.b [initialization predicate] + + Forward reachability iteration 1: + Forward controlled-behavior: p1.c = 0 and not p2.b -> (p1.c = 0 or p1.c = 1) and not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + Forward controlled-behavior: (p1.c = 0 or p1.c = 1) and not p2.b -> p1.c = 0 and not p2.b or p1.c = 1 [forward reach with edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true), restricted to current/previous controlled-behavior predicate: true] + + Forward reachability iteration 2: + Forward controlled-behavior: p1.c = 0 and not p2.b or p1.c = 1 -> (p1.c != 0 or not p2.b) and p1.c != 3 [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + + Forward reachability iteration 3: + Forward controlled-behavior: (p1.c != 0 or not p2.b) and p1.c != 3 -> p1.c != 0 or not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + + Forward reachability iteration 4: + No change this iteration. + + Forward controlled-behavior: p1.c != 0 or not p2.b [fixed point]. + + Controlled behavior: true -> p1.c != 0 or not p2.b. + + Need another round. + +Synthesis round 2: + Computing backward controlled-behavior predicate: + Backward controlled-behavior: true [marker predicate] + Backward controlled-behavior: true -> p1.c != 0 or not p2.b [restricted to current/previous controlled-behavior predicate: p1.c != 0 or not p2.b] + + Backward reachability iteration 1: + No change this iteration. + + Backward controlled-behavior: p1.c != 0 or not p2.b [fixed point]. + + Controlled behavior not changed. + + Computing backward uncontrolled bad-state predicate: + Backward uncontrolled bad-state: p1.c = 0 and p2.b [current/previous controlled behavior predicate] + + Controlled behavior not changed. + + Finished: controlled behavior is stable. + +Computing final controlled system guards: + No guards changed. + +Cleaning up cached predicate of edges that were used when applying edges. + +Final synthesis result: + State: (controlled-behavior: p1.c != 0 or not p2.b) + Edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1) + Edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true) + +Computing initialization predicate of the controlled system. + +Controlled system: exactly 7 states. + +Determining initialization predicate for output model: + Initial (synthesis result): p1.c != 0 or not p2.b + Initial (uncontrolled system): p1.c = 0 and not p2.b + Initial (controlled system): p1.c = 0 and not p2.b + Initial (removed by supervisor): false + Initial (added by supervisor): true + + Initial (output model): n/a + +Determining supervisor guards for output model: + Event p1.next: guard: p1.c != 3. + Event p2.e: guard: p1.c = 1 and not p2.b. + +Checking post-synthesis for events that are never enabled. + +Simplifying supervisor guards for output model: + Simplification under the assumption of the plants. + + Event p1.next: guard: p1.c != 3 -> true [assume p1.c != 3]. + Event p2.e: guard: p1.c = 1 and not p2.b -> true [assume p1.c = 1 and not p2.b]. + +Constructing output CIF specification. + +Checking output CIF specification. + +Writing output CIF file "datasynth/chaining_fixed.ctrlsys.real.cif". diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_forward.ctrlsys.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.ctrlsys.cif similarity index 100% rename from cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_forward.ctrlsys.cif rename to cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.ctrlsys.cif diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_forward.statespace.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.statespace.cif similarity index 100% rename from cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_forward.statespace.cif rename to cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed.statespace.cif diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.cif new file mode 100644 index 0000000000000000000000000000000000000000..a783800aa4d81e996d2142d04aba259d3cf50403 --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.cif @@ -0,0 +1,32 @@ +////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2023, 2024 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available +// under the terms of the MIT License which is available at +// https://opensource.org/licenses/MIT +// +// SPDX-License-Identifier: MIT +////////////////////////////////////////////////////////////////////////////// + +plant p1: + controllable next; + disc int[0..3] c = 0; + + location: + initial; + marked; + edge next when c < 3 do c := c + 1; +end + +plant p2: + controllable e; + disc bool b; + + location: + initial; + marked; + edge e when p1.c = 1, not b do b := true; +end diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.cif.out new file mode 100644 index 0000000000000000000000000000000000000000..b6508a0cab8c539c6e310815cf3c49c7fb133f69 --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.cif.out @@ -0,0 +1,271 @@ +Reading CIF file "datasynth/chaining_fixed_forward.cif". + +Preprocessing CIF specification (includes checking that the specification is supported). + +Converting CIF specification to internal format (BDDs): + CIF variables and location pointers: + Nr Kind Type Name Group BDD vars CIF values BDD values Values used + ----- ----------------- --------- ---- ----- -------- ---------- ---------- ----------- + 1 discrete variable int[0..3] p1.c 0 2 * 2 4 * 2 4 * 2 100% + 2 discrete variable bool p2.b 1 1 * 2 2 * 2 2 * 2 100% + ----- ----------------- --------- ---- ----- -------- ---------- ---------- ----------- + Total 2 6 12 12 100% + + Applying variable ordering: + Applying 4 orderers, sequentially: + Applying model variable order: + Effect: both + + Applying DCSH algorithm: + Metric: wes + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Applying Weighted Cuthill-McKee algorithm: + Node finder: george-liu + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Found new best variable order. + + Applying Sloan algorithm: + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Applying 2 orderers, sequentially: + Applying Weighted Cuthill-McKee algorithm: + Node finder: george-liu + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Reversing the variable order: + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [reversed] + + Applying 2 orderers, sequentially: + Applying Sloan algorithm: + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Reversing the variable order: + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [reversed] + + Applying FORCE algorithm: + Metric: total-span + Relations: linearized + Effect: var-order + Number of hyper-edges: 2 + Maximum number of iterations: 10 + + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] + + Applying sliding window algorithm: + Size: 4 + Metric: total-span + Relations: linearized + Effect: var-order + Number of hyper-edges: 2 + Window length: 2 + + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] + + Variable order unchanged. + +Starting data-based synthesis. + +Synthesis input: + Invariant (components state plant inv): true + Invariant (locations state plant invariant): true + Invariant (system state plant invariant): true + + Invariant (components state req invariant): true + Invariant (locations state req invariant): true + Invariant (system state req invariant): true + + Initial (discrete variable 0): p1.c = 0 + Initial (discrete variable 1): not p2.b + Initial (discrete variables): p1.c = 0 and not p2.b + Initial (components init predicate): true + Initial (aut/locs init predicate): true + Initial (aut/locs init predicate): true + Initial (auts/locs init predicate): true + Initial (uncontrolled system): p1.c = 0 and not p2.b + Initial (system, combined init/plant inv): p1.c = 0 and not p2.b + Initial (system, combined init/state inv): p1.c = 0 and not p2.b + + Marked (components marker predicate): true + Marked (aut/locs marker predicate): true + Marked (aut/locs marker predicate): true + Marked (auts/locs marker predicate): true + Marked (uncontrolled system): true + Marked (system, combined mark/plant inv): true + Marked (system, combined mark/state inv): true + + State/event exclusion plants: + None + + State/event exclusion requirements: + None + + Uncontrolled system: + State: (controlled-behavior: ?) + Edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1) + Edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true) + +Checking input for potential problems. + +Restricting edge guards to prevent runtime errors: + No guards changed. + +Restricting uncontrolled system behavior using state/event exclusion plant invariants: + No guards changed. + +Initializing edges for being applied. + +Restricting uncontrolled system behavior using state plant invariants: + No restrictions needed. + +Initializing controlled behavior: + Controlled-behavior predicate: true. + Controlled-initialization predicate: p1.c = 0 and not p2.b. + +Restricting behavior using state requirements: + Controlled behavior not changed. + +Extending controlled-behavior predicate using variable ranges: + Controlled behavior not changed. + +Restricting behavior using state/event exclusion requirements: + Guards and controlled behavior not changed. + +Restricting behavior using implicit runtime error requirements: + Controlled behavior not changed. + +Re-initializing edges for being applied. + +Checking pre-synthesis for events that are never enabled. + +Synthesis round 1: + Computing backward controlled-behavior predicate: + Backward controlled-behavior: true [marker predicate] + + Backward reachability iteration 1: + No change this iteration. + + Controlled behavior not changed. + + Computing backward uncontrolled bad-state predicate: + Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] + + Controlled behavior not changed. + + Computing forward controlled-behavior predicate: + Forward controlled-behavior: p1.c = 0 and not p2.b [initialization predicate] + + Forward reachability iteration 1: + Forward controlled-behavior: p1.c = 0 and not p2.b -> (p1.c = 0 or p1.c = 1) and not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + Forward controlled-behavior: (p1.c = 0 or p1.c = 1) and not p2.b -> p1.c = 0 and not p2.b or p1.c = 1 [forward reach with edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true), restricted to current/previous controlled-behavior predicate: true] + + Forward reachability iteration 2: + Forward controlled-behavior: p1.c = 0 and not p2.b or p1.c = 1 -> (p1.c != 0 or not p2.b) and p1.c != 3 [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + + Forward reachability iteration 3: + Forward controlled-behavior: (p1.c != 0 or not p2.b) and p1.c != 3 -> p1.c != 0 or not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + + Forward reachability iteration 4: + No change this iteration. + + Forward controlled-behavior: p1.c != 0 or not p2.b [fixed point]. + + Controlled behavior: true -> p1.c != 0 or not p2.b. + + Need another round. + +Synthesis round 2: + Computing backward controlled-behavior predicate: + Backward controlled-behavior: true [marker predicate] + Backward controlled-behavior: true -> p1.c != 0 or not p2.b [restricted to current/previous controlled-behavior predicate: p1.c != 0 or not p2.b] + + Backward reachability iteration 1: + No change this iteration. + + Backward controlled-behavior: p1.c != 0 or not p2.b [fixed point]. + + Controlled behavior not changed. + + Computing backward uncontrolled bad-state predicate: + Backward uncontrolled bad-state: p1.c = 0 and p2.b [current/previous controlled behavior predicate] + + Controlled behavior not changed. + + Finished: controlled behavior is stable. + +Computing final controlled system guards: + No guards changed. + +Cleaning up cached predicate of edges that were used when applying edges. + +Final synthesis result: + State: (controlled-behavior: p1.c != 0 or not p2.b) + Edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1) + Edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true) + +Computing initialization predicate of the controlled system. + +Controlled system: exactly 7 states. + +Determining initialization predicate for output model: + Initial (synthesis result): p1.c != 0 or not p2.b + Initial (uncontrolled system): p1.c = 0 and not p2.b + Initial (controlled system): p1.c = 0 and not p2.b + Initial (removed by supervisor): false + Initial (added by supervisor): true + + Initial (output model): n/a + +Determining supervisor guards for output model: + Event p1.next: guard: p1.c != 3. + Event p2.e: guard: p1.c = 1 and not p2.b. + +Checking post-synthesis for events that are never enabled. + +Simplifying supervisor guards for output model: + Simplification under the assumption of the plants. + + Event p1.next: guard: p1.c != 3 -> true [assume p1.c != 3]. + Event p2.e: guard: p1.c = 1 and not p2.b -> true [assume p1.c = 1 and not p2.b]. + +Constructing output CIF specification. + +Checking output CIF specification. + +Writing output CIF file "datasynth/chaining_fixed_forward.ctrlsys.real.cif". diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.ctrlsys.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.ctrlsys.cif new file mode 100644 index 0000000000000000000000000000000000000000..6cef5a998d5c324df23bcce4e81a06efe981a60c --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.ctrlsys.cif @@ -0,0 +1,24 @@ +plant automaton p1: + controllable next; + disc int[0..3] c = 0; + location: + initial; + marked; + edge next when c < 3 do c := c + 1; +end +plant automaton p2: + controllable e; + disc bool b; + location: + initial; + marked; + edge e when p1.c = 1, not b do b := true; +end +supervisor automaton sup: + alphabet p1.next, p2.e; + location: + initial; + marked; + edge p1.next when true; + edge p2.e when true; +end diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.statespace.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.statespace.cif new file mode 100644 index 0000000000000000000000000000000000000000..d35b8315694a22ba2172a1c98eaca363360e1927 --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_fixed_forward.statespace.cif @@ -0,0 +1,37 @@ +group p1: + controllable next; +end +group p2: + controllable e; +end +automaton statespace: + alphabet p1.next, p2.e; + @state(p1: "*", p1.c: 0, p2: "*", p2.b: false, sup: "*") + location loc1: + initial; + marked; + edge p1.next goto loc2; + @state(p1: "*", p1.c: 1, p2: "*", p2.b: false, sup: "*") + location loc2: + marked; + edge p1.next goto loc3; + edge p2.e goto loc4; + @state(p1: "*", p1.c: 2, p2: "*", p2.b: false, sup: "*") + location loc3: + marked; + edge p1.next goto loc5; + @state(p1: "*", p1.c: 1, p2: "*", p2.b: true, sup: "*") + location loc4: + marked; + edge p1.next goto loc6; + @state(p1: "*", p1.c: 3, p2: "*", p2.b: false, sup: "*") + location loc5: + marked; + @state(p1: "*", p1.c: 2, p2: "*", p2.b: true, sup: "*") + location loc6: + marked; + edge p1.next goto loc7; + @state(p1: "*", p1.c: 3, p2: "*", p2.b: true, sup: "*") + location loc7: + marked; +end diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.cif new file mode 100644 index 0000000000000000000000000000000000000000..a783800aa4d81e996d2142d04aba259d3cf50403 --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.cif @@ -0,0 +1,32 @@ +////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2023, 2024 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available +// under the terms of the MIT License which is available at +// https://opensource.org/licenses/MIT +// +// SPDX-License-Identifier: MIT +////////////////////////////////////////////////////////////////////////////// + +plant p1: + controllable next; + disc int[0..3] c = 0; + + location: + initial; + marked; + edge next when c < 3 do c := c + 1; +end + +plant p2: + controllable e; + disc bool b; + + location: + initial; + marked; + edge e when p1.c = 1, not b do b := true; +end diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.cif.out new file mode 100644 index 0000000000000000000000000000000000000000..e24624db645dd0596a814130001a73a0f23bb805 --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.cif.out @@ -0,0 +1,268 @@ +Reading CIF file "datasynth/chaining_workset_forward.cif". + +Preprocessing CIF specification (includes checking that the specification is supported). + +Converting CIF specification to internal format (BDDs): + CIF variables and location pointers: + Nr Kind Type Name Group BDD vars CIF values BDD values Values used + ----- ----------------- --------- ---- ----- -------- ---------- ---------- ----------- + 1 discrete variable int[0..3] p1.c 0 2 * 2 4 * 2 4 * 2 100% + 2 discrete variable bool p2.b 1 1 * 2 2 * 2 2 * 2 100% + ----- ----------------- --------- ---- ----- -------- ---------- ---------- ----------- + Total 2 6 12 12 100% + + Applying variable ordering: + Applying 4 orderers, sequentially: + Applying model variable order: + Effect: both + + Applying DCSH algorithm: + Metric: wes + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Applying Weighted Cuthill-McKee algorithm: + Node finder: george-liu + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Found new best variable order. + + Applying Sloan algorithm: + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Applying 2 orderers, sequentially: + Applying Weighted Cuthill-McKee algorithm: + Node finder: george-liu + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Reversing the variable order: + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [reversed] + + Applying 2 orderers, sequentially: + Applying Sloan algorithm: + Relations: legacy + Effect: var-order + Number of graph edges: 1 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [after] + + Reversing the variable order: + Relations: legacy + Effect: var-order + Number of hyper-edges: 6 + + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [before] + Total span: 1 (total) 0.17 (avg/edge) / WES: 0.250000 (total) 0.041667 (avg/edge) [reversed] + + Applying FORCE algorithm: + Metric: total-span + Relations: linearized + Effect: var-order + Number of hyper-edges: 2 + Maximum number of iterations: 10 + + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] + + Applying sliding window algorithm: + Size: 4 + Metric: total-span + Relations: linearized + Effect: var-order + Number of hyper-edges: 2 + Window length: 2 + + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] + + Variable order unchanged. + +Starting data-based synthesis. + +Synthesis input: + Invariant (components state plant inv): true + Invariant (locations state plant invariant): true + Invariant (system state plant invariant): true + + Invariant (components state req invariant): true + Invariant (locations state req invariant): true + Invariant (system state req invariant): true + + Initial (discrete variable 0): p1.c = 0 + Initial (discrete variable 1): not p2.b + Initial (discrete variables): p1.c = 0 and not p2.b + Initial (components init predicate): true + Initial (aut/locs init predicate): true + Initial (aut/locs init predicate): true + Initial (auts/locs init predicate): true + Initial (uncontrolled system): p1.c = 0 and not p2.b + Initial (system, combined init/plant inv): p1.c = 0 and not p2.b + Initial (system, combined init/state inv): p1.c = 0 and not p2.b + + Marked (components marker predicate): true + Marked (aut/locs marker predicate): true + Marked (aut/locs marker predicate): true + Marked (auts/locs marker predicate): true + Marked (uncontrolled system): true + Marked (system, combined mark/plant inv): true + Marked (system, combined mark/state inv): true + + State/event exclusion plants: + None + + State/event exclusion requirements: + None + + Uncontrolled system: + State: (controlled-behavior: ?) + Edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1) + Edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true) + +Checking input for potential problems. + +Restricting edge guards to prevent runtime errors: + No guards changed. + +Restricting uncontrolled system behavior using state/event exclusion plant invariants: + No guards changed. + +Initializing edges for being applied. + +Restricting uncontrolled system behavior using state plant invariants: + No restrictions needed. + +Initializing controlled behavior: + Controlled-behavior predicate: true. + Controlled-initialization predicate: p1.c = 0 and not p2.b. + +Restricting behavior using state requirements: + Controlled behavior not changed. + +Extending controlled-behavior predicate using variable ranges: + Controlled behavior not changed. + +Restricting behavior using state/event exclusion requirements: + Guards and controlled behavior not changed. + +Restricting behavior using implicit runtime error requirements: + Controlled behavior not changed. + +Re-initializing edges for being applied. + +Checking pre-synthesis for events that are never enabled. + +Preparing workset algorithm: + Edge workset algorithm forward dependencies: + - 1: p1.next .1 + - 2: p2.e 1. + + Edge workset algorithm backward dependencies: + - 1: p1.next .1 + - 2: p2.e 1. + +Synthesis round 1: + Computing backward controlled-behavior predicate: + Backward controlled-behavior: true [marker predicate] + + Controlled behavior not changed. + + Computing backward uncontrolled bad-state predicate: + Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] + + Controlled behavior not changed. + + Computing forward controlled-behavior predicate: + Forward controlled-behavior: p1.c = 0 and not p2.b [initialization predicate] + + Forward controlled-behavior: p1.c = 0 and not p2.b -> (p1.c = 0 or p1.c = 1) and not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + Forward controlled-behavior: (p1.c = 0 or p1.c = 1) and not p2.b -> (p1.c = 0 or p1.c = 2) and not p2.b or p1.c = 1 and not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + Forward controlled-behavior: (p1.c = 0 or p1.c = 2) and not p2.b or p1.c = 1 and not p2.b -> not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + Forward controlled-behavior: not p2.b -> (p1.c = 1 or (p1.c = 3 or not p2.b)) and (p1.c != 3 or not p2.b) [forward reach with edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true), restricted to current/previous controlled-behavior predicate: true] + Forward controlled-behavior: (p1.c = 1 or (p1.c = 3 or not p2.b)) and (p1.c != 3 or not p2.b) -> (p1.c != 0 or not p2.b) and (p1.c != 3 or not p2.b) [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + Forward controlled-behavior: (p1.c != 0 or not p2.b) and (p1.c != 3 or not p2.b) -> p1.c != 0 or not p2.b [forward reach with edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1), restricted to current/previous controlled-behavior predicate: true] + + Forward controlled-behavior: p1.c != 0 or not p2.b [fixed point]. + + Controlled behavior: true -> p1.c != 0 or not p2.b. + + Need another round. + +Synthesis round 2: + Computing backward controlled-behavior predicate: + Backward controlled-behavior: true [marker predicate] + Backward controlled-behavior: true -> p1.c != 0 or not p2.b [restricted to current/previous controlled-behavior predicate: p1.c != 0 or not p2.b] + + Backward controlled-behavior: p1.c != 0 or not p2.b [fixed point]. + + Controlled behavior not changed. + + Computing backward uncontrolled bad-state predicate: + Backward uncontrolled bad-state: p1.c = 0 and p2.b [current/previous controlled behavior predicate] + + Controlled behavior not changed. + + Finished: controlled behavior is stable. + +Computing final controlled system guards: + No guards changed. + +Cleaning up cached predicate of edges that were used when applying edges. + +Final synthesis result: + State: (controlled-behavior: p1.c != 0 or not p2.b) + Edge: (event: p1.next) (guard: p1.c != 3) (assignments: p1.c := p1.c + 1) + Edge: (event: p2.e) (guard: p1.c = 1 and not p2.b) (assignments: p2.b := true) + +Computing initialization predicate of the controlled system. + +Controlled system: exactly 7 states. + +Determining initialization predicate for output model: + Initial (synthesis result): p1.c != 0 or not p2.b + Initial (uncontrolled system): p1.c = 0 and not p2.b + Initial (controlled system): p1.c = 0 and not p2.b + Initial (removed by supervisor): false + Initial (added by supervisor): true + + Initial (output model): n/a + +Determining supervisor guards for output model: + Event p1.next: guard: p1.c != 3. + Event p2.e: guard: p1.c = 1 and not p2.b. + +Checking post-synthesis for events that are never enabled. + +Simplifying supervisor guards for output model: + Simplification under the assumption of the plants. + + Event p1.next: guard: p1.c != 3 -> true [assume p1.c != 3]. + Event p2.e: guard: p1.c = 1 and not p2.b -> true [assume p1.c = 1 and not p2.b]. + +Constructing output CIF specification. + +Checking output CIF specification. + +Writing output CIF file "datasynth/chaining_workset_forward.ctrlsys.real.cif". diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.ctrlsys.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.ctrlsys.cif new file mode 100644 index 0000000000000000000000000000000000000000..6cef5a998d5c324df23bcce4e81a06efe981a60c --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.ctrlsys.cif @@ -0,0 +1,24 @@ +plant automaton p1: + controllable next; + disc int[0..3] c = 0; + location: + initial; + marked; + edge next when c < 3 do c := c + 1; +end +plant automaton p2: + controllable e; + disc bool b; + location: + initial; + marked; + edge e when p1.c = 1, not b do b := true; +end +supervisor automaton sup: + alphabet p1.next, p2.e; + location: + initial; + marked; + edge p1.next when true; + edge p2.e when true; +end diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.statespace.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.statespace.cif new file mode 100644 index 0000000000000000000000000000000000000000..d35b8315694a22ba2172a1c98eaca363360e1927 --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_forward.statespace.cif @@ -0,0 +1,37 @@ +group p1: + controllable next; +end +group p2: + controllable e; +end +automaton statespace: + alphabet p1.next, p2.e; + @state(p1: "*", p1.c: 0, p2: "*", p2.b: false, sup: "*") + location loc1: + initial; + marked; + edge p1.next goto loc2; + @state(p1: "*", p1.c: 1, p2: "*", p2.b: false, sup: "*") + location loc2: + marked; + edge p1.next goto loc3; + edge p2.e goto loc4; + @state(p1: "*", p1.c: 2, p2: "*", p2.b: false, sup: "*") + location loc3: + marked; + edge p1.next goto loc5; + @state(p1: "*", p1.c: 1, p2: "*", p2.b: true, sup: "*") + location loc4: + marked; + edge p1.next goto loc6; + @state(p1: "*", p1.c: 3, p2: "*", p2.b: false, sup: "*") + location loc5: + marked; + @state(p1: "*", p1.c: 2, p2: "*", p2.b: true, sup: "*") + location loc6: + marked; + edge p1.next goto loc7; + @state(p1: "*", p1.c: 3, p2: "*", p2.b: true, sup: "*") + location loc7: + marked; +end diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_edge_order_duplicate_events.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_edge_order_duplicate_events.cif similarity index 100% rename from cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_edge_order_duplicate_events.cif rename to cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_edge_order_duplicate_events.cif diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_edge_order_duplicate_events.cif.err b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_edge_order_duplicate_events.cif.err similarity index 100% rename from cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_edge_order_duplicate_events.cif.err rename to cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_edge_order_duplicate_events.cif.err diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_edge_order_duplicate_events.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_edge_order_duplicate_events.cif.out new file mode 100644 index 0000000000000000000000000000000000000000..38b5071f7031ea31353d5d9eae4496d49c621bbb --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_edge_order_duplicate_events.cif.out @@ -0,0 +1,6 @@ +Reading CIF file "datasynth/chaining_workset_with_edge_order_duplicate_events.cif". + +Preprocessing CIF specification (includes checking that the specification is supported). + +Converting CIF specification to internal format (BDDs): + The specification has no BDD variables. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_per_edge_edge_granularity.cif b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_per_edge_edge_granularity.cif similarity index 100% rename from cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_per_edge_edge_granularity.cif rename to cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_per_edge_edge_granularity.cif diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_per_edge_edge_granularity.cif.err b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_per_edge_edge_granularity.cif.err similarity index 100% rename from cif/org.eclipse.escet.cif.tests/tests/datasynth/workset_with_per_edge_edge_granularity.cif.err rename to cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_per_edge_edge_granularity.cif.err diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_per_edge_edge_granularity.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_per_edge_edge_granularity.cif.out new file mode 100644 index 0000000000000000000000000000000000000000..a2f209e70269fbed17cacf7bbbc9babe0eafd056 --- /dev/null +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/chaining_workset_with_per_edge_edge_granularity.cif.out @@ -0,0 +1,6 @@ +Reading CIF file "datasynth/chaining_workset_with_per_edge_edge_granularity.cif". + +Preprocessing CIF specification (includes checking that the specification is supported). + +Converting CIF specification to internal format (BDDs): + The specification has no BDD variables. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out index 803f7f3319c53d3bd29de3eac901f92adc500a58..d7be9015220a5b378ec7dfb6ad7176f2fee44ffc 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out @@ -199,9 +199,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -212,20 +209,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) -> (cnt.c = 0 or cnt.c = 1) and (rcv1.x = 0 and rcv2.x = 0) [forward reach with edge: (event: cnt.next) (guard: cnt.c != 3) (assignments: cnt.c := cnt.c + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (cnt.c = 0 or cnt.c = 1) and (rcv1.x = 0 and rcv2.x = 0) -> cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) [forward reach with edge: (event: e) (guard: cnt.c = 1 -> cnt.c = 1 and rcv1.x = 0 or (cnt.c = 1 and (rcv1.x = 2 and rcv2.x = 1) or cnt.c = 1 and ((rcv1.x = 1 or rcv1.x = 3) and rcv2.x = 1))) (assignments: rcv1.x := 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) -> cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0)) [forward reach with edge: (event: cnt.next) (guard: cnt.c != 3) (assignments: cnt.c := cnt.c + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0)) -> cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or (cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0) or cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0)) [forward reach with edge: (event: e) (guard: cnt.c = 2 -> cnt.c = 2 and rcv1.x = 0 or (cnt.c = 2 and (rcv1.x = 2 and rcv2.x = 1) or cnt.c = 2 and ((rcv1.x = 1 or rcv1.x = 3) and rcv2.x = 1))) (assignments: rcv2.x := 2), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or (cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0) or cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0)) -> cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0)) or (cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or (cnt.c = 3 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 3 and (rcv1.x = 1 and rcv2.x = 0))) [forward reach with edge: (event: cnt.next) (guard: cnt.c != 3) (assignments: cnt.c := cnt.c + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0)) or (cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or (cnt.c = 3 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 3 and (rcv1.x = 1 and rcv2.x = 0))) [fixed point]. Controlled behavior: true -> cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0)) or (cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or (cnt.c = 3 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 3 and (rcv1.x = 1 and rcv2.x = 0))). @@ -237,9 +220,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0)) or (cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or (cnt.c = 3 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 3 and (rcv1.x = 1 and rcv2.x = 0))) [restricted to current/previous controlled-behavior predicate: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0)) or (cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or (cnt.c = 3 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 3 and (rcv1.x = 1 and rcv2.x = 0)))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: cnt.c = 0 and (rcv1.x = 0 and rcv2.x = 0) or (cnt.c = 2 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 2 and (rcv1.x = 1 and rcv2.x = 0)) or (cnt.c = 1 and ((rcv1.x = 0 or rcv1.x = 1) and rcv2.x = 0) or (cnt.c = 3 and (rcv1.x = 0 and (rcv2.x = 0 or rcv2.x = 2)) or cnt.c = 3 and (rcv1.x = 1 and rcv2.x = 0))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out index a5a0a15bbdbd52c2f9600dc6f280cabcc34496b6..b3f4eca1e441ec5f01c124179dce887a838fc5c9 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out @@ -203,12 +203,6 @@ Synthesis round 1: Backward controlled-behavior: g.p.l0 [marker predicate] Backward controlled-behavior: g.p.l0 -> (g.p.x = 4 or g.p.x = 6) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) [restricted to current/previous controlled-behavior predicate: g.p.x = 4 or g.p.x = 6 or (g.p.x = 5 or (g.p.x = 3 and g.p.l0 or g.p.x = 7))] - Backward reachability iteration 1: - Backward controlled-behavior: (g.p.x = 4 or g.p.x = 6) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) -> g.p.x = 4 or g.p.x = 6 or (g.p.x = 5 or (g.p.x = 3 and g.p.l0 or g.p.x = 7)) [backward reach with edge: (event: u) (guard: g.p.l1 -> g.p.x = 8 and g.p.l1 or g.p.x = 4 and g.p.l1 or ((g.p.x = 2 or (g.p.x = 6 or g.p.x = 10)) and g.p.l1 or (g.p.x = 1 or g.p.x = 3 or (g.p.x = 5 or (g.p.x = 7 or g.p.x = 9))) and g.p.l1)) (assignments: g.p.x := g.p.x - 1, g.p := g.p.l0), restricted to current/previous controlled-behavior predicate: g.p.x = 4 or g.p.x = 6 or (g.p.x = 5 or (g.p.x = 3 and g.p.l0 or g.p.x = 7))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: g.p.x = 4 or g.p.x = 6 or (g.p.x = 5 or (g.p.x = 3 and g.p.l0 or g.p.x = 7)) [fixed point]. Controlled behavior not changed. @@ -216,21 +210,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: not(g.p.x = 4 or g.p.x = 6) and g.p.x != 5 and ((g.p.x != 3 or g.p.l1) and g.p.x != 7) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: (g.p.x = 0 or g.p.x = 2 or (g.p.x = 8 or g.p.x = 10)) and g.p.l0 or (g.p.x = 4 or g.p.x = 6) and g.p.l0 or ((g.p.x = 1 or g.p.x = 9) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0)) [initialization predicate] Forward controlled-behavior: (g.p.x = 0 or g.p.x = 2 or (g.p.x = 8 or g.p.x = 10)) and g.p.l0 or (g.p.x = 4 or g.p.x = 6) and g.p.l0 or ((g.p.x = 1 or g.p.x = 9) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0)) -> (g.p.x = 4 or g.p.x = 6) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) [restricted to current/previous controlled-behavior predicate: g.p.x = 4 or g.p.x = 6 or (g.p.x = 5 or (g.p.x = 3 and g.p.l0 or g.p.x = 7))] - Forward reachability iteration 1: - Forward controlled-behavior: (g.p.x = 4 or g.p.x = 6) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) -> g.p.x = 4 or g.p.x = 6 and g.p.l0 or (g.p.x = 5 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) [forward reach with edge: (event: c) (guard: g.p.l0 -> (g.p.x = 0 or g.p.x = 4) and g.p.l0 or (g.p.x = 2 and g.p.l0 or (g.p.x = 1 or g.p.x = 3) and g.p.l0)) (assignments: g.p.x := g.p.x + 1, g.p := g.p.l1), restricted to current/previous controlled-behavior predicate: g.p.x = 4 or g.p.x = 6 or (g.p.x = 5 or (g.p.x = 3 and g.p.l0 or g.p.x = 7))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: g.p.x = 4 or g.p.x = 6 and g.p.l0 or (g.p.x = 5 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) [fixed point]. Controlled behavior: g.p.x = 4 or g.p.x = 6 or (g.p.x = 5 or (g.p.x = 3 and g.p.l0 or g.p.x = 7)) -> g.p.x = 4 or g.p.x = 6 and g.p.l0 or (g.p.x = 5 or (g.p.x = 3 or g.p.x = 7) and g.p.l0). @@ -242,12 +227,6 @@ Synthesis round 2: Backward controlled-behavior: g.p.l0 [marker predicate] Backward controlled-behavior: g.p.l0 -> (g.p.x = 4 or g.p.x = 6) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) [restricted to current/previous controlled-behavior predicate: g.p.x = 4 or g.p.x = 6 and g.p.l0 or (g.p.x = 5 or (g.p.x = 3 or g.p.x = 7) and g.p.l0)] - Backward reachability iteration 1: - Backward controlled-behavior: (g.p.x = 4 or g.p.x = 6) and g.p.l0 or (g.p.x = 5 and g.p.l0 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) -> g.p.x = 4 or g.p.x = 6 and g.p.l0 or (g.p.x = 5 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) [backward reach with edge: (event: u) (guard: g.p.l1 -> g.p.x = 8 and g.p.l1 or g.p.x = 4 and g.p.l1 or ((g.p.x = 2 or (g.p.x = 6 or g.p.x = 10)) and g.p.l1 or (g.p.x = 1 or g.p.x = 3 or (g.p.x = 5 or (g.p.x = 7 or g.p.x = 9))) and g.p.l1)) (assignments: g.p.x := g.p.x - 1, g.p := g.p.l0), restricted to current/previous controlled-behavior predicate: g.p.x = 4 or g.p.x = 6 and g.p.l0 or (g.p.x = 5 or (g.p.x = 3 or g.p.x = 7) and g.p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: g.p.x = 4 or g.p.x = 6 and g.p.l0 or (g.p.x = 5 or (g.p.x = 3 or g.p.x = 7) and g.p.l0) [fixed point]. Controlled behavior not changed. @@ -255,9 +234,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: g.p.x != 4 and (g.p.x != 6 or g.p.l1) and (g.p.x != 5 and (not(g.p.x = 3 or g.p.x = 7) or g.p.l1)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out index 5c382714449377697f421cf8e6f85c8faec6c8ad..387ea7d8ae6b3c7a5b05972abd3ac89014a544ab 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out @@ -215,14 +215,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: motor1.Off and (order.l1 and motor2.On) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: motor1.Off and (order.l1 and motor2.On) -> motor1.Off and (order.l1 and motor2.On) or motor1.On and (order.l4 and motor2.On) [backward reach with edge: (event: motor1.c_off) (guard: motor1.On and order.l4) (assignments: motor1 := motor1.Off, order := order.l1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: motor1.Off and (order.l1 and motor2.On) or motor1.On and (order.l4 and motor2.On) -> motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and (order.l4 and motor2.On)) [backward reach with edge: (event: motor2.c_on) (guard: order.l3 and motor2.Off) (assignments: motor2 := motor2.On, order := order.l4), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and (order.l4 and motor2.On)) -> motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On)) [backward reach with edge: (event: motor2.c_off) (guard: order.l2 and motor2.On) (assignments: motor2 := motor2.Off, order := order.l3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On)) [fixed point]. Controlled behavior: true -> motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On)). @@ -235,16 +227,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: motor1.Off and (order.l1 and motor2.On) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: motor1.Off and (order.l1 and motor2.On) -> motor1.Off and (order.l1 and motor2.On) or motor1.On and (order.l2 and motor2.On) [forward reach with edge: (event: motor1.c_on) (guard: motor1.Off and order.l1) (assignments: motor1 := motor1.On, order := order.l2), restricted to current/previous controlled-behavior predicate: motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On))] - Forward controlled-behavior: motor1.Off and (order.l1 and motor2.On) or motor1.On and (order.l2 and motor2.On) -> motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and (order.l2 and motor2.On)) [forward reach with edge: (event: motor2.c_off) (guard: order.l2 and motor2.On) (assignments: motor2 := motor2.Off, order := order.l3), restricted to current/previous controlled-behavior predicate: motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On))] - - Forward reachability iteration 2: - Forward controlled-behavior: motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and (order.l2 and motor2.On)) -> motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On)) [forward reach with edge: (event: motor2.c_on) (guard: order.l3 and motor2.Off) (assignments: motor2 := motor2.On, order := order.l4), restricted to current/previous controlled-behavior predicate: motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On))] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: motor1.Off and (order.l1 and motor2.On) or (motor1.On and (order.l3 and motor2.Off) or motor1.On and ((order.l2 or order.l4) and motor2.On)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out index bb06ccd9b7ea626d76c90726ee1b251d73971405..5d94712e5b9f1840e9dde492d3457591ec34181a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out @@ -226,57 +226,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) -> p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) or p2.neither and f2.taken and (f3.available and p1.both) and (f1.taken and p3.neither and (f4.available and p4.neither)) [backward reach with edge: (event: p1.release_both) (guard: f2.taken and (p1.both and f1.taken)) (assignments: f1 := f1.available, f2 := f2.available, p1 := p1.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) or p2.neither and f2.taken and (f3.available and p1.both) and (f1.taken and p3.neither and (f4.available and p4.neither)) -> <bdd 21n 3p> [backward reach with edge: (event: p4.release_both) (guard: f1.taken and (f4.taken and p4.both)) (assignments: f1 := f1.available, f4 := f4.available, p4 := p4.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 21n 3p> -> <bdd 22n 4p> [backward reach with edge: (event: p1.take_right) (guard: f2.available and p1.left) (assignments: f2 := f2.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 22n 4p> -> <bdd 25n 7p> [backward reach with edge: (event: p2.release_both) (guard: p2.both and (f2.taken and f3.taken)) (assignments: f2 := f2.available, f3 := f3.available, p2 := p2.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 25n 7p> -> <bdd 26n 10p> [backward reach with edge: (event: p2.take_right) (guard: p2.left and f3.available) (assignments: f3 := f3.taken, p2 := p2.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 26n 10p> -> <bdd 36n 15p> [backward reach with edge: (event: p3.release_both) (guard: f3.taken and (p3.both and f4.taken)) (assignments: f3 := f3.available, f4 := f4.available, p3 := p3.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 36n 15p> -> <bdd 37n 18p> [backward reach with edge: (event: p4.take_left) (guard: f4.available and p4.right) (assignments: f4 := f4.taken, p4 := p4.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 37n 18p> -> <bdd 37n 23p> [backward reach with edge: (event: p3.take_right) (guard: p3.left and f4.available) (assignments: f4 := f4.taken, p3 := p3.both), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: <bdd 37n 23p> -> <bdd 40n 26p> [backward reach with edge: (event: p1.take_left) (guard: p1.right and f1.available) (assignments: f1 := f1.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 40n 26p> -> <bdd 44n 29p> [backward reach with edge: (event: p4.take_right) (guard: f1.available and p4.left) (assignments: f1 := f1.taken, p4 := p4.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 44n 29p> -> <bdd 45n 30p> [backward reach with edge: (event: p1.release_both) (guard: f2.taken and (p1.both and f1.taken)) (assignments: f1 := f1.available, f2 := f2.available, p1 := p1.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 45n 30p> -> <bdd 49n 34p> [backward reach with edge: (event: p4.release_both) (guard: f1.taken and (f4.taken and p4.both)) (assignments: f1 := f1.available, f4 := f4.available, p4 := p4.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 49n 34p> -> <bdd 50n 39p> [backward reach with edge: (event: p2.take_left) (guard: p2.right and f2.available) (assignments: f2 := f2.taken, p2 := p2.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 50n 39p> -> <bdd 53n 40p> [backward reach with edge: (event: p1.take_right) (guard: f2.available and p1.left) (assignments: f2 := f2.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 53n 40p> -> <bdd 54n 41p> [backward reach with edge: (event: p2.release_both) (guard: p2.both and (f2.taken and f3.taken)) (assignments: f2 := f2.available, f3 := f3.available, p2 := p2.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 54n 41p> -> <bdd 65n 47p> [backward reach with edge: (event: p3.take_left) (guard: f3.available and p3.right) (assignments: f3 := f3.taken, p3 := p3.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 65n 47p> -> <bdd 61n 48p> [backward reach with edge: (event: p2.take_right) (guard: p2.left and f3.available) (assignments: f3 := f3.taken, p2 := p2.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 61n 48p> -> <bdd 65n 50p> [backward reach with edge: (event: p3.release_both) (guard: f3.taken and (p3.both and f4.taken)) (assignments: f3 := f3.available, f4 := f4.available, p3 := p3.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 65n 50p> -> <bdd 62n 54p> [backward reach with edge: (event: p4.take_left) (guard: f4.available and p4.right) (assignments: f4 := f4.taken, p4 := p4.both), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: <bdd 62n 54p> -> <bdd 60n 55p> [backward reach with edge: (event: p1.take_left) (guard: p1.right and f1.available) (assignments: f1 := f1.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 60n 55p> -> <bdd 61n 58p> [backward reach with edge: (event: p4.take_right) (guard: f1.available and p4.left) (assignments: f1 := f1.taken, p4 := p4.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 61n 58p> -> <bdd 65n 61p> [backward reach with edge: (event: p1.release_both) (guard: f2.taken and (p1.both and f1.taken)) (assignments: f1 := f1.available, f2 := f2.available, p1 := p1.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 65n 61p> -> <bdd 59n 62p> [backward reach with edge: (event: p2.take_left) (guard: p2.right and f2.available) (assignments: f2 := f2.taken, p2 := p2.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 59n 62p> -> <bdd 62n 63p> [backward reach with edge: (event: p1.take_right) (guard: f2.available and p1.left) (assignments: f2 := f2.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 62n 63p> -> <bdd 63n 65p> [backward reach with edge: (event: p2.release_both) (guard: p2.both and (f2.taken and f3.taken)) (assignments: f2 := f2.available, f3 := f3.available, p2 := p2.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 63n 65p> -> <bdd 67n 67p> [backward reach with edge: (event: p3.take_left) (guard: f3.available and p3.right) (assignments: f3 := f3.taken, p3 := p3.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 67n 67p> -> <bdd 65n 68p> [backward reach with edge: (event: p3.release_both) (guard: f3.taken and (p3.both and f4.taken)) (assignments: f3 := f3.available, f4 := f4.available, p3 := p3.neither), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: <bdd 65n 68p> -> <bdd 67n 70p> [backward reach with edge: (event: p1.take_left) (guard: p1.right and f1.available) (assignments: f1 := f1.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 67n 70p> -> <bdd 70n 71p> [backward reach with edge: (event: p4.release_both) (guard: f1.taken and (f4.taken and p4.both)) (assignments: f1 := f1.available, f4 := f4.available, p4 := p4.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 70n 71p> -> <bdd 65n 73p> [backward reach with edge: (event: p2.take_left) (guard: p2.right and f2.available) (assignments: f2 := f2.taken, p2 := p2.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 65n 73p> -> <bdd 66n 74p> [backward reach with edge: (event: p2.release_both) (guard: p2.both and (f2.taken and f3.taken)) (assignments: f2 := f2.available, f3 := f3.available, p2 := p2.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 66n 74p> -> <bdd 66n 75p> [backward reach with edge: (event: p3.take_left) (guard: f3.available and p3.right) (assignments: f3 := f3.taken, p3 := p3.both), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 66n 75p> -> <bdd 63n 76p> [backward reach with edge: (event: p4.take_left) (guard: f4.available and p4.right) (assignments: f4 := f4.taken, p4 := p4.both), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 63n 76p> -> <bdd 61n 77p> [backward reach with edge: (event: p1.release_both) (guard: f2.taken and (p1.both and f1.taken)) (assignments: f1 := f1.available, f2 := f2.available, p1 := p1.neither), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 61n 77p> -> <bdd 57n 78p> [backward reach with edge: (event: p2.take_left) (guard: p2.right and f2.available) (assignments: f2 := f2.taken, p2 := p2.both), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: <bdd 57n 78p> -> <bdd 55n 79p> [backward reach with edge: (event: p1.take_left) (guard: p1.right and f1.available) (assignments: f1 := f1.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - No change this iteration. - Backward controlled-behavior: <bdd 55n 79p> [fixed point]. Controlled behavior: true -> <bdd 55n 79p>. @@ -289,23 +238,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) -> p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) or p2.neither and f2.available and (f3.available and p1.left) and (f1.taken and p3.neither and (f4.available and p4.neither)) [forward reach with edge: (event: p1.take_left) (guard: p1.neither and f1.available) (assignments: f1 := f1.taken, p1 := p1.left), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) or p2.neither and f2.available and (f3.available and p1.left) and (f1.taken and p3.neither and (f4.available and p4.neither)) -> p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) or (p2.neither and f2.available and (f3.available and p1.neither) and (f1.taken and p3.neither and (f4.available and p4.right)) or p2.neither and f2.available and (f3.available and p1.left) and (f1.taken and p3.neither and (f4.available and p4.neither))) [forward reach with edge: (event: p4.take_right) (guard: f1.available and p4.neither) (assignments: f1 := f1.taken, p4 := p4.right), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: p2.neither and f2.available and (f3.available and p1.neither) and (f1.available and p3.neither and (f4.available and p4.neither)) or (p2.neither and f2.available and (f3.available and p1.neither) and (f1.taken and p3.neither and (f4.available and p4.right)) or p2.neither and f2.available and (f3.available and p1.left) and (f1.taken and p3.neither and (f4.available and p4.neither))) -> <bdd 21n 6p> [forward reach with edge: (event: p2.take_left) (guard: p2.neither and f2.available) (assignments: f2 := f2.taken, p2 := p2.left), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 21n 6p> -> <bdd 24n 8p> [forward reach with edge: (event: p1.take_right) (guard: f2.available and p1.neither) (assignments: f2 := f2.taken, p1 := p1.right), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 24n 8p> -> <bdd 25n 9p> [forward reach with edge: (event: p1.take_right) (guard: f2.available and p1.left) (assignments: f2 := f2.taken, p1 := p1.both), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 25n 9p> -> <bdd 35n 18p> [forward reach with edge: (event: p3.take_left) (guard: f3.available and p3.neither) (assignments: f3 := f3.taken, p3 := p3.left), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 35n 18p> -> <bdd 38n 24p> [forward reach with edge: (event: p2.take_right) (guard: p2.neither and f3.available) (assignments: f3 := f3.taken, p2 := p2.right), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 38n 24p> -> <bdd 39n 27p> [forward reach with edge: (event: p2.take_right) (guard: p2.left and f3.available) (assignments: f3 := f3.taken, p2 := p2.both), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 39n 27p> -> <bdd 47n 44p> [forward reach with edge: (event: p4.take_left) (guard: f4.available and p4.neither) (assignments: f4 := f4.taken, p4 := p4.left), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 47n 44p> -> <bdd 48n 53p> [forward reach with edge: (event: p4.take_left) (guard: f4.available and p4.right) (assignments: f4 := f4.taken, p4 := p4.both), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 48n 53p> -> <bdd 56n 70p> [forward reach with edge: (event: p3.take_right) (guard: p3.neither and f4.available) (assignments: f4 := f4.taken, p3 := p3.right), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - Forward controlled-behavior: <bdd 56n 70p> -> <bdd 55n 79p> [forward reach with edge: (event: p3.take_right) (guard: p3.left and f4.available) (assignments: f4 := f4.taken, p3 := p3.both), restricted to current/previous controlled-behavior predicate: <bdd 55n 79p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 55n 79p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out index 79fc2ad79de788e14876abdc4f4cf6f543b1782d..9a2845eaac06f5ecf7f93bf4bfd8447e9d8f96c1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out @@ -243,33 +243,6 @@ Synthesis round 1: Backward controlled-behavior: (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and p.x = 7) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))))) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and p.x = 7) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 18 or p.y = 19) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)))))) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 18 or p.y = 19) and (p.m3 and p.x = 7) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 10 or p.y = 11) and (p.m3 and (p.x = 3 or p.x = 11)))) or ((p.y = 10 or p.y = 11) and (p.m3 and p.x = 7) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and p.x = 7))))) [marker predicate] Backward controlled-behavior: (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and p.x = 7) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))))) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and p.x = 7) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 18 or p.y = 19) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)))))) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 18 or p.y = 19) and (p.m3 and p.x = 7) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 10 or p.y = 11) and (p.m3 and (p.x = 3 or p.x = 11)))) or ((p.y = 10 or p.y = 11) and (p.m3 and p.x = 7) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and p.x = 7))))) -> <bdd 18n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - Backward reachability iteration 1: - Backward controlled-behavior: <bdd 18n 44p> -> <bdd 21n 77p> [backward reach with edge: (event: u) (guard: p.m2 -> not p.m0 and (not p.t1 and not p.t5) and (not p.b4 and (not p.b2 and not p.t3)) and (not p.m1 and (not p.m3 and not p.t2) and (not p.t4 and (not p.b1 and not p.b3)))) (assignments: p.x := p.x + 1, p := p.m3), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - - Backward reachability iteration 2: - Backward controlled-behavior: <bdd 21n 77p> -> <bdd 24n 132p> [backward reach with edge: (event: u) (guard: p.m1 -> (p.m1 or (p.m3 or p.t2) or (p.t4 or (p.b1 or p.b3))) and (not p.b1 and not p.t2) and (not p.m3 and (not p.t4 and not p.b3))) (assignments: p.x := p.x + 1, p := p.m2), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - Backward controlled-behavior: <bdd 24n 132p> -> <bdd 31n 199p> [backward reach with edge: (event: u) (guard: p.t5 -> p.y = 16 and p.t5 or p.y = 8 and p.t5 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.t5 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.t5 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.t5))) (assignments: p.y := p.y - 1, p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - Backward controlled-behavior: <bdd 31n 199p> -> <bdd 51n 331p> [backward reach with edge: (event: u) (guard: p.b4 -> <bdd 12n 21p>) (assignments: p.x := p.x - 4, p.y := p.y + 3, p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - - Backward reachability iteration 3: - Backward controlled-behavior: <bdd 51n 331p> -> <bdd 51n 336p> [backward reach with edge: (event: u) (guard: p.m0) (assignments: p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - Backward controlled-behavior: <bdd 51n 336p> -> <bdd 59n 451p> [backward reach with edge: (event: u) (guard: p.t4 -> <bdd 14n 25p>) (assignments: p.x := p.x - 1, p.y := p.y - 1, p := p.t5), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - Backward controlled-behavior: <bdd 59n 451p> -> <bdd 68n 556p> [backward reach with edge: (event: u) (guard: p.b3 -> p.y = 16 and p.b3 or p.y = 8 and p.b3 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.b3 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.b3 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.b3))) (assignments: p.y := p.y - 1, p := p.b4), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - - Backward reachability iteration 4: - Backward controlled-behavior: <bdd 68n 556p> -> <bdd 73n 616p> [backward reach with edge: (event: u) (guard: p.t3 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y - 1, p := p.t4), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - Backward controlled-behavior: <bdd 73n 616p> -> <bdd 81n 691p> [backward reach with edge: (event: u) (guard: p.b2 -> not p.m0 and (not p.t1 and not p.t5) and (not p.b4 and (not p.m2 and not p.t3)) and (not p.m1 and (not p.m3 and not p.t2) and (not p.t4 and (not p.b1 and not p.b3)))) (assignments: p.x := p.x + 1, p := p.b3), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 81n 691p> -> <bdd 84n 691p> [backward reach with edge: (event: u) (guard: p.t2 -> p.y = 16 and p.t2 or p.y = 8 and p.t2 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.t2 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.t2 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.t2))) (assignments: p.y := p.y - 1, p := p.t3), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - Backward controlled-behavior: <bdd 84n 691p> -> <bdd 93n 846p> [backward reach with edge: (event: u) (guard: p.b1 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y - 1, p := p.b2), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - - Backward reachability iteration 6: - Backward controlled-behavior: <bdd 93n 846p> -> <bdd 98n 868p> [backward reach with edge: (event: u) (guard: p.t1 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y + 1, p := p.t2), restricted to current/previous controlled-behavior predicate: <bdd 35n 802p>] - - Backward reachability iteration 7: - No change this iteration. - Backward controlled-behavior: <bdd 98n 868p> [fixed point]. Controlled behavior: <bdd 35n 802p> -> <bdd 98n 868p>. @@ -277,34 +250,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 98n 1,276p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: <bdd 14n 64p> [initialization predicate] Forward controlled-behavior: <bdd 14n 64p> -> <bdd 18n 55p> [restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward reachability iteration 1: - Forward controlled-behavior: <bdd 18n 55p> -> <bdd 17n 55p> [forward reach with edge: (event: u) (guard: p.m0) (assignments: p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 17n 55p> -> <bdd 25n 187p> [forward reach with edge: (event: u) (guard: p.m1 -> (p.m1 or (p.m3 or p.t2) or (p.t4 or (p.b1 or p.b3))) and (not p.b1 and not p.t2) and (not p.m3 and (not p.t4 and not p.b3))) (assignments: p.x := p.x + 1, p := p.m2), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 25n 187p> -> <bdd 29n 264p> [forward reach with edge: (event: u) (guard: p.m2 -> not p.m0 and (not p.t1 and not p.t5) and (not p.b4 and (not p.b2 and not p.t3)) and (not p.m1 and (not p.m3 and not p.t2) and (not p.t4 and (not p.b1 and not p.b3)))) (assignments: p.x := p.x + 1, p := p.m3), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 29n 264p> -> <bdd 41n 404p> [forward reach with edge: (event: c1) (guard: p.m2 -> not p.m0 and (not p.t1 and not p.t5) and (not p.b4 and (not p.b2 and not p.t3)) and (not p.m1 and (not p.m3 and not p.t2) and (not p.t4 and (not p.b1 and not p.b3)))) (assignments: p.x := p.x + 1, p := p.t1), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 41n 404p> -> <bdd 50n 509p> [forward reach with edge: (event: c2) (guard: p.m2 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y - 1, p := p.b1), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - - Forward reachability iteration 2: - Forward controlled-behavior: <bdd 50n 509p> -> <bdd 59n 597p> [forward reach with edge: (event: u) (guard: p.t1 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y + 1, p := p.t2), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 59n 597p> -> <bdd 60n 685p> [forward reach with edge: (event: u) (guard: p.t2 -> p.y = 16 and p.t2 or p.y = 8 and p.t2 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.t2 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.t2 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.t2))) (assignments: p.y := p.y - 1, p := p.t3), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 60n 685p> -> <bdd 70n 729p> [forward reach with edge: (event: u) (guard: p.t3 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y - 1, p := p.t4), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 70n 729p> -> <bdd 80n 817p> [forward reach with edge: (event: u) (guard: p.t4 -> <bdd 14n 25p>) (assignments: p.x := p.x - 1, p.y := p.y - 1, p := p.t5), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 80n 817p> -> <bdd 90n 892p> [forward reach with edge: (event: u) (guard: p.b1 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y - 1, p := p.b2), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 90n 892p> -> <bdd 100n 997p> [forward reach with edge: (event: u) (guard: p.b2 -> not p.m0 and (not p.t1 and not p.t5) and (not p.b4 and (not p.m2 and not p.t3)) and (not p.m1 and (not p.m3 and not p.t2) and (not p.t4 and (not p.b1 and not p.b3)))) (assignments: p.x := p.x + 1, p := p.b3), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - Forward controlled-behavior: <bdd 100n 997p> -> <bdd 105n 1,102p> [forward reach with edge: (event: u) (guard: p.b3 -> p.y = 16 and p.b3 or p.y = 8 and p.b3 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.b3 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.b3 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.b3))) (assignments: p.y := p.y - 1, p := p.b4), restricted to current/previous controlled-behavior predicate: <bdd 98n 868p>] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: <bdd 105n 1,102p> [fixed point]. Controlled behavior: <bdd 98n 868p> -> <bdd 105n 1,102p>. @@ -316,33 +267,6 @@ Synthesis round 2: Backward controlled-behavior: (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and p.x = 7) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))))) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and p.x = 7) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 18 or p.y = 19) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)))))) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 18 or p.y = 19) and (p.m3 and p.x = 7) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 10 or p.y = 11) and (p.m3 and (p.x = 3 or p.x = 11)))) or ((p.y = 10 or p.y = 11) and (p.m3 and p.x = 7) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and p.x = 7))))) [marker predicate] Backward controlled-behavior: (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 16 or (p.y = 17 or p.y = 20)) and (p.m3 and p.x = 7) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))))) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and (p.x = 3 or p.x = 11)) or ((p.y = 8 or p.y = 9 or (p.y = 12 or p.y = 13)) and (p.m3 and p.x = 7) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or (p.y = 18 or p.y = 19) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)))))) or ((p.y = 18 or p.y = 19) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 18 or p.y = 19) and (p.m3 and p.x = 7) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 10 or p.y = 11) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.y = 10 or p.y = 11) and (p.m3 and (p.x = 3 or p.x = 11)))) or ((p.y = 10 or p.y = 11) and (p.m3 and p.x = 7) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14)))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or ((p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and (p.x = 3 or p.x = 11)) or (p.y = 6 or p.y = 7 or (p.y = 14 or p.y = 15)) and (p.m3 and p.x = 7))))) -> <bdd 21n 77p> [restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - Backward reachability iteration 1: - Backward controlled-behavior: <bdd 21n 77p> -> <bdd 26n 154p> [backward reach with edge: (event: u) (guard: p.m2 -> not p.m0 and (not p.t1 and not p.t5) and (not p.b4 and (not p.b2 and not p.t3)) and (not p.m1 and (not p.m3 and not p.t2) and (not p.t4 and (not p.b1 and not p.b3)))) (assignments: p.x := p.x + 1, p := p.m3), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - - Backward reachability iteration 2: - Backward controlled-behavior: <bdd 26n 154p> -> <bdd 29n 209p> [backward reach with edge: (event: u) (guard: p.m1 -> (p.m1 or (p.m3 or p.t2) or (p.t4 or (p.b1 or p.b3))) and (not p.b1 and not p.t2) and (not p.m3 and (not p.t4 and not p.b3))) (assignments: p.x := p.x + 1, p := p.m2), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - Backward controlled-behavior: <bdd 29n 209p> -> <bdd 43n 346p> [backward reach with edge: (event: u) (guard: p.t5 -> p.y = 16 and p.t5 or p.y = 8 and p.t5 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.t5 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.t5 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.t5))) (assignments: p.y := p.y - 1, p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - Backward controlled-behavior: <bdd 43n 346p> -> <bdd 57n 444p> [backward reach with edge: (event: u) (guard: p.b4 -> <bdd 12n 21p>) (assignments: p.x := p.x - 4, p.y := p.y + 3, p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - - Backward reachability iteration 3: - Backward controlled-behavior: <bdd 57n 444p> -> <bdd 58n 514p> [backward reach with edge: (event: u) (guard: p.m0) (assignments: p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - Backward controlled-behavior: <bdd 58n 514p> -> <bdd 65n 597p> [backward reach with edge: (event: u) (guard: p.t4 -> <bdd 14n 25p>) (assignments: p.x := p.x - 1, p.y := p.y - 1, p := p.t5), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - Backward controlled-behavior: <bdd 65n 597p> -> <bdd 73n 702p> [backward reach with edge: (event: u) (guard: p.b3 -> p.y = 16 and p.b3 or p.y = 8 and p.b3 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.b3 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.b3 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.b3))) (assignments: p.y := p.y - 1, p := p.b4), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - - Backward reachability iteration 4: - Backward controlled-behavior: <bdd 73n 702p> -> <bdd 81n 790p> [backward reach with edge: (event: u) (guard: p.t3 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y - 1, p := p.t4), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - Backward controlled-behavior: <bdd 81n 790p> -> <bdd 89n 865p> [backward reach with edge: (event: u) (guard: p.b2 -> not p.m0 and (not p.t1 and not p.t5) and (not p.b4 and (not p.m2 and not p.t3)) and (not p.m1 and (not p.m3 and not p.t2) and (not p.t4 and (not p.b1 and not p.b3)))) (assignments: p.x := p.x + 1, p := p.b3), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 89n 865p> -> <bdd 93n 953p> [backward reach with edge: (event: u) (guard: p.t2 -> p.y = 16 and p.t2 or p.y = 8 and p.t2 or ((p.y = 4 or (p.y = 12 or p.y = 20)) and p.t2 or ((p.y = 2 or p.y = 6 or (p.y = 10 or (p.y = 14 or p.y = 18))) and p.t2 or (p.y = 1 or p.y = 3 or (p.y = 5 or (p.y = 7 or p.y = 9)) or (p.y = 11 or p.y = 13 or (p.y = 15 or (p.y = 17 or p.y = 19)))) and p.t2))) (assignments: p.y := p.y - 1, p := p.t3), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - Backward controlled-behavior: <bdd 93n 953p> -> <bdd 101n 1,058p> [backward reach with edge: (event: u) (guard: p.b1 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y - 1, p := p.b2), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - - Backward reachability iteration 6: - Backward controlled-behavior: <bdd 101n 1,058p> -> <bdd 105n 1,102p> [backward reach with edge: (event: u) (guard: p.t1 -> <bdd 14n 25p>) (assignments: p.x := p.x + 1, p.y := p.y + 1, p := p.t2), restricted to current/previous controlled-behavior predicate: <bdd 105n 1,102p>] - - Backward reachability iteration 7: - No change this iteration. - Backward controlled-behavior: <bdd 105n 1,102p> [fixed point]. Controlled behavior not changed. @@ -350,9 +274,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 105n 1,744p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_edge.cif.out index 1580f98aedc999494007fd3f1cd8f14088a59894..531b2820820d940c50f0865bc1da32a78e70d810 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_edge.cif.out @@ -194,12 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l2) and (p.x != 7 or p.l2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior not changed. @@ -207,22 +201,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 0 and p.l1 or p.x = 7 and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) [restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l2) and (p.x != 7 or p.l2)] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) -> p.x != 0 and ((p.x != 1 or p.l1) and (p.x != 7 or p.l2)) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l2) and (p.x != 7 or p.l2)] - Forward controlled-behavior: p.x != 0 and ((p.x != 1 or p.l1) and (p.x != 7 or p.l2)) -> (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [forward reach with edge: (event: e) (guard: p.l1 -> p.x = 4 and p.l1 or ((p.x = 2 or p.x = 6) and p.l1 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l1)) (assignments: p.x := p.x - 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l2) and (p.x != 7 or p.l2)] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_event.cif.out index 54451885c5beabf216d3aa96c2524792cad07df3..af0d21daede7aaf8966e0a903f9a2d1e829dd2ca 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors01_per_event.cif.out @@ -186,12 +186,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [backward reach with edge: (event: e) (guard: p.l1) (assignments: p.x := p.x + 1, p := p.l2 / p.x := p.x - 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l2) and (p.x != 7 or p.l2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior not changed. @@ -199,21 +193,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 0 and p.l1 or p.x = 7 and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) [restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l2) and (p.x != 7 or p.l2)] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 4 and p.l1 or (p.x = 2 or p.x = 6) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) -> (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [forward reach with edge: (event: e) (guard: p.l1) (assignments: p.x := p.x + 1, p := p.l2 / p.x := p.x - 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l2) and (p.x != 7 or p.l2)] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x != 0 or p.l2) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_edge.cif.out index f133ebdc0531da6bf29ebff40efed58737e0cbc4..5dba5a346982aaebbdef6a1493d18036fbbc6465 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_edge.cif.out @@ -194,12 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> 0 <= p.x and p.x <= 5 or p.l2 [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: 0 <= p.x and p.x <= 5 or p.l2 [fixed point]. Controlled behavior not changed. @@ -207,22 +201,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 6 or p.x = 7) and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1 or (p.x = 4 or p.x = 5)) and p.l1 or (p.x = 2 or p.x = 3) and p.l1 [restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1 or (p.x = 4 or p.x = 5)) and p.l1 or (p.x = 2 or p.x = 3) and p.l1 -> (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and p.x != 7) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - Forward controlled-behavior: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and p.x != 7) -> (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 1 or (p.x = 4 or p.x = 5)) and p.l1 or (p.x = 2 or p.x = 3) and p.l1) (assignments: p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [fixed point]. Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)). @@ -234,12 +218,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) [restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) -> (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [fixed point]. Controlled behavior not changed. @@ -247,9 +225,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 0 and p.l2 or (p.x = 6 and p.l1 or p.x = 7 and p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_event.cif.out index b8956a2cb9466c4e4b971c14b68b61aab14da5e8..327974014a4706283ab5572137e1f3c57c84ec7f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors02_per_event.cif.out @@ -190,12 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> 0 <= p.x and p.x <= 5 or p.l2 [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2 / p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: 0 <= p.x and p.x <= 5 or p.l2 [fixed point]. Controlled behavior not changed. @@ -203,21 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 6 or p.x = 7) and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1 or (p.x = 4 or p.x = 5)) and p.l1 or (p.x = 2 or p.x = 3) and p.l1 [restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1 or (p.x = 4 or p.x = 5)) and p.l1 or (p.x = 2 or p.x = 3) and p.l1 -> (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2 / p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [fixed point]. Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)). @@ -229,12 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) [restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) -> (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2 / p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or p.l1) and ((p.x != 6 or p.l2) and (p.x != 7 or p.l2)) [fixed point]. Controlled behavior not changed. @@ -242,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 0 and p.l2 or (p.x = 6 and p.l1 or p.x = 7 and p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_edge.cif.out index eb2a0fe04177054c9643574fef59ee2c24f526b2..50c620f2ee2c3d2605ca38c66ed245f45e41fbfd 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_edge.cif.out @@ -192,12 +192,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> p.x != 7 or p.l2 [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x != 7 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x != 7 or p.l2 [fixed point]. Controlled behavior not changed. @@ -205,21 +199,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 7 and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) [restricted to current/previous controlled-behavior predicate: p.x != 7 or p.l2] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) -> (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x != 7 or p.l2] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior: p.x != 7 or p.l2 -> (p.x != 0 or p.l1) and (p.x != 7 or p.l2). @@ -231,12 +216,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) [restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and (p.x != 7 or p.l2)] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) -> (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and (p.x != 7 or p.l2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior not changed. @@ -244,9 +223,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 0 and p.l2 or p.x = 7 and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_event.cif.out index ea1258c329f52b03db23596048f05d4a72597d03..108bc9892b285cb339e255390067b61bc1b6d0c9 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors03_per_event.cif.out @@ -186,12 +186,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> p.x != 7 or p.l2 [backward reach with edge: (event: e) (guard: p.l1) (assignments: p.x := p.x + 1, p := p.l2 / p.x := 5, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x != 7 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x != 7 or p.l2 [fixed point]. Controlled behavior not changed. @@ -199,21 +193,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 7 and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) [restricted to current/previous controlled-behavior predicate: p.x != 7 or p.l2] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) -> (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [forward reach with edge: (event: e) (guard: p.l1) (assignments: p.x := p.x + 1, p := p.l2 / p.x := 5, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x != 7 or p.l2] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior: p.x != 7 or p.l2 -> (p.x != 0 or p.l1) and (p.x != 7 or p.l2). @@ -225,12 +210,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) [restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and (p.x != 7 or p.l2)] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 4 and p.l2 or ((p.x = 2 or p.x = 6) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2) -> (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [backward reach with edge: (event: e) (guard: p.l1) (assignments: p.x := p.x + 1, p := p.l2 / p.x := 5, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or p.l1) and (p.x != 7 or p.l2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or p.l1) and (p.x != 7 or p.l2) [fixed point]. Controlled behavior not changed. @@ -238,9 +217,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 0 and p.l2 or p.x = 7 and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_edge.cif.out index 29344c56c590b3573391b42525053b48a957b533..4238bd463437dfe61ab34038e8cfd900249f22ca 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_edge.cif.out @@ -193,9 +193,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: p.x != 7 or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_event.cif.out index 29059f5fd5f1091490a2628df5b1378d2bb9f05d..7f4c297b22237dbcdcca9a030cee20d9e5589f0d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors04_per_event.cif.out @@ -190,9 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: p.x != 7 or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_edge.cif.out index db92f819f2dc32bbe347220aeca12ab1b6d2323a..aff578ab78ee61a747c10d75015a8937c281b657 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_edge.cif.out @@ -193,9 +193,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: p.x != 7 or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_event.cif.out index ffe47fac92bfa90b05a7c5473da4450fdd2ac15b..b9f55e048e5a07c6a047949114b87705e29780fd 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors05_per_event.cif.out @@ -190,9 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: p.x != 7 or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_edge.cif.out index d972647a4fa17d8931d3c9014522dbf58532c865..6717c2714dd741570cda38c44c82248823955295 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_edge.cif.out @@ -194,9 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_event.cif.out index 0eb45d0861d8896be21ac81a0ea62756381cea4c..fbf1b458f7176396599c7a22a0b0b79c5a3c72ff 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors06_per_event.cif.out @@ -190,9 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_edge.cif.out index 9cd90556e8d7d260b88c9d0a111c14f017ba378b..bdc69034b2fdb7dbd7d46780bbe36946620fa4ba 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_edge.cif.out @@ -194,9 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: not(p.x = 4 or p.x = 5) or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_event.cif.out index 92721f2bb8ababa80016896d63d7cf6529d1379e..842241888b96ddf3ae2c6fb5a52e44a16fcdc2ea 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors07_per_event.cif.out @@ -190,9 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: not(p.x = 4 or p.x = 5) or p.l2 -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_edge.cif.out index c4c8b70b5c19a1d8bfa57d20e7bdebc4c676c0ec..176aa6cf89b55bd49dad4a41056bae9730be9fbf 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_edge.cif.out @@ -194,9 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: (p.x != 6 or p.l2) and (0 <= p.x and p.x <= 4 or (p.x = 6 or p.l2)) -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_event.cif.out index 27398f372f7384ca226480b1359b640f21ab22b6..1955e5b1c159d5ef187ecd931190a516efac7b9a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors08_per_event.cif.out @@ -190,9 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: (p.x != 6 or p.l2) and (0 <= p.x and p.x <= 4 or (p.x = 6 or p.l2)) -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_edge.cif.out index e2b9b2b3144592c9dd7e51a673bc5b7c5069cb31..00016ba21bc2235bec536e16d87b2db934c39631 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_edge.cif.out @@ -194,12 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or p.x = 5 and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [fixed point]. Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)). @@ -207,21 +201,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or (p.x = 1 and p.l1 or (p.x = 3 or p.x = 7) and p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 5 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 5 and p.l1 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [forward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or p.x = 5 and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) -> p.x = 5 and p.l1 or p.x = 7 and p.l2. @@ -233,12 +218,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 7 and p.l2 [restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 7 and p.l2 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or p.x = 5 and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior not changed. @@ -246,9 +225,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 5 or p.l2) and (p.x != 7 or p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_event.cif.out index 5a42b705aef56c1988d5fe2cfca10cfb109f599c..5d13bd06a06aab4f3e66159d9c8c8935e5bf1287 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors09_per_event.cif.out @@ -190,12 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or (p.x = 5 or p.x = 7) and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2 / p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [fixed point]. Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)). @@ -203,21 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or (p.x = 1 and p.l1 or (p.x = 3 or p.x = 7) and p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 5 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 5 and p.l1 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [forward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or (p.x = 5 or p.x = 7) and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2 / p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) -> p.x = 5 and p.l1 or p.x = 7 and p.l2. @@ -229,12 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 7 and p.l2 [restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 7 and p.l2 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or (p.x = 5 or p.x = 7) and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2 / p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior not changed. @@ -242,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 5 or p.l2) and (p.x != 7 or p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_edge.cif.out index 9759d3fba93d1a7e6e041967ae0024690f6538e7..1691852d3355478e5807e5f1d847db826d6d1ef8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_edge.cif.out @@ -194,9 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: (p.x != 6 or p.l2) and (0 <= p.x and p.x <= 4 or (p.x = 6 or p.l2)) -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_event.cif.out index 1ea948d4975780c14be453b1c7a933a860ff77bb..9319c672b4b3cc6b099dc0ad747c3a991117e92a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors10_per_event.cif.out @@ -190,9 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: (p.x != 6 or p.l2) and (0 <= p.x and p.x <= 4 or (p.x = 6 or p.l2)) -> p.l2. Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_edge.cif.out index b1504c147a33900d39ef5fa4fe05eae274e47171..795a665650d98419af2437de67085d81227dd2fa 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_edge.cif.out @@ -194,12 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or p.x = 5 and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [fixed point]. Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)). @@ -207,21 +201,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or (p.x = 1 and p.l1 or (p.x = 3 or p.x = 7) and p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 5 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 5 and p.l1 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [forward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or p.x = 5 and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) -> p.x = 5 and p.l1 or p.x = 7 and p.l2. @@ -233,12 +218,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 7 and p.l2 [restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 7 and p.l2 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or p.x = 5 and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior not changed. @@ -246,9 +225,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 5 or p.l2) and (p.x != 7 or p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_event.cif.out index f65528860e4f7c9838c9d561fb8a68e66b897444..7f7552a53d5fa0f3d841ba2b004bf8ed9924625e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors11_per_event.cif.out @@ -190,12 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or (p.x = 5 or p.x = 7) and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2 / p.x := p.x + 3, p := p.l2), restricted to current/previous controlled-behavior predicate: 0 <= p.x and p.x <= 5 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) [fixed point]. Controlled behavior: 0 <= p.x and p.x <= 5 or p.l2 -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)). @@ -203,21 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or (p.x = 1 and p.l1 or (p.x = 3 or p.x = 7) and p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 5 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 5 and p.l1 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [forward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or (p.x = 5 or p.x = 7) and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2 / p.x := p.x + 3, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior: (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.l2))) and ((p.x != 1 or p.l2) and (not(p.x = 3 or p.x = 7) or p.l2)) -> p.x = 5 and p.l1 or p.x = 7 and p.l2. @@ -229,12 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> p.x = 7 and p.l2 [restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 7 and p.l2 -> p.x = 5 and p.l1 or p.x = 7 and p.l2 [backward reach with edge: (event: e) (guard: p.x = 6 and p.l1 or (p.x = 5 or p.x = 7) and p.l1 -> p.x = 5 and p.l1) (assignments: p.x := p.x + 2, p := p.l2 / p.x := p.x + 3, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 5 and p.l1 or p.x = 7 and p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 5 and p.l1 or p.x = 7 and p.l2 [fixed point]. Controlled behavior not changed. @@ -242,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 5 or p.l2) and (p.x != 7 or p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_edge.cif.out index f442fedd9c2459427878f2a7be34d21d7851a7c8..4ca33b4f53428d73fc755887b1ed2fee7d1e80e1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_edge.cif.out @@ -194,13 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 4) and p.l1 or (p.x = 2 and p.l1 or (p.x = 1 or p.x = 3) and p.l1) -> (p.x = 0 or p.x = 1) and p.l1) (assignments: p.x := p.x + 6, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - Backward controlled-behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) -> (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2) [backward reach with edge: (event: e) (guard: 4 <= p.x and (p.x <= 7 and p.l1) -> (p.x = 6 or p.x = 7) and p.l1) (assignments: p.x := p.x - 6, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2) [fixed point]. Controlled behavior not changed. @@ -208,22 +201,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 4 or p.x = 5) and p.l1 or (p.x = 2 or p.x = 3) and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) and p.l1 [restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) and p.l1 -> (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 4) and p.l1 or (p.x = 2 and p.l1 or (p.x = 1 or p.x = 3) and p.l1) -> (p.x = 0 or p.x = 1) and p.l1) (assignments: p.x := p.x + 6, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) -> p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [forward reach with edge: (event: e) (guard: 4 <= p.x and (p.x <= 7 and p.l1) -> (p.x = 6 or p.x = 7) and p.l1) (assignments: p.x := p.x - 6, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [fixed point]. Controlled behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2) -> p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7). @@ -235,13 +218,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> (p.x = 0 or p.x = 1) and p.l2 or (p.x = 6 or p.x = 7) and p.l2 [restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7)] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 1) and p.l2 or (p.x = 6 or p.x = 7) and p.l2 -> p.x = 0 or (p.x = 1 or (p.x = 6 or p.x = 7) and p.l2) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 4) and p.l1 or (p.x = 2 and p.l1 or (p.x = 1 or p.x = 3) and p.l1) -> (p.x = 0 or p.x = 1) and p.l1) (assignments: p.x := p.x + 6, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7)] - Backward controlled-behavior: p.x = 0 or (p.x = 1 or (p.x = 6 or p.x = 7) and p.l2) -> p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [backward reach with edge: (event: e) (guard: 4 <= p.x and (p.x <= 7 and p.l1) -> (p.x = 6 or p.x = 7) and p.l1) (assignments: p.x := p.x - 6, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [fixed point]. Controlled behavior not changed. @@ -249,9 +225,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: 2 <= p.x and p.x <= 7 and (0 <= p.x and p.x <= 5) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_event.cif.out index 645c942ca9bc808174ba6b97766357c047aa09f9..eb9ef1cc96229f8f8ee4d5ffc0628d1213693779 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors12_per_event.cif.out @@ -190,12 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2) [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) and p.l1) (assignments: p.x := p.x + 6, p := p.l2 / p.x := p.x - 6, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2) [fixed point]. Controlled behavior not changed. @@ -203,21 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 4 or p.x = 5) and p.l1 or (p.x = 2 or p.x = 3) and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) and p.l1 [restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) and p.l1 -> p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) and p.l1) (assignments: p.x := p.x + 6, p := p.l2 / p.x := p.x - 6, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2)] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [fixed point]. Controlled behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (not(p.x = 2 or p.x = 3) or p.l2) -> p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7). @@ -229,12 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> (p.x = 0 or p.x = 1) and p.l2 or (p.x = 6 or p.x = 7) and p.l2 [restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7)] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 1) and p.l2 or (p.x = 6 or p.x = 7) and p.l2 -> p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [backward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 or (p.x = 6 or p.x = 7) and p.l1) (assignments: p.x := p.x + 6, p := p.l2 / p.x := p.x - 6, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 or p.x = 1 or (p.x = 6 or p.x = 7) [fixed point]. Controlled behavior not changed. @@ -242,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: 2 <= p.x and p.x <= 7 and (0 <= p.x and p.x <= 5) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_edge.cif.out index fb7f399dbc2beecc298cdcf7260dee50c72642a7..3c69c574d93e8176b4fde2fb9d7b95ac88f9d5e7 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_edge.cif.out @@ -198,12 +198,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) [backward reach with edge: (event: e) (guard: p.l1 -> 0 <= p.x and (p.x <= 3 and p.l1)) (assignments: p.x := p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) [fixed point]. Controlled behavior not changed. @@ -211,23 +205,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 4 or p.x = 5) and p.l1 or (p.x = 2 or p.x = 3 or (p.x = 6 or p.x = 7)) and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 [restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 -> p.x = 0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1) [forward reach with edge: (event: e) (guard: p.l1 -> 0 <= p.x and (p.x <= 3 and p.l1)) (assignments: p.x := p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - Forward controlled-behavior: p.x = 0 or (p.x = 2 and p.l2 or p.x = 1 and p.l1) -> p.x = 0 or p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - Forward controlled-behavior: p.x = 0 or p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) -> p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [forward reach with edge: (event: e) (guard: p.l1 -> (p.x = 0 or p.x = 1) and p.l1) (assignments: p.x := p.x + p.x + p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [fixed point]. Controlled behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) -> p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)). @@ -239,12 +222,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or p.x = 3 and p.l2) [restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2))] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or p.x = 3 and p.l2) -> p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [backward reach with edge: (event: e) (guard: p.l1 -> 0 <= p.x and (p.x <= 3 and p.l1)) (assignments: p.x := p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [fixed point]. Controlled behavior not changed. @@ -252,9 +229,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 0 and (p.x != 4 or p.l1) and ((p.x != 2 or p.l1) and ((p.x != 1 or p.l2) and (p.x != 3 or p.l1))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_event.cif.out index b6701cbfa5fb7b6f503c371028c5303920dd3eb1..57c402ee83f6d5c21cde949a0b36e4912d899700 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_errors13_per_event.cif.out @@ -190,12 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 -> (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) [backward reach with edge: (event: e) (guard: p.l1 -> 0 <= p.x and (p.x <= 3 and p.l1)) (assignments: p.x := p.x + p.x, p := p.l2 / p.x := p.x + p.x + p.x, p := p.l2 / p.x := p.x + p.x + p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) [fixed point]. Controlled behavior not changed. @@ -203,21 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 4 or p.x = 5) and p.l1 or (p.x = 2 or p.x = 3 or (p.x = 6 or p.x = 7)) and p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 [restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 -> p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [forward reach with edge: (event: e) (guard: p.l1 -> 0 <= p.x and (p.x <= 3 and p.l1)) (assignments: p.x := p.x + p.x, p := p.l2 / p.x := p.x + p.x + p.x, p := p.l2 / p.x := p.x + p.x + p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [fixed point]. Controlled behavior: (not(p.x = 4 or p.x = 5) or p.l2) and (p.x = 0 or p.x = 1 or (p.x = 4 or (p.x = 5 or p.l2))) -> p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)). @@ -229,12 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.l2 [marker predicate] Backward controlled-behavior: p.l2 -> (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or p.x = 3 and p.l2) [restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2))] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or p.x = 3 and p.l2) -> p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [backward reach with edge: (event: e) (guard: p.l1 -> 0 <= p.x and (p.x <= 3 and p.l1)) (assignments: p.x := p.x + p.x, p := p.l2 / p.x := p.x + p.x + p.x, p := p.l2 / p.x := p.x + p.x + p.x + p.x, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 or p.x = 4 and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2)) [fixed point]. Controlled behavior not changed. @@ -242,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 0 and (p.x != 4 or p.l1) and ((p.x != 2 or p.l1) and ((p.x != 1 or p.l2) and (p.x != 3 or p.l1))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_edge.cif.out index 7f383f2c43a8bf20c625669f4283fff259692415..98991efc6582d3ed9c4f61fe47a12126424ade03 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_edge.cif.out @@ -188,12 +188,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) [fixed point]. Controlled behavior: true -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))). @@ -201,21 +195,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or p.y2)) and (p.y != 2 or p.x != 0) and ((p.y != 2 or (p.x != 2 or p.l1)) and ((p.y != 2 or p.x = 0 or (p.x = 2 or p.l1)) and (p.y = 0 or p.y = 2 or (p.x != 0 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 0 and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and p.l1 -> p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [fixed point]. Controlled behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) -> p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)). @@ -227,12 +212,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 2 and (p.x = 0 and p.y2) [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and (p.x = 0 and p.y2) -> p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [fixed point]. Controlled behavior not changed. @@ -240,9 +219,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or p.y2)) and ((p.y != 2 or p.x != 0) and (p.y = 0 or p.y = 2 or (p.x != 0 or p.y2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_event.cif.out index 5e4da333490930817bca2e305e8290ace99a2537..f6ab9b5c1d94b33a2f305ca40d41a1b065cc6331 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates1_per_event.cif.out @@ -187,12 +187,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) [fixed point]. Controlled behavior: true -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))). @@ -200,21 +194,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or p.y2)) and (p.y != 2 or p.x != 0) and ((p.y != 2 or (p.x != 2 or p.l1)) and ((p.y != 2 or p.x = 0 or (p.x = 2 or p.l1)) and (p.y = 0 or p.y = 2 or (p.x != 0 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 0 and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and p.l1 -> p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [fixed point]. Controlled behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) -> p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)). @@ -226,12 +211,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 2 and (p.x = 0 and p.y2) [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and (p.x = 0 and p.y2) -> p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and p.x = 0 or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [fixed point]. Controlled behavior not changed. @@ -239,9 +218,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or p.y2)) and ((p.y != 2 or p.x != 0) and (p.y = 0 or p.y = 2 or (p.x != 0 or p.y2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_edge.cif.out index 81c3c47aef8088d66f09968c7cc89e69321cceed..b37b428807e2bb58cab1400172bc4723411a37d1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_edge.cif.out @@ -190,12 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) [fixed point]. Controlled behavior: true -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))). @@ -203,22 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or not p.l1)) and (p.y != 2 or (p.x != 0 or p.y3)) and ((p.y != 2 or (p.x != 2 or not p.y2)) and (p.y != 2 or p.x = 0 or (p.x = 2 or not p.y2))) and ((p.y != 1 or (p.x != 0 or not p.l1)) and (p.y != 3 or (p.x != 0 or p.y2)) and ((p.y != 3 or (p.x != 2 or not p.y3)) and (p.y != 3 or p.x = 0 or (p.x = 2 or not p.y3)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 0 and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and p.l1 -> p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3)))] - Forward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [fixed point]. Controlled behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)). @@ -230,12 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 0 and p.y3) [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 0 and p.y3) -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [fixed point]. Controlled behavior not changed. @@ -243,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or not p.l1)) and (p.y != 2 or (p.x != 0 or p.y3)) and ((p.y != 1 or (p.x != 0 or not p.l1)) and (p.y != 3 or (p.x != 0 or p.y2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_event.cif.out index 3e92706e1ade62446130bb05d716975227ed14d8..ac2f0a4057c482caafccb7f94996bb4d5e510516 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates2_per_event.cif.out @@ -189,12 +189,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) [fixed point]. Controlled behavior: true -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))). @@ -202,21 +196,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or not p.l1)) and (p.y != 2 or (p.x != 0 or p.y3)) and ((p.y != 2 or (p.x != 2 or not p.y2)) and (p.y != 2 or p.x = 0 or (p.x = 2 or not p.y2))) and ((p.y != 1 or (p.x != 0 or not p.l1)) and (p.y != 3 or (p.x != 0 or p.y2)) and ((p.y != 3 or (p.x != 2 or not p.y3)) and (p.y != 3 or p.x = 0 or (p.x = 2 or not p.y3)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> p.x = 0 and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3)))] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and p.l1 -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [fixed point]. Controlled behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)). @@ -228,12 +213,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 0 and p.y3) [restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 0 and p.y3) -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2)) [fixed point]. Controlled behavior not changed. @@ -241,9 +220,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or (p.x != 0 or not p.l1)) and (p.y != 2 or (p.x != 0 or p.y3)) and ((p.y != 1 or (p.x != 0 or not p.l1)) and (p.y != 3 or (p.x != 0 or p.y2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_edge.cif.out index 798302b23e5c6a259aef705671c0e57178c8ce32..c0442c731d32ab98ed3246bdb3c1ac56cd9a715c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_edge.cif.out @@ -188,13 +188,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 2 and p.y2) or (p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1))) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [backward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [fixed point]. Controlled behavior: true -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)). @@ -202,22 +195,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or p.y2)) and (p.y != 2 or (p.x = 2 or p.x = 3)) and ((p.y != 2 or p.x = 0 or (p.x = 1 or p.l1)) and (p.y = 0 or p.y = 2 or (p.x = 2 or (p.x = 3 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 1 and p.l1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - Forward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 1 and p.l1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [forward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [fixed point]. Controlled behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)). @@ -229,13 +212,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 2 and ((p.x = 0 or p.x = 1) and p.y2) [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and ((p.x = 0 or p.x = 1) and p.y2) -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 1 and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and p.x = 0 or (p.y = 2 and (p.x = 1 and p.y2) or (p.y = 1 or p.y = 3) and (p.x = 0 and p.l1)) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [backward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [fixed point]. Controlled behavior not changed. @@ -243,9 +219,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or p.y2)) and ((p.y != 2 or (p.x = 2 or p.x = 3)) and (p.y = 0 or p.y = 2 or (p.x = 2 or (p.x = 3 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_event.cif.out index aed0f01b363261f79d4f0668d1dd9ea1c0e1cd81..c90fdc4129aa372c5da8113723cd648546a6dd04 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates3_per_event.cif.out @@ -187,12 +187,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [fixed point]. Controlled behavior: true -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)). @@ -200,21 +194,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or p.y2)) and (p.y != 2 or (p.x = 2 or p.x = 3)) and ((p.y != 2 or p.x = 0 or (p.x = 1 or p.l1)) and (p.y = 0 or p.y = 2 or (p.x = 2 or (p.x = 3 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [fixed point]. Controlled behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)). @@ -226,12 +211,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 -> p.y = 2 and ((p.x = 0 or p.x = 1) and p.y2) [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and ((p.x = 0 or p.x = 1) and p.y2) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 or p.x = 1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [fixed point]. Controlled behavior not changed. @@ -239,9 +218,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or p.y2)) and ((p.y != 2 or (p.x = 2 or p.x = 3)) and (p.y = 0 or p.y = 2 or (p.x = 2 or (p.x = 3 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_edge.cif.out index 312c48e7996fbdff647ba6a26349aec4cd2f2cc8..57ab732655c0b38b05726de19099c2e20849f819 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_edge.cif.out @@ -190,13 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 2 and p.y2) or p.y = 2 and ((p.x = 1 or p.x = 3) and p.y2)) or (p.y = 1 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 0 and not p.y2) or (p.y = 3 and (p.x = 2 and p.y3) or p.y = 3 and ((p.x = 1 or p.x = 3) and p.y3))) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))) [backward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))) [fixed point]. Controlled behavior: true -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))). @@ -204,22 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 2 or p.x = 2 or (p.x = 3 or p.y3)) and (p.y != 2 or p.x = 0 or (p.x = 1 or not p.y2))) and ((p.y != 1 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 3 or p.x = 2 or (p.x = 3 or p.y2)) and (p.y != 3 or p.x = 0 or (p.x = 1 or not p.y3)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3)))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 1 and p.l1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3)))] - Forward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 2 and (p.x = 1 and p.l1) or (p.y = 1 or p.y = 3) and ((p.x = 0 or p.x = 1) and p.l1)) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [forward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [fixed point]. Controlled behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))). @@ -231,13 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 1 and p.y3) [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2)))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 1 and p.y3) -> p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and p.y3))) [backward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2)))] - Backward controlled-behavior: p.y = 0 and (p.x = 0 and p.l1) or p.y = 2 and (p.x = 0 and not p.y3) or (p.y = 1 and (p.x = 0 and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and p.y3))) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [backward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2)))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [fixed point]. Controlled behavior not changed. @@ -245,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 2 or (p.x != 0 or p.y3)) and (p.y != 2 or (p.x != 1 or not p.l1))) and ((p.y != 1 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 3 or (p.x != 0 or not p.l1)) and (p.y != 3 or (p.x != 1 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_event.cif.out index 06b017e4b4a740884e3dae7b22faafcd37609166..6ed841729b4086f47e830a4eb49e8ffa4edcdb2b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates4_per_event.cif.out @@ -189,12 +189,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))) [fixed point]. Controlled behavior: true -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))). @@ -202,21 +196,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 2 or p.x = 2 or (p.x = 3 or p.y3)) and (p.y != 2 or p.x = 0 or (p.x = 1 or not p.y2))) and ((p.y != 1 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 3 or p.x = 2 or (p.x = 3 or p.y2)) and (p.y != 3 or p.x = 0 or (p.x = 1 or not p.y3)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 1) and p.l1 [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3)))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.l1 -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [fixed point]. Controlled behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and ((p.x = 0 or p.x = 1) and not p.y3) or p.y = 2 and ((p.x = 2 or p.x = 3) and p.y2)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and ((p.x = 0 or p.x = 1) and not p.y2) or p.y = 3 and ((p.x = 2 or p.x = 3) and p.y3))) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))). @@ -228,12 +213,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 1 and p.y3) [restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2)))] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and (p.x = 0 and p.y2) or p.y = 3 and (p.x = 1 and p.y3) -> p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2)))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.y = 0 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 2 and (p.x = 0 and not p.y3) or p.y = 2 and (p.x = 1 and p.l1)) or (p.y = 1 and ((p.x = 0 or p.x = 1) and p.l1) or (p.y = 3 and (p.x = 0 and p.l1) or p.y = 3 and (p.x = 1 and not p.y2))) [fixed point]. Controlled behavior not changed. @@ -241,9 +220,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.y != 0 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 2 or (p.x != 0 or p.y3)) and (p.y != 2 or (p.x != 1 or not p.l1))) and ((p.y != 1 or p.x = 2 or (p.x = 3 or not p.l1)) and ((p.y != 3 or (p.x != 0 or not p.l1)) and (p.y != 3 or (p.x != 1 or p.y2)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_edge.cif.out index 5f7077942e370ad0acbf80217b4d729e9fe12ada..2ba7199ab2446e832d7d109fdd25e82cca8368c7 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_edge.cif.out @@ -190,13 +190,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 3 and p.y3 -> (p.x = 0 or p.x = 1) and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 0 or p.x = 1) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 1) and p.y = 3 or (p.x = 2 or p.x = 3) and (p.y = 3 and p.y3)) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 1) and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 0 or p.x = 1) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 1) and p.y = 3 or (p.x = 2 or p.x = 3) and (p.y = 3 and p.y3)) -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))) [backward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))) [fixed point]. Controlled behavior: true -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))). @@ -204,22 +197,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.y3))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.y3)) and (p.x = 1 or (p.x = 3 or p.y != 3))) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.y3)) and (p.x != 1 or (p.y != 1 or p.y3)) and ((p.x != 1 or p.y != 3) and (p.x != 3 or (p.y != 3 or p.l1)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3))))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 -> (p.x != 0 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 0 or (p.y != 1 or p.l1)) and (p.x != 2 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3))))] - Forward controlled-behavior: (p.x != 0 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 0 or (p.y != 1 or p.l1)) and (p.x != 2 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [forward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3))))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [fixed point]. Controlled behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))) -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)). @@ -231,13 +214,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 3 and p.y3 -> (p.x = 0 or p.x = 2) and (p.y = 3 and p.y3) or p.x = 1 and (p.y = 3 and p.y3) [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3))] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.y = 3 and p.y3) or p.x = 1 and (p.y = 3 and p.y3) -> p.x = 0 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 0 and (p.y = 1 and p.l1) or p.x = 0 and p.y = 3) or (p.x = 2 and (p.y = 3 and p.y3) or p.x = 1 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 1 and (p.y = 1 and p.l1) or p.x = 1 and p.y = 3)) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3))] - Backward controlled-behavior: p.x = 0 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 0 and (p.y = 1 and p.l1) or p.x = 0 and p.y = 3) or (p.x = 2 and (p.y = 3 and p.y3) or p.x = 1 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 1 and (p.y = 1 and p.l1) or p.x = 1 and p.y = 3)) -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [backward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [fixed point]. Controlled behavior not changed. @@ -245,9 +221,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 2) and ((p.y = 0 or p.y = 2) and p.y3) or (p.x = 0 or p.x = 2) and (p.y = 1 and p.y3) or (p.x = 1 and ((p.y = 0 or p.y = 2) and p.y3) or (p.x = 1 and (p.y = 1 and p.y3) or p.x = 3)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_event.cif.out index 95771732347babe917ec98bb27538c3246cdfd3f..d37e8201743578a5eeed060e4b0afda958011fd4 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates5_per_event.cif.out @@ -189,12 +189,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 3 and p.y3 -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))) [fixed point]. Controlled behavior: true -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))). @@ -202,21 +196,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.y3))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.y3)) and (p.x = 1 or (p.x = 3 or p.y != 3))) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.y3)) and (p.x != 1 or (p.y != 1 or p.y3)) and ((p.x != 1 or p.y != 3) and (p.x != 3 or (p.y != 3 or p.l1)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3))))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3))))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [fixed point]. Controlled behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and ((p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and (p.x != 1 or p.y = 1 or (p.y = 3 or p.l1))) and ((p.x != 1 or (p.y != 1 or p.l1)) and (p.x != 3 or (p.y = 1 or p.y = 3)) and ((p.x != 3 or p.y != 1) and (p.x != 3 or (p.y != 3 or p.y3)))) -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)). @@ -228,12 +213,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 3 and p.y3 -> (p.x = 0 or p.x = 2) and (p.y = 3 and p.y3) or p.x = 1 and (p.y = 3 and p.y3) [restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3))] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.y = 3 and p.y3) or p.x = 1 and (p.y = 3 and p.y3) -> (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 1 or p.x = 3 or (p.y = 1 or (p.y = 3 or p.l1))) and (p.x = 1 or p.x = 3 or (p.y != 1 or p.l1)) and ((p.x != 1 or p.y = 1 or (p.y = 3 or p.l1)) and ((p.x != 1 or (p.y != 1 or p.l1)) and p.x != 3)) [fixed point]. Controlled behavior not changed. @@ -241,9 +220,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 2) and ((p.y = 0 or p.y = 2) and p.y3) or (p.x = 0 or p.x = 2) and (p.y = 1 and p.y3) or (p.x = 1 and ((p.y = 0 or p.y = 2) and p.y3) or (p.x = 1 and (p.y = 1 and p.y3) or p.x = 3)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_edge.cif.out index 9e9cd4ece699af591104606588350ea7129c6e00..56e2914b1c7fc8315224ca6b6cc579002ad08a2c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_edge.cif.out @@ -192,13 +192,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or (p.x = 0 or p.x = 2) and (p.y = 1 and p.l1)) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or ((p.x = 1 or p.x = 3) and (p.y = 2 and p.y2) or (p.x = 1 or p.x = 3) and (p.y = 3 and p.y3))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or (p.x = 0 or p.x = 2) and (p.y = 1 and p.l1)) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or ((p.x = 1 or p.x = 3) and (p.y = 2 and p.y2) or (p.x = 1 or p.x = 3) and (p.y = 3 and p.y3))) -> (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [backward reach with edge: (event: e) (guard: (p.x = 2 or p.x = 3) and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [fixed point]. Controlled behavior: true -> (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))). @@ -206,22 +199,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 1 or p.x = 3 or (p.y != 0 or not p.l1)) and (p.x = 1 or p.x = 3 or (p.y != 2 or p.y3)) and ((p.x = 1 or p.x = 3 or (p.y != 1 or not p.l1)) and ((p.x = 1 or p.x = 3 or (p.y != 3 or p.y2)) and (p.x != 1 or (p.y != 2 or not p.y2)))) and ((p.x != 1 or (p.y != 3 or not p.y3)) and (p.x != 3 or (p.y != 0 or not p.l1)) and ((p.x != 3 or (p.y != 2 or p.y3)) and ((p.x != 3 or (p.y != 1 or not p.l1)) and (p.x != 3 or (p.y != 3 or p.y2))))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or p.x = 3 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or p.x = 3 and p.l1 -> (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 3 and p.l1) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 3 and p.l1) -> p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [forward reach with edge: (event: e) (guard: (p.x = 2 or p.x = 3) and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) -> p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))). @@ -233,13 +216,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 2 and p.y2) or (p.x = 2 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 3 and p.y3)) [restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 2 and p.y2) or (p.x = 2 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 3 and p.y3)) -> p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and (p.y = 0 and p.l1)) or (p.x = 2 and (p.y = 2 and not p.y3) or p.x = 2 and (p.y = 1 and p.l1) or (p.x = 2 and (p.y = 3 and not p.y2) or p.x = 3 and (p.y = 3 and p.y3))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - Backward controlled-behavior: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and (p.y = 0 and p.l1)) or (p.x = 2 and (p.y = 2 and not p.y3) or p.x = 2 and (p.y = 1 and p.l1) or (p.x = 2 and (p.y = 3 and not p.y2) or p.x = 3 and (p.y = 3 and p.y3))) -> p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [backward reach with edge: (event: e) (guard: (p.x = 2 or p.x = 3) and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [fixed point]. Controlled behavior not changed. @@ -247,9 +223,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 0 or (p.y != 0 or not p.l1)) and (p.x != 0 or (p.y != 2 or p.y3)) and ((p.x != 0 or p.y = 0 or (p.y = 2 or not p.l1)) and ((p.x != 2 or (p.y != 0 or not p.l1)) and (p.x != 2 or (p.y != 2 or p.y3)))) and ((p.x != 2 or (p.y != 1 or not p.l1)) and (p.x != 2 or (p.y != 3 or p.y2)) and ((p.x != 3 or p.y = 1 or (p.y = 3 or not p.l1)) and ((p.x != 3 or (p.y != 1 or not p.l1)) and (p.x != 3 or (p.y != 3 or p.y2))))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_event.cif.out index 13eac8ecf20efa4daf576868d68488e147a32680..9b7201583b754ea4632a11b1d22532b24e510760 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates6_per_event.cif.out @@ -191,12 +191,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 3 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [fixed point]. Controlled behavior: true -> (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))). @@ -204,21 +198,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 1 or p.x = 3 or (p.y != 0 or not p.l1)) and (p.x = 1 or p.x = 3 or (p.y != 2 or p.y3)) and ((p.x = 1 or p.x = 3 or (p.y != 1 or not p.l1)) and ((p.x = 1 or p.x = 3 or (p.y != 3 or p.y2)) and (p.x != 1 or (p.y != 2 or not p.y2)))) and ((p.x != 1 or (p.y != 3 or not p.y3)) and (p.x != 3 or (p.y != 0 or not p.l1)) and ((p.x != 3 or (p.y != 2 or p.y3)) and ((p.x != 3 or (p.y != 1 or not p.l1)) and (p.x != 3 or (p.y != 3 or p.y2))))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or p.x = 3 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or p.x = 3 and p.l1 -> p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 3 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2) and (p.y = 0 and p.l1) or (p.x = 0 or p.x = 2) and (p.y = 2 and not p.y3) or ((p.x = 0 or p.x = 2) and (p.y = 1 and p.l1) or ((p.x = 0 or p.x = 2) and (p.y = 3 and not p.y2) or p.x = 1 and (p.y = 2 and p.y2))) or (p.x = 1 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 0 and p.l1) or (p.x = 3 and (p.y = 2 and not p.y3) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) -> p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))). @@ -230,12 +215,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 [marker predicate] Backward controlled-behavior: p.y = 2 and p.y2 or p.y = 3 and p.y3 -> p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 2 and p.y2) or (p.x = 2 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 3 and p.y3)) [restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 2 and p.y2) or (p.x = 2 and (p.y = 3 and p.y3) or p.x = 3 and (p.y = 3 and p.y3)) -> p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 3 and p.l1) (assignments: p.y := 2, p := p.y2 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 and (p.y = 0 and p.l1) or p.x = 0 and (p.y = 2 and not p.y3) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and (p.y = 0 and p.l1) or p.x = 2 and (p.y = 2 and not p.y3))) or (p.x = 2 and (p.y = 1 and p.l1) or p.x = 2 and (p.y = 3 and not p.y2) or (p.x = 3 and ((p.y = 0 or p.y = 2) and p.l1) or (p.x = 3 and (p.y = 1 and p.l1) or p.x = 3 and (p.y = 3 and not p.y2)))) [fixed point]. Controlled behavior not changed. @@ -243,9 +222,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 0 or (p.y != 0 or not p.l1)) and (p.x != 0 or (p.y != 2 or p.y3)) and ((p.x != 0 or p.y = 0 or (p.y = 2 or not p.l1)) and ((p.x != 2 or (p.y != 0 or not p.l1)) and (p.x != 2 or (p.y != 2 or p.y3)))) and ((p.x != 2 or (p.y != 1 or not p.l1)) and (p.x != 2 or (p.y != 3 or p.y2)) and ((p.x != 3 or p.y = 1 or (p.y = 3 or not p.l1)) and ((p.x != 3 or (p.y != 1 or not p.l1)) and (p.x != 3 or (p.y != 3 or p.y2))))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_edge.cif.out index 90fe21f8bc2dcd53cf5bf22709cd90dffbae1ddf..c35e412a7e9559088d54652123e91880925d08a2 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_edge.cif.out @@ -196,13 +196,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> (p.x = 0 or p.x = 1) and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 0 or p.x = 1) and (p.y = 2 and p.l1) or ((p.x = 0 or p.x = 1) and (p.y = 2 and p.y2) or (p.x = 0 or p.x = 1) and (p.y = 1 and (p.l1 or p.y1))) or ((p.x = 0 or p.x = 1) and (p.y = 3 and (p.l1 or p.y3)) or (p.x = 2 or p.x = 3) and (p.y = 0 and p.y0) or ((p.x = 2 or p.x = 3) and (p.y = 2 and p.y2) or ((p.x = 2 or p.x = 3) and (p.y = 1 and p.y1) or (p.x = 2 or p.x = 3) and (p.y = 3 and p.y3)))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 0, p := p.y0), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 1) and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 0 or p.x = 1) and (p.y = 2 and p.l1) or ((p.x = 0 or p.x = 1) and (p.y = 2 and p.y2) or (p.x = 0 or p.x = 1) and (p.y = 1 and (p.l1 or p.y1))) or ((p.x = 0 or p.x = 1) and (p.y = 3 and (p.l1 or p.y3)) or (p.x = 2 or p.x = 3) and (p.y = 0 and p.y0) or ((p.x = 2 or p.x = 3) and (p.y = 2 and p.y2) or ((p.x = 2 or p.x = 3) and (p.y = 1 and p.y1) or (p.x = 2 or p.x = 3) and (p.y = 3 and p.y3)))) -> <bdd 21n 14p> [backward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 1, p := p.y1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 21n 14p> [fixed point]. Controlled behavior: true -> <bdd 21n 14p>. @@ -210,24 +203,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 21n 32p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 [restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 0 and (p.y = 2 and p.l1) or p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1)) or (p.x = 2 and p.l1 or p.x = 1 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 1 and (p.y = 2 and p.l1) or p.x = 1 and ((p.y = 1 or p.y = 3) and p.l1))) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 0, p := p.y0), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 0 and (p.y = 2 and p.l1) or p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1)) or (p.x = 2 and p.l1 or p.x = 1 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 1 and (p.y = 2 and p.l1) or p.x = 1 and ((p.y = 1 or p.y = 3) and p.l1))) -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1) or p.x = 2 and (p.y = 1 and (p.l1 or p.y1)))) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and p.l1)))) [forward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 1, p := p.y1), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or (p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1) or p.x = 2 and (p.y = 1 and (p.l1 or p.y1)))) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and p.l1)))) -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and p.l1)))) [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and p.l1)))) -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [forward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [fixed point]. Controlled behavior: <bdd 21n 14p> -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))). @@ -239,13 +220,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> p.x = 0 and (p.y = 0 and p.y0) or (p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 1 and p.y1)) or (p.x = 1 and (p.y = 0 and p.y0) or (p.x = 1 and (p.y = 1 and p.y1) or p.x = 1 and (p.y = 3 and p.y3))) [restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3)))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.y = 0 and p.y0) or (p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 1 and p.y1)) or (p.x = 1 and (p.y = 0 and p.y0) or (p.x = 1 and (p.y = 1 and p.y1) or p.x = 1 and (p.y = 3 and p.y3))) -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1)) or (p.x = 2 and (p.y = 1 and p.y1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 0, p := p.y0), restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3)))))] - Backward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1)) or (p.x = 2 and (p.y = 1 and p.y1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [backward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 1, p := p.y1), restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3)))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [fixed point]. Controlled behavior not changed. @@ -253,9 +227,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 18n 27p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_event.cif.out index 164193807cbbdc3cb3bf580de045db937f43ec25..1ff8acdbe9676d89ff471d6f3c4bd88d2c31e248 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates7_per_event.cif.out @@ -191,12 +191,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> <bdd 21n 14p> [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 0, p := p.y0 / p.y := 1, p := p.y1 / p.y := 0, p := p.y0 / p.y := 2, p := p.y2 / p.y := 1, p := p.y1 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 21n 14p> [fixed point]. Controlled behavior: true -> <bdd 21n 14p>. @@ -204,21 +198,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 21n 32p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 [initialization predicate] Forward controlled-behavior: p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 [restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1 -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 0, p := p.y0 / p.y := 1, p := p.y1 / p.y := 0, p := p.y0 / p.y := 2, p := p.y2 / p.y := 1, p := p.y1 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [fixed point]. Controlled behavior: <bdd 21n 14p> -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))). @@ -230,12 +215,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> p.x = 0 and (p.y = 0 and p.y0) or (p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 1 and p.y1)) or (p.x = 1 and (p.y = 0 and p.y0) or (p.x = 1 and (p.y = 1 and p.y1) or p.x = 1 and (p.y = 3 and p.y3))) [restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3)))))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.y = 0 and p.y0) or (p.x = 0 and (p.y = 2 and p.y2) or p.x = 2 and (p.y = 1 and p.y1)) or (p.x = 1 and (p.y = 0 and p.y0) or (p.x = 1 and (p.y = 1 and p.y1) or p.x = 1 and (p.y = 3 and p.y3))) -> p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 0, p := p.y0 / p.y := 1, p := p.y1 / p.y := 0, p := p.y0 / p.y := 2, p := p.y2 / p.y := 1, p := p.y1 / p.y := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3)))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 and (p.y = 0 and (p.l1 or p.y0)) or p.x = 0 and (p.y = 2 and p.l1) or (p.x = 0 and (p.y = 2 and p.y2) or (p.x = 0 and ((p.y = 1 or p.y = 3) and p.l1) or p.x = 2 and ((p.y = 0 or p.y = 2) and p.l1))) or (p.x = 2 and (p.y = 1 and (p.l1 or p.y1)) or (p.x = 2 and (p.y = 3 and p.l1) or p.x = 1 and (p.y = 0 and (p.l1 or p.y0))) or (p.x = 1 and (p.y = 2 and p.l1) or (p.x = 1 and (p.y = 1 and (p.l1 or p.y1)) or p.x = 1 and (p.y = 3 and (p.l1 or p.y3))))) [fixed point]. Controlled behavior not changed. @@ -243,9 +222,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 18n 27p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_edge.cif.out index 33653b186e004180d1027a685ffe6572256725b2..85707ca6c2ef02d44b8291d3d98024c0d8e521ec 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_edge.cif.out @@ -199,13 +199,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> (p.x = 0 or p.x = 1) and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 0 or p.x = 1) and (p.y = 2 and p.l1) or ((p.x = 0 or p.x = 1) and (p.y = 2 and p.y2) or (p.x = 0 or p.x = 1) and (p.y = 1 and (p.l1 or p.y1))) or ((p.x = 0 or p.x = 1) and (p.y = 3 and (p.l1 or p.y3)) or (p.x = 2 or p.x = 3) and (p.y = 0 and p.y0) or ((p.x = 2 or p.x = 3) and (p.y = 2 and p.y2) or ((p.x = 2 or p.x = 3) and (p.y = 1 and p.y1) or (p.x = 2 or p.x = 3) and (p.y = 3 and p.y3)))) [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 0, p.z := 1, p := p.y0), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 1) and (p.y = 0 and (p.l1 or p.y0)) or (p.x = 0 or p.x = 1) and (p.y = 2 and p.l1) or ((p.x = 0 or p.x = 1) and (p.y = 2 and p.y2) or (p.x = 0 or p.x = 1) and (p.y = 1 and (p.l1 or p.y1))) or ((p.x = 0 or p.x = 1) and (p.y = 3 and (p.l1 or p.y3)) or (p.x = 2 or p.x = 3) and (p.y = 0 and p.y0) or ((p.x = 2 or p.x = 3) and (p.y = 2 and p.y2) or ((p.x = 2 or p.x = 3) and (p.y = 1 and p.y1) or (p.x = 2 or p.x = 3) and (p.y = 3 and p.y3)))) -> <bdd 21n 14p> [backward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 1, p.z := 1, p := p.y1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 21n 14p> [fixed point]. Controlled behavior: true -> <bdd 21n 14p>. @@ -213,25 +206,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 21n 32p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.z = 0 and (p.y = 0 and p.l1) [initialization predicate] Forward controlled-behavior: p.z = 0 and (p.y = 0 and p.l1) -> (p.x = 0 or p.x = 2) and p.z = 0 and (p.y = 0 and p.l1) or p.x = 1 and p.z = 0 and (p.y = 0 and p.l1) [restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.z = 0 and (p.y = 0 and p.l1) or p.x = 1 and p.z = 0 and (p.y = 0 and p.l1) -> p.x = 0 and p.z = 0 and (p.y = 0 and p.l1) or p.x = 0 and p.z = 1 and (p.y = 0 and p.y0) or (p.x = 2 and p.z = 0 and (p.y = 0 and p.l1) or (p.x = 1 and p.z = 0 and (p.y = 0 and p.l1) or p.x = 1 and p.z = 1 and (p.y = 0 and p.y0))) [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 0, p.z := 1, p := p.y0), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward controlled-behavior: p.x = 0 and p.z = 0 and (p.y = 0 and p.l1) or p.x = 0 and p.z = 1 and (p.y = 0 and p.y0) or (p.x = 2 and p.z = 0 and (p.y = 0 and p.l1) or (p.x = 1 and p.z = 0 and (p.y = 0 and p.l1) or p.x = 1 and p.z = 1 and (p.y = 0 and p.y0))) -> <bdd 23n 7p> [forward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 1, p.z := 1, p := p.y1), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward controlled-behavior: <bdd 23n 7p> -> <bdd 27n 8p> [forward reach with edge: (event: e) (guard: p.x = 0 and p.l1) (assignments: p.y := 2, p.z := 2, p := p.y2), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward controlled-behavior: <bdd 27n 8p> -> <bdd 28n 9p> [forward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 1, p.z := 2, p := p.y1), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward controlled-behavior: <bdd 28n 9p> -> <bdd 33n 10p> [forward reach with edge: (event: e) (guard: p.x = 1 and p.l1) (assignments: p.y := 3, p.z := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 33n 10p> [fixed point]. Controlled behavior: <bdd 21n 14p> -> <bdd 33n 10p>. @@ -243,13 +223,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> <bdd 29n 7p> [restricted to current/previous controlled-behavior predicate: <bdd 33n 10p>] - Backward reachability iteration 1: - Backward controlled-behavior: <bdd 29n 7p> -> <bdd 32n 9p> [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 1) and p.l1) (assignments: p.y := 0, p.z := 1, p := p.y0), restricted to current/previous controlled-behavior predicate: <bdd 33n 10p>] - Backward controlled-behavior: <bdd 32n 9p> -> <bdd 33n 10p> [backward reach with edge: (event: e) (guard: p.x = 2 and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 1, p.z := 1, p := p.y1), restricted to current/previous controlled-behavior predicate: <bdd 33n 10p>] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 33n 10p> [fixed point]. Controlled behavior not changed. @@ -257,9 +230,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 33n 52p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_event.cif.out index 6a8668c2bea04c1408c10c4af844000753028bf4..64ee3c483842a2964ccbfcc717dd1449990d75b0 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_guards_updates8_per_event.cif.out @@ -194,12 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> <bdd 21n 14p> [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 0, p.z := 1, p := p.y0 / p.y := 1, p.z := 1, p := p.y1 / p.y := 0, p.z := 1, p := p.y0 / p.y := 2, p.z := 2, p := p.y2 / p.y := 1, p.z := 2, p := p.y1 / p.y := 3, p.z := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 21n 14p> [fixed point]. Controlled behavior: true -> <bdd 21n 14p>. @@ -207,21 +201,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 21n 32p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.z = 0 and (p.y = 0 and p.l1) [initialization predicate] Forward controlled-behavior: p.z = 0 and (p.y = 0 and p.l1) -> (p.x = 0 or p.x = 2) and p.z = 0 and (p.y = 0 and p.l1) or p.x = 1 and p.z = 0 and (p.y = 0 and p.l1) [restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.z = 0 and (p.y = 0 and p.l1) or p.x = 1 and p.z = 0 and (p.y = 0 and p.l1) -> <bdd 33n 10p> [forward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 0, p.z := 1, p := p.y0 / p.y := 1, p.z := 1, p := p.y1 / p.y := 0, p.z := 1, p := p.y0 / p.y := 2, p.z := 2, p := p.y2 / p.y := 1, p.z := 2, p := p.y1 / p.y := 3, p.z := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: <bdd 21n 14p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 33n 10p> [fixed point]. Controlled behavior: <bdd 21n 14p> -> <bdd 33n 10p>. @@ -233,12 +218,6 @@ Synthesis round 2: Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) [marker predicate] Backward controlled-behavior: p.y = 0 and p.y0 or p.y = 2 and p.y2 or (p.y = 1 and p.y1 or p.y = 3 and p.y3) -> <bdd 29n 7p> [restricted to current/previous controlled-behavior predicate: <bdd 33n 10p>] - Backward reachability iteration 1: - Backward controlled-behavior: <bdd 29n 7p> -> <bdd 33n 10p> [backward reach with edge: (event: e) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.y := 0, p.z := 1, p := p.y0 / p.y := 1, p.z := 1, p := p.y1 / p.y := 0, p.z := 1, p := p.y0 / p.y := 2, p.z := 2, p := p.y2 / p.y := 1, p.z := 2, p := p.y1 / p.y := 3, p.z := 3, p := p.y3), restricted to current/previous controlled-behavior predicate: <bdd 33n 10p>] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 33n 10p> [fixed point]. Controlled behavior not changed. @@ -246,9 +225,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 33n 52p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_edge.cif.out index 7646898ca9f68c7f9a89bef3c83f5d092d459a64..671e0ebed89414f18caf1256a41fb4888414ec45 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_edge.cif.out @@ -211,17 +211,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p2.l1 and p1.l1 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p2.l1 and p1.l1 -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or (p2.x = 1 and p2.l1 or p2.x = 3 and (p2.l1 and p1.l1)) [backward reach with edge: (event: e) (guard: p2.x = 1 and (p2.l1 and p1.l2)) (assignments: p1 := p1.l1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or (p2.x = 1 and p2.l1 or p2.x = 3 and (p2.l1 and p1.l1)) -> (p2.x = 0 or p2.x = 2) and (not p2.l3 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (not p2.l3 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1))) [backward reach with edge: (event: e) (guard: p2.x = 2 and (p2.l1 and p1.l2)) (assignments: p1 := p1.l1, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1))) -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) [fixed point]. Controlled behavior: true -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)). @@ -229,12 +218,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (p2.l3 or p1.l2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (p2.l3 or p1.l2))) -> (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (not p2.l2 or p1.l2))) [backward reach with edge: (event: e) (guard: p2.x = 3 and (p2.l1 and p1.l1)) (assignments: p1 := p1.l2, p2 := p2.l3)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (not p2.l2 or p1.l2))) [fixed point]. Controlled behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1)). @@ -243,17 +226,6 @@ Synthesis round 1: Forward controlled-behavior: p2.l1 and p1.l1 [initialization predicate] Forward controlled-behavior: p2.l1 and p1.l1 -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) [restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - Forward reachability iteration 1: - Forward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and p2.l1 [forward reach with edge: (event: e) (guard: p2.x = 1 and (p2.l1 and p1.l1)) (assignments: p1 := p1.l2), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - Forward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and p2.l1 -> p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and (p2.l1 and p1.l1) or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) [forward reach with edge: (event: e) (guard: p2.x = 2 and (p2.l1 and p1.l1)) (assignments: p1 := p1.l2, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - Forward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and (p2.l1 and p1.l1) or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) [forward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - - Forward reachability iteration 2: - Forward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [forward reach with edge: (event: e) (guard: p2.x = 2 and (p2.l1 and p1.l2)) (assignments: p1 := p1.l1, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [fixed point]. Controlled behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1)) -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1). @@ -265,17 +237,6 @@ Synthesis round 2: Backward controlled-behavior: p2.l1 and p1.l1 [marker predicate] Backward controlled-behavior: p2.l1 and p1.l1 -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) [restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - Backward reachability iteration 1: - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and p2.l1 [backward reach with edge: (event: e) (guard: p2.x = 1 and (p2.l1 and p1.l2)) (assignments: p1 := p1.l1), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and p2.l1 -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and (not p2.l3 and p1.l1) or p2.x = 1 and p2.l1) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - - Backward reachability iteration 2: - Backward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and (not p2.l3 and p1.l1) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or p2.x = 1 and p2.l1) [backward reach with edge: (event: e) (guard: p2.x = 2 and (p2.l1 and p1.l2)) (assignments: p1 := p1.l1, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - Backward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [fixed point]. Controlled behavior not changed. @@ -283,9 +244,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p2.x != 0 or (not p2.l1 or p1.l2)) and ((p2.x != 2 or p2.l3) and (p2.x != 1 or not p2.l1)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_event.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_event.cif.out index ad14f554699f112e5f2e05de2dea181a0956cd7e..b80316a7fb7f723bb4132536ce9f7ef683c9f0a9 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_event.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_granularity_simple_per_event.cif.out @@ -201,17 +201,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p2.l1 and p1.l1 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p2.l1 and p1.l1 -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or (p2.x = 1 and p2.l1 or p2.x = 3 and (p2.l1 and p1.l1)) [backward reach with edge: (event: e) (guard: p2.x = 2 and p2.l1 or (p2.x = 1 or p2.x = 3) and p2.l1) (assignments: p1 := p1.l2 / p1 := p1.l2, p2 := p2.l2 / p1 := p1.l2, p2 := p2.l3 / p1 := p1.l1 / p1 := p1.l1, p2 := p2.l2 / p1 := p1.l1, p2 := p2.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or (p2.x = 1 and p2.l1 or p2.x = 3 and (p2.l1 and p1.l1)) -> (p2.x = 0 or p2.x = 2) and (not p2.l3 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (not p2.l3 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1))) [backward reach with edge: (event: e) (guard: p2.x = 2 and p2.l1 or (p2.x = 1 or p2.x = 3) and p2.l1) (assignments: p1 := p1.l2 / p1 := p1.l2, p2 := p2.l2 / p1 := p1.l2, p2 := p2.l3 / p1 := p1.l1 / p1 := p1.l1, p2 := p2.l2 / p1 := p1.l1, p2 := p2.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1))) -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) [fixed point]. Controlled behavior: true -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)). @@ -219,12 +208,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (p2.l3 or p1.l2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (p2.l3 or p1.l2))) -> (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (not p2.l2 or p1.l2))) [backward reach with edge: (event: e) (guard: p2.x = 2 and p2.l1 or (p2.x = 1 or p2.x = 3) and p2.l1) (assignments: p1 := p1.l2 / p1 := p1.l2, p2 := p2.l2 / p1 := p1.l2, p2 := p2.l3 / p1 := p1.l1 / p1 := p1.l1, p2 := p2.l2 / p1 := p1.l1, p2 := p2.l3)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (p2.x != 0 or (p2.l3 or p1.l2)) and (p2.x != 2 or p2.l3) and ((p2.x != 1 or p2.l3) and (p2.x != 3 or (not p2.l2 or p1.l2))) [fixed point]. Controlled behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (not p2.l3 and p1.l1)) -> p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1)). @@ -233,16 +216,6 @@ Synthesis round 1: Forward controlled-behavior: p2.l1 and p1.l1 [initialization predicate] Forward controlled-behavior: p2.l1 and p1.l1 -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) [restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - Forward reachability iteration 1: - Forward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and (p2.l1 and p1.l1) or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) [forward reach with edge: (event: e) (guard: p2.x = 2 and p2.l1 or (p2.x = 1 or p2.x = 3) and p2.l1) (assignments: p1 := p1.l2 / p1 := p1.l2, p2 := p2.l2 / p1 := p1.l2, p2 := p2.l3 / p1 := p1.l1 / p1 := p1.l1, p2 := p2.l2 / p1 := p1.l1, p2 := p2.l3), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - Forward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and (p2.l1 and p1.l1) or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) [forward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - - Forward reachability iteration 2: - Forward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l2) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [forward reach with edge: (event: e) (guard: p2.x = 2 and p2.l1 or (p2.x = 1 or p2.x = 3) and p2.l1) (assignments: p1 := p1.l2 / p1 := p1.l2, p2 := p2.l2 / p1 := p1.l2, p2 := p2.l3 / p1 := p1.l1 / p1 := p1.l1, p2 := p2.l2 / p1 := p1.l1, p2 := p2.l3), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1))] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [fixed point]. Controlled behavior: p2.x = 0 and (not p2.l3 and p1.l1) or p2.x = 2 and not p2.l3 or (p2.x = 1 and not p2.l3 or p2.x = 3 and (p2.l2 and p1.l1)) -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1). @@ -254,17 +227,6 @@ Synthesis round 2: Backward controlled-behavior: p2.l1 and p1.l1 [marker predicate] Backward controlled-behavior: p2.l1 and p1.l1 -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) [restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - Backward reachability iteration 1: - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and (p2.l1 and p1.l1) -> (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and p2.l1 [backward reach with edge: (event: e) (guard: p2.x = 2 and p2.l1 or (p2.x = 1 or p2.x = 3) and p2.l1) (assignments: p1 := p1.l2 / p1 := p1.l2, p2 := p2.l2 / p1 := p1.l2, p2 := p2.l3 / p1 := p1.l1 / p1 := p1.l1, p2 := p2.l2 / p1 := p1.l1, p2 := p2.l3), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and (p2.l1 and p1.l1) or p2.x = 1 and p2.l1 -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and (not p2.l3 and p1.l1) or p2.x = 1 and p2.l1) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - - Backward reachability iteration 2: - Backward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and (not p2.l3 and p1.l1) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or p2.x = 1 and p2.l1) [backward reach with edge: (event: e) (guard: p2.x = 2 and p2.l1 or (p2.x = 1 or p2.x = 3) and p2.l1) (assignments: p1 := p1.l2 / p1 := p1.l2, p2 := p2.l2 / p1 := p1.l2, p2 := p2.l3 / p1 := p1.l1 / p1 := p1.l1, p2 := p2.l2 / p1 := p1.l1, p2 := p2.l3), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - Backward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or p2.x = 2 and p2.l1 or (p2.x = 2 and (p2.l2 and p1.l1) or p2.x = 1 and p2.l1) -> p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [backward reach with edge: (event: a) (guard: p2.l2) (assignments: p2 := p2.l1), restricted to current/previous controlled-behavior predicate: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1)] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: p2.x = 0 and (p2.l1 and p1.l1) or (p2.x = 2 and not p2.l3 or p2.x = 1 and p2.l1) [fixed point]. Controlled behavior not changed. @@ -272,9 +234,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p2.x != 0 or (not p2.l1 or p1.l2)) and ((p2.x != 2 or p2.l3) and (p2.x != 1 or not p2.l1)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_basic.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_basic.cif.out index c7d5fe8afbf8d44b73c6c0b7549123be0d9ff91b..e298bcb2855dd089b0d941a6012d4d10a699bdbf 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_basic.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_basic.cif.out @@ -127,25 +127,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_no.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_no.cif.out index d17273f7ff2d779a5ec698f77e7ee939aa9af2dc..a460ebabcb7fc6659eec30c30fd6e547c70a1486 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_no.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_no.cif.out @@ -203,30 +203,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: Counter.zero and Actuator.Off [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.one) (assignments: Counter := Counter.zero), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.two) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.three) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.four) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.five) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) [backward reach with edge: (event: Actuator.off) (guard: Actuator.On -> Counter.five and Actuator.On) (assignments: Actuator := Actuator.Off), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) -> (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) -> (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) [backward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) -> not Counter.zero and not Counter.one or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: not Counter.zero and not Counter.one or Actuator.Off -> not Counter.zero or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: not Counter.zero or Actuator.Off -> true [backward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -239,24 +215,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: Counter.zero and Actuator.Off [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) -> Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or ((Counter.one or Counter.five) and Actuator.Off or Counter.three and Actuator.Off)) [forward reach with edge: (event: Actuator.on) (guard: Actuator.Off -> Counter.zero and Actuator.Off) (assignments: Actuator := Actuator.On), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or ((Counter.one or Counter.five) and Actuator.Off or Counter.three and Actuator.Off)) -> (not Counter.four and not Counter.five or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four and not Counter.five or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) -> (not Counter.four or Actuator.Off) and ((not Counter.five or Actuator.Off) and (not Counter.three or Actuator.Off)) [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four or Actuator.Off) and ((not Counter.five or Actuator.Off) and (not Counter.three or Actuator.Off)) -> not Counter.four and not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and not Counter.five or Actuator.Off -> not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.five or Actuator.Off -> true [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -315,15 +273,15 @@ Simplifying supervisor guards for output model: Constructing output CIF specification. BDD cache statistics: - Node creation requests: 690 + Node creation requests: 691 Node creation chain accesses: 0 Node creation cache hits: 462 Node creation cache misses: 146 - Operation count: 2515 - Operation cache hits: 268 - Operation cache misses: 540 + Operation count: 2565 + Operation cache hits: 280 + Operation cache misses: 543 -Maximum used BDD nodes: 102. +Maximum used BDD nodes: 95. Checking output CIF specification. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_yes.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_yes.cif.out index 11e54b7d48e3f93383dd02bed0478ea50331eae6..01957674398756973ff427c313c70e0e4b2b217c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_yes.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_custom_dupl_yes.cif.out @@ -311,8 +311,8 @@ BDD cache statistics: Node creation chain accesses: 0 Node creation cache hits: 436 Node creation cache misses: 146 - Operation count: 2685 - Operation cache hits: 517 + Operation count: 2709 + Operation cache hits: 518 Operation cache misses: 504 Maximum used BDD nodes: 102. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_model.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_model.cif.out index 98cb6f4e1f784f28a0b322e9477903d141d3a5da..be732709403839c5339365352a0c02f25c2bd470 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_model.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_model.cif.out @@ -126,25 +126,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_random.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_random.cif.out index cab31193bd134e11d4b5a095efa680cd5d84c7bb..ffc0630dabc257dc64838dfec95843f52211f012 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_random.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_random.cif.out @@ -126,25 +126,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_model.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_model.cif.out index 76b99abe4f2ce78a1bc5b866252fd92673d2f91a..37d78799b8f9096572197cff3ac917b62f84abb5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_model.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_model.cif.out @@ -126,25 +126,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_sorted.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_sorted.cif.out index 61e6a9a91791898402a040a6087298cf3e304043..79f229a749c4099e6173dad1d139f64cf0e77e34 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_sorted.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_reverse_sorted.cif.out @@ -126,25 +126,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_sorted.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_sorted.cif.out index c7ac2ac09e1b8dade5fad6ef4988e88627b859df..cc128bc3dc5b41956554d619d61ded15f744ab13 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_sorted.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_both_sorted.cif.out @@ -126,25 +126,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_default.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_default.cif.out index a823f723712002807608fd11f40db1dba05494db..1862b3fbb8b451a754bd4b600868f15ddc94b098 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_default.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_default.cif.out @@ -126,25 +126,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_off.cif.out index c29099b9b141552e2fea9477be41405475d0498b..ac8cadee35795d3281f2bdb981dcd25e29553492 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_off.cif.out @@ -203,32 +203,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: Counter.zero and Actuator.Off [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.one) (assignments: Counter := Counter.zero), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.two) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.three) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.four) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.five) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) [backward reach with edge: (event: Actuator.off) (guard: Actuator.On -> Counter.five and Actuator.On) (assignments: Actuator := Actuator.Off), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) -> (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) -> (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) [backward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) -> not Counter.zero and not Counter.one or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: not Counter.zero and not Counter.one or Actuator.Off -> not Counter.zero or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: not Counter.zero or Actuator.Off -> true [backward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_on.cif.out index 61512cf16348e900d082d9031606c57973995748..e348ab15e525b7c2b074082a2e061b7fcd69c6c8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_forward_random_on.cif.out @@ -203,32 +203,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: Counter.zero and Actuator.Off [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.one) (assignments: Counter := Counter.zero), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.two) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.three) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.four) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.five) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) [backward reach with edge: (event: Actuator.off) (guard: Actuator.On -> Counter.five and Actuator.On) (assignments: Actuator := Actuator.Off), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) -> (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) -> (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) [backward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) -> not Counter.zero and not Counter.one or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: not Counter.zero and not Counter.one or Actuator.Off -> not Counter.zero or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: not Counter.zero or Actuator.Off -> true [backward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -241,26 +215,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: Counter.zero and Actuator.Off [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [forward reach with edge: (event: Actuator.on) (guard: Actuator.Off -> Counter.zero and Actuator.Off) (assignments: Actuator := Actuator.On), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three and Actuator.Off)) [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three and Actuator.Off)) -> (not Counter.four or Actuator.Off) and (not Counter.five and (not Counter.three or Actuator.Off)) [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four or Actuator.Off) and (not Counter.five and (not Counter.three or Actuator.Off)) -> (not Counter.four or Actuator.Off) and not Counter.five [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four or Actuator.Off) and not Counter.five -> not Counter.four and not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and not Counter.five or Actuator.Off -> not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: not Counter.five or Actuator.Off -> true [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_backward_random.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_backward_random.cif.out index 99adf1558879be002128c93240ef4e5abdc8184c..6d554f87e5477292a4b90e12db0e747660959a95 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_backward_random.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_backward_random.cif.out @@ -203,34 +203,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: Counter.zero and Actuator.Off [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.one) (assignments: Counter := Counter.zero), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.two) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.three) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.four) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.five) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) [backward reach with edge: (event: Actuator.off) (guard: Actuator.On -> Counter.five and Actuator.On) (assignments: Actuator := Actuator.Off), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) -> (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) -> (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) [backward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) -> not Counter.zero and not Counter.one or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: not Counter.zero and not Counter.one or Actuator.Off -> not Counter.zero or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - Backward controlled-behavior: not Counter.zero or Actuator.Off -> true [backward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 8: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -243,24 +215,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: Counter.zero and Actuator.Off [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) -> Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or ((Counter.one or Counter.five) and Actuator.Off or Counter.three and Actuator.Off)) [forward reach with edge: (event: Actuator.on) (guard: Actuator.Off -> Counter.zero and Actuator.Off) (assignments: Actuator := Actuator.On), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or ((Counter.one or Counter.five) and Actuator.Off or Counter.three and Actuator.Off)) -> (not Counter.four and not Counter.five or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four and not Counter.five or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) -> (not Counter.four or Actuator.Off) and ((not Counter.five or Actuator.Off) and (not Counter.three or Actuator.Off)) [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four or Actuator.Off) and ((not Counter.five or Actuator.Off) and (not Counter.three or Actuator.Off)) -> not Counter.four and not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and not Counter.five or Actuator.Off -> not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.five or Actuator.Off -> true [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_forward_random.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_forward_random.cif.out index 52aeb9a03f1ab55aacdf1a2490cd2639a73b1246..5cca39e47f7c9ef3bfad929260297e0e1086d7c3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_forward_random.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/edge_order_single_forward_random.cif.out @@ -203,32 +203,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: Counter.zero and Actuator.Off [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.one) (assignments: Counter := Counter.zero), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [backward reach with edge: (event: Counter.dec) (guard: Counter.two) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.three) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.four) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.dec) (guard: Counter.five) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (Counter.two or (Counter.three or Actuator.Off)) and (not Counter.two and not Counter.three or Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) [backward reach with edge: (event: Actuator.off) (guard: Actuator.On -> Counter.five and Actuator.On) (assignments: Actuator := Actuator.Off), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or Counter.two and Actuator.Off or (Counter.one and Actuator.Off or (Counter.five or Counter.three and Actuator.Off)) -> (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) [backward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (not Counter.zero and not Counter.one or Actuator.Off) and (not Counter.two and not Counter.three or Actuator.Off) -> (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) [backward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: (not Counter.zero or Actuator.Off) and ((not Counter.two or Actuator.Off) and (not Counter.one or Actuator.Off)) -> not Counter.zero and not Counter.one or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: not Counter.zero and not Counter.one or Actuator.Off -> not Counter.zero or Actuator.Off [backward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: not Counter.zero or Actuator.Off -> true [backward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -241,26 +215,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: Counter.zero and Actuator.Off [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: Counter.zero and Actuator.Off -> (Counter.zero or Counter.one) and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.one) and Actuator.Off -> (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.two) and Actuator.Off or Counter.one and Actuator.Off -> not Counter.four and (not Counter.five and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and (not Counter.five and Actuator.Off) -> (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (Counter.zero or Counter.four) and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) [forward reach with edge: (event: Actuator.on) (guard: Actuator.Off -> Counter.zero and Actuator.Off) (assignments: Actuator := Actuator.On), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three) and Actuator.Off) -> Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three and Actuator.Off)) [forward reach with edge: (event: Counter.inc) (guard: Counter.zero) (assignments: Counter := Counter.one), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: Counter.zero or Counter.four and Actuator.Off or (Counter.two and Actuator.Off or (Counter.one or Counter.three and Actuator.Off)) -> (not Counter.four or Actuator.Off) and (not Counter.five and (not Counter.three or Actuator.Off)) [forward reach with edge: (event: Counter.inc) (guard: Counter.one) (assignments: Counter := Counter.two), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four or Actuator.Off) and (not Counter.five and (not Counter.three or Actuator.Off)) -> (not Counter.four or Actuator.Off) and not Counter.five [forward reach with edge: (event: Counter.inc) (guard: Counter.two) (assignments: Counter := Counter.three), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (not Counter.four or Actuator.Off) and not Counter.five -> not Counter.four and not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not Counter.four and not Counter.five or Actuator.Off -> not Counter.five or Actuator.Off [forward reach with edge: (event: Counter.inc) (guard: Counter.three) (assignments: Counter := Counter.four), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: not Counter.five or Actuator.Off -> true [forward reach with edge: (event: Counter.inc) (guard: Counter.four) (assignments: Counter := Counter.five), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/enums.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/enums.cif.out index 4e6d6ed0072f30b8b038f9b0aa09a7bb2f4c3934..66ed1821d3e25a6022c3dc396a0e71b9e0942331 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/enums.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/enums.cif.out @@ -202,21 +202,6 @@ Synthesis round 1: Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.B or g.p.x5 = g.D))) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.B or g.p.x5 = g.D)))) [marker predicate] Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.B or g.p.x5 = g.D))) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.B or g.p.x5 = g.D)))) -> g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))) [restricted to current/previous controlled-behavior predicate: <bdd 20n 1,458p>] - Backward reachability iteration 1: - Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))) -> <bdd 21n 8p> [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.D) (assignments: g.p.x0 := g.E), restricted to current/previous controlled-behavior predicate: <bdd 20n 1,458p>] - - Backward reachability iteration 2: - Backward controlled-behavior: <bdd 21n 8p> -> <bdd 21n 12p> [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.C) (assignments: g.p.x0 := g.D), restricted to current/previous controlled-behavior predicate: <bdd 20n 1,458p>] - - Backward reachability iteration 3: - Backward controlled-behavior: <bdd 21n 12p> -> g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))) [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.B) (assignments: g.p.x0 := g.C), restricted to current/previous controlled-behavior predicate: <bdd 20n 1,458p>] - - Backward reachability iteration 4: - Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))) -> (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))) [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.A) (assignments: g.p.x0 := g.B), restricted to current/previous controlled-behavior predicate: <bdd 20n 1,458p>] - - Backward reachability iteration 5: - No change this iteration. - Backward controlled-behavior: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))) [fixed point]. Controlled behavior: <bdd 20n 1,458p> -> (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))). @@ -230,15 +215,6 @@ Synthesis round 1: Forward controlled-behavior: g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.A or g.p.x4 = g.E) and (g.p.x5 = g.C and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and g.p.x4 = g.C and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and g.p.x4 = g.C and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and g.p.x4 = g.C and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.B or g.p.x4 = g.D) and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.A or g.p.x4 = g.E) and (g.p.x5 = g.C and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and g.p.x4 = g.C and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and g.p.x4 = g.C and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and g.p.x4 = g.C and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.B or g.p.x4 = g.D) and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))))) [initialization predicate] Forward controlled-behavior: g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.A or g.p.x4 = g.E) and (g.p.x5 = g.C and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and g.p.x4 = g.C and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and g.p.x4 = g.C and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and g.p.x4 = g.C and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.B or g.p.x4 = g.D) and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.A and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.A or g.p.x4 = g.E) and (g.p.x5 = g.C and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.A or g.p.x4 = g.E) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and g.p.x4 = g.C and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and g.p.x4 = g.C and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and g.p.x4 = g.C and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.B or g.p.x4 = g.D) and (g.p.x5 = g.C and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and ((g.p.x3 = g.B or g.p.x3 = g.D) and (g.p.x4 = g.B or g.p.x4 = g.D) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))))) -> g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) [restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))))] - Forward reachability iteration 1: - Forward controlled-behavior: g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.A and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) -> (g.p.x0 = g.A or g.p.x0 = g.B) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.B) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) [forward reach with edge: (event: g.e1) (guard: g.p.x0 = g.A) (assignments: g.p.x0 := g.B), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))))] - Forward controlled-behavior: (g.p.x0 = g.A or g.p.x0 = g.B) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.B) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) -> (g.p.x0 = g.A or g.p.x0 = g.C) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.C) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.B and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))) [forward reach with edge: (event: g.e1) (guard: g.p.x0 = g.B) (assignments: g.p.x0 := g.C), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))))] - Forward controlled-behavior: (g.p.x0 = g.A or g.p.x0 = g.C) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.C) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.B and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))) -> g.p.x0 != g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 != g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) [forward reach with edge: (event: g.e1) (guard: g.p.x0 = g.C) (assignments: g.p.x0 := g.D), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))))] - Forward controlled-behavior: g.p.x0 != g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 != g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) -> (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))) [forward reach with edge: (event: g.e1) (guard: g.p.x0 = g.D) (assignments: g.p.x0 := g.E), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))) [fixed point]. Controlled behavior: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G))) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 != g.G))) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 != g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))) -> (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))). @@ -250,21 +226,6 @@ Synthesis round 2: Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.B or g.p.x5 = g.D))) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.B or g.p.x5 = g.D)))) [marker predicate] Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A and (g.p.x5 = g.B or g.p.x5 = g.D))) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.A or g.p.x5 = g.E))) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.B and (g.p.x5 = g.B or g.p.x5 = g.D)))) -> g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) [restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))] - Backward reachability iteration 1: - Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) -> <bdd 21n 4p> [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.D) (assignments: g.p.x0 := g.E), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))] - - Backward reachability iteration 2: - Backward controlled-behavior: <bdd 21n 4p> -> <bdd 21n 6p> [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.C) (assignments: g.p.x0 := g.D), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))] - - Backward reachability iteration 3: - Backward controlled-behavior: <bdd 21n 6p> -> g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))) [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.B) (assignments: g.p.x0 := g.C), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))] - - Backward reachability iteration 4: - Backward controlled-behavior: g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.E and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))) -> (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))) [backward reach with edge: (event: g.e1) (guard: g.p.x0 = g.A) (assignments: g.p.x0 := g.B), restricted to current/previous controlled-behavior predicate: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G))))] - - Backward reachability iteration 5: - No change this iteration. - Backward controlled-behavior: (g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or ((g.p.x0 = g.A or g.p.x0 = g.E) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G))) or (g.p.x0 = g.C and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)) or ((g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.A or g.p.x5 = g.E) and g.p.x6 = g.G)) or (g.p.x0 = g.B or g.p.x0 = g.D) and (g.p.x1 = g.A and g.p.x2 = g.B) and (g.p.x3 = g.D and (g.p.x4 = g.A or g.p.x4 = g.B) and ((g.p.x5 = g.B or g.p.x5 = g.D) and g.p.x6 = g.G)))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out index d9c1367239bca41f5e1f1ac92aa0e260c676e409..b9a7916ae98a530f069ecf9b9bc3e69eddd53378 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out @@ -450,9 +450,6 @@ Synthesis round 1: Backward controlled-behavior: p.l1 and q.l1 [marker predicate] Backward controlled-behavior: p.l1 and q.l1 -> <bdd 66n 244,140,625p> [restricted to current/previous controlled-behavior predicate: <bdd 65n 488,281,250p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 66n 244,140,625p> [fixed point]. Controlled behavior: <bdd 65n 488,281,250p> -> <bdd 66n 244,140,625p>. @@ -460,12 +457,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 66n 261,233,718p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: <bdd 66n 261,233,718p> -> <bdd 65n 212,405,593p> [backward reach with edge: (event: q.u13) (guard: q.l1 and q.v13 = 10) (assignments: q.v13 := q.v13 + 1)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: <bdd 65n 212,405,593p> [fixed point]. Controlled behavior: <bdd 66n 244,140,625p> -> <bdd 65n 146,484,375p>. @@ -473,12 +464,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: <bdd 69n 1p> [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: <bdd 69n 1p> -> <bdd 70n 2p> [forward reach with edge: (event: c_off) (guard: a.l1 and b.l1) (assignments: a := a.l2, b := b.l2), restricted to current/previous controlled-behavior predicate: <bdd 65n 146,484,375p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 70n 2p> [fixed point]. Controlled behavior: <bdd 65n 146,484,375p> -> <bdd 70n 2p>. @@ -490,9 +475,6 @@ Synthesis round 2: Backward controlled-behavior: p.l1 and q.l1 [marker predicate] Backward controlled-behavior: p.l1 and q.l1 -> <bdd 70n 2p> [restricted to current/previous controlled-behavior predicate: <bdd 70n 2p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 70n 2p> [fixed point]. Controlled behavior not changed. @@ -500,9 +482,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 70n 69p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/evts.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/evts.cif.out index a3dda9d5ee33e4e12f1616ceb055db45223b9901..7efb705301a2eb65e85f6919b785649776321869 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/evts.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/evts.cif.out @@ -111,9 +111,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> false [restricted to current/previous controlled-behavior predicate: false] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: false [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out index 951cade7bac6c2076cfc78ab261b2aec89f0f3ac..e6613a194388e1eca315dd4ac3f456256c6272be 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out @@ -215,16 +215,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) -> Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) or Button1.Pushed and (LampOnWhileButtonPushed.Pushed and Lamp1.Off) [backward reach with edge: (event: Button1.u_released) (guard: Button1.Pushed and LampOnWhileButtonPushed.Pushed) (assignments: Button1 := Button1.Released, LampOnWhileButtonPushed := LampOnWhileButtonPushed.Released), restricted to current/previous controlled-behavior predicate: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed)] - Backward controlled-behavior: Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) or Button1.Pushed and (LampOnWhileButtonPushed.Pushed and Lamp1.Off) -> Button1.Released and LampOnWhileButtonPushed.Released or Button1.Pushed and (LampOnWhileButtonPushed.Pushed and Lamp1.Off) [backward reach with edge: (event: Lamp1.c_off) (guard: LampOnWhileButtonPushed.Released and Lamp1.On) (assignments: Lamp1 := Lamp1.Off), restricted to current/previous controlled-behavior predicate: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed)] - - Backward reachability iteration 2: - Backward controlled-behavior: Button1.Released and LampOnWhileButtonPushed.Released or Button1.Pushed and (LampOnWhileButtonPushed.Pushed and Lamp1.Off) -> (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed) [backward reach with edge: (event: Button1.u_released) (guard: Button1.Pushed and LampOnWhileButtonPushed.Pushed) (assignments: Button1 := Button1.Released, LampOnWhileButtonPushed := LampOnWhileButtonPushed.Released), restricted to current/previous controlled-behavior predicate: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed)] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed) [fixed point]. Controlled behavior not changed. @@ -232,24 +222,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (Button1.Pushed or LampOnWhileButtonPushed.Pushed) and (Button1.Released or LampOnWhileButtonPushed.Released) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) -> Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) or Button1.Pushed and (LampOnWhileButtonPushed.Pushed and Lamp1.Off) [forward reach with edge: (event: Button1.u_pushed) (guard: Button1.Released and LampOnWhileButtonPushed.Released) (assignments: Button1 := Button1.Pushed, LampOnWhileButtonPushed := LampOnWhileButtonPushed.Pushed), restricted to current/previous controlled-behavior predicate: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed)] - Forward controlled-behavior: Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) or Button1.Pushed and (LampOnWhileButtonPushed.Pushed and Lamp1.Off) -> Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) or Button1.Pushed and LampOnWhileButtonPushed.Pushed [forward reach with edge: (event: Lamp1.c_on) (guard: LampOnWhileButtonPushed.Pushed and Lamp1.Off) (assignments: Lamp1 := Lamp1.On), restricted to current/previous controlled-behavior predicate: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed)] - - Forward reachability iteration 2: - Forward controlled-behavior: Button1.Released and (LampOnWhileButtonPushed.Released and Lamp1.Off) or Button1.Pushed and LampOnWhileButtonPushed.Pushed -> (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed) [forward reach with edge: (event: Button1.u_released) (guard: Button1.Pushed and LampOnWhileButtonPushed.Pushed) (assignments: Button1 := Button1.Released, LampOnWhileButtonPushed := LampOnWhileButtonPushed.Released), restricted to current/previous controlled-behavior predicate: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed)] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: (Button1.Pushed or LampOnWhileButtonPushed.Released) and (Button1.Released or LampOnWhileButtonPushed.Pushed) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out index e810452d192af747f0e8dca611d2ca0af17e27ba..e4433d9a52f5c461b8fc35a4af3fb1ee7347119c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out @@ -197,12 +197,6 @@ Synthesis round 1: Backward controlled-behavior: p.L0 [marker predicate] Backward controlled-behavior: p.L0 -> not(2 <= p.x and p.x <= 7) and p.L0 or ((p.x = 4 or p.x = 5) and p.L0 or (p.x = 2 or p.x = 3 or (p.x = 6 or p.x = 7)) and p.L0) [restricted to current/previous controlled-behavior predicate: (p.x != 8 or p.L0) and ((p.x != 6 or p.L0) and (p.x != 7 or p.L0))] - Backward reachability iteration 1: - Backward controlled-behavior: not(2 <= p.x and p.x <= 7) and p.L0 or ((p.x = 4 or p.x = 5) and p.L0 or (p.x = 2 or p.x = 3 or (p.x = 6 or p.x = 7)) and p.L0) -> (0 <= p.x and p.x <= 7 or p.L0) and (not(p.x = 6 or p.x = 7) or p.L0) [backward reach with edge: (event: e2) (guard: (p.x = 0 or p.x = 8) and p.L1 or p.x = 4 and p.L1 or ((p.x = 2 or p.x = 6) and p.L1 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.L1)) (assignments: p.x := p.x + 1, p := p.L0), restricted to current/previous controlled-behavior predicate: (p.x != 8 or p.L0) and ((p.x != 6 or p.L0) and (p.x != 7 or p.L0))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (0 <= p.x and p.x <= 7 or p.L0) and (not(p.x = 6 or p.x = 7) or p.L0) [fixed point]. Controlled behavior: (p.x != 8 or p.L0) and ((p.x != 6 or p.L0) and (p.x != 7 or p.L0)) -> (0 <= p.x and p.x <= 7 or p.L0) and (not(p.x = 6 or p.x = 7) or p.L0). @@ -210,21 +204,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 8 or p.x = 9) and p.L1 or (p.x = 6 or p.x = 7) and p.L1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 2 and p.L0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 2 and p.L0 -> p.x = 4 and p.L1 or p.x = 2 and p.L0 [forward reach with edge: (event: e1) (guard: 0 <= p.x and (p.x <= 7 and p.L0) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.L0 or ((p.x = 1 or p.x = 5) and p.L0 or p.x = 3 and p.L0)) (assignments: p.x := p.x + 2, p := p.L1), restricted to current/previous controlled-behavior predicate: (0 <= p.x and p.x <= 7 or p.L0) and (not(p.x = 6 or p.x = 7) or p.L0)] - Forward controlled-behavior: p.x = 4 and p.L1 or p.x = 2 and p.L0 -> p.x = 4 and p.L1 or (p.x = 2 and p.L0 or p.x = 5 and p.L0) [forward reach with edge: (event: e2) (guard: (p.x = 0 or p.x = 8) and p.L1 or p.x = 4 and p.L1 or ((p.x = 2 or p.x = 6) and p.L1 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.L1)) (assignments: p.x := p.x + 1, p := p.L0), restricted to current/previous controlled-behavior predicate: (0 <= p.x and p.x <= 7 or p.L0) and (not(p.x = 6 or p.x = 7) or p.L0)] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 4 and p.L1 or (p.x = 2 and p.L0 or p.x = 5 and p.L0) [fixed point]. Controlled behavior: (0 <= p.x and p.x <= 7 or p.L0) and (not(p.x = 6 or p.x = 7) or p.L0) -> p.x = 4 and p.L1 or (p.x = 2 and p.L0 or p.x = 5 and p.L0). @@ -236,12 +220,6 @@ Synthesis round 2: Backward controlled-behavior: p.L0 [marker predicate] Backward controlled-behavior: p.L0 -> p.x = 2 and p.L0 or p.x = 5 and p.L0 [restricted to current/previous controlled-behavior predicate: p.x = 4 and p.L1 or (p.x = 2 and p.L0 or p.x = 5 and p.L0)] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 2 and p.L0 or p.x = 5 and p.L0 -> p.x = 4 and p.L1 or (p.x = 2 and p.L0 or p.x = 5 and p.L0) [backward reach with edge: (event: e2) (guard: (p.x = 0 or p.x = 8) and p.L1 or p.x = 4 and p.L1 or ((p.x = 2 or p.x = 6) and p.L1 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.L1)) (assignments: p.x := p.x + 1, p := p.L0), restricted to current/previous controlled-behavior predicate: p.x = 4 and p.L1 or (p.x = 2 and p.L0 or p.x = 5 and p.L0)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 4 and p.L1 or (p.x = 2 and p.L0 or p.x = 5 and p.L0) [fixed point]. Controlled behavior not changed. @@ -249,9 +227,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 4 or p.L0) and ((p.x != 2 or p.L1) and (p.x != 5 or p.L1)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out index 478878115c4220b29ef4a98c2c4f0b9fc49d5d92..c3a383fefb4ab9c1fd3a96345dfc9d8cb42c946e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out @@ -198,12 +198,6 @@ Synthesis round 1: Backward controlled-behavior: p.L0 [marker predicate] Backward controlled-behavior: p.L0 -> (p.x = 0 or p.x = 8) and p.L0 or (p.x = 2 or p.x = 6) and p.L0 or ((p.x = 1 or p.x = 9) and p.L0 or (p.x = 5 and p.L0 or (p.x = 3 or p.x = 7) and p.L0)) [restricted to current/previous controlled-behavior predicate: (p.x != 8 or p.L0) and p.x != 4 and ((p.x != 6 or p.L0) and (p.x != 7 or p.L0))] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 8) and p.L0 or (p.x = 2 or p.x = 6) and p.L0 or ((p.x = 1 or p.x = 9) and p.L0 or (p.x = 5 and p.L0 or (p.x = 3 or p.x = 7) and p.L0)) -> (p.x != 8 or p.L0) and p.x != 4 and ((p.x != 6 or p.L0) and ((p.x != 9 or p.L0) and (not(p.x = 3 or p.x = 7) or p.L0))) [backward reach with edge: (event: e2) (guard: (p.x = 0 or p.x = 8) and p.L1 or p.x = 4 and p.L1 or ((p.x = 2 or p.x = 6) and p.L1 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.L1)) (assignments: p.x := p.x + 1, p := p.L0), restricted to current/previous controlled-behavior predicate: (p.x != 8 or p.L0) and p.x != 4 and ((p.x != 6 or p.L0) and (p.x != 7 or p.L0))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 8 or p.L0) and p.x != 4 and ((p.x != 6 or p.L0) and ((p.x != 9 or p.L0) and (not(p.x = 3 or p.x = 7) or p.L0))) [fixed point]. Controlled behavior: (p.x != 8 or p.L0) and p.x != 4 and ((p.x != 6 or p.L0) and (p.x != 7 or p.L0)) -> (p.x != 8 or p.L0) and p.x != 4 and ((p.x != 6 or p.L0) and ((p.x != 9 or p.L0) and (not(p.x = 3 or p.x = 7) or p.L0))). @@ -211,17 +205,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 8 and p.L1 or p.x = 4 or (p.x = 6 and p.L1 or (p.x = 9 and p.L1 or (p.x = 3 or p.x = 7) and p.L1)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 2 and p.L0 [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior: (p.x != 8 or p.L0) and p.x != 4 and ((p.x != 6 or p.L0) and ((p.x != 9 or p.L0) and (not(p.x = 3 or p.x = 7) or p.L0))) -> p.x = 2 and p.L0. Need another round. @@ -231,9 +219,6 @@ Synthesis round 2: Backward controlled-behavior: p.L0 [marker predicate] Backward controlled-behavior: p.L0 -> p.x = 2 and p.L0 [restricted to current/previous controlled-behavior predicate: p.x = 2 and p.L0] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 2 and p.L0 [fixed point]. Controlled behavior not changed. @@ -241,9 +226,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 2 or p.L1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point.cif.out index 71feb1adecaccc45928fd3cccf792f5f535b9ba4..5480424bbecd91d1bb78e16c447a7012e78ed77a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point.cif.out @@ -176,9 +176,6 @@ Synthesis round 1: Backward controlled-behavior: p.l0 and p.x = 1 or p.l1 and (p.x = 1 and p.y = 1) [marker predicate] Backward controlled-behavior: p.l0 and p.x = 1 or p.l1 and (p.x = 1 and p.y = 1) -> (p.l1 or p.x = 1) and ((p.l0 or p.x = 1) and (p.l0 or (p.x = 2 or p.y = 1))) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: (p.l1 or p.x = 1) and ((p.l0 or p.x = 1) and (p.l0 or (p.x = 2 or p.y = 1))) [fixed point]. Controlled behavior: true -> (p.l1 or p.x = 1) and ((p.l0 or p.x = 1) and (p.l0 or (p.x = 2 or p.y = 1))). @@ -191,12 +188,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l0 and (p.x = 1 and p.y = 1) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.l0 and (p.x = 1 and p.y = 1) -> p.x = 1 and p.y = 1 [forward reach with edge: (event: c) (guard: p.l0) (assignments: p := p.l1), restricted to current/previous controlled-behavior predicate: (p.l1 or p.x = 1) and ((p.l0 or p.x = 1) and (p.l0 or (p.x = 2 or p.y = 1)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.x = 1 and p.y = 1 [fixed point]. Controlled behavior: (p.l1 or p.x = 1) and ((p.l0 or p.x = 1) and (p.l0 or (p.x = 2 or p.y = 1))) -> p.x = 1 and p.y = 1. @@ -208,9 +199,6 @@ Synthesis round 2: Backward controlled-behavior: p.l0 and p.x = 1 or p.l1 and (p.x = 1 and p.y = 1) [marker predicate] Backward controlled-behavior: p.l0 and p.x = 1 or p.l1 and (p.x = 1 and p.y = 1) -> p.x = 1 and p.y = 1 [restricted to current/previous controlled-behavior predicate: p.x = 1 and p.y = 1] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 1 and p.y = 1 [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_nonblock_reach.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_nonblock_reach.cif.out index 3a38a88b62d89fc20af8f773f7fc8121a66361fe..13cfa0286c2c4dc889b0b52f3e0bad26a768d898 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_nonblock_reach.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_nonblock_reach.cif.out @@ -194,73 +194,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l5 and p.y = 1 -> p.l5 and p.y = 1 or p.l4 and p.y = 1 [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.l5 and p.y = 1 or p.l4 and p.y = 1 -> (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or p.x = 1 and (p.l5 and p.y = 1)) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l4 and p.y = 1))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or p.x = 1 and (p.l5 and p.y = 1)) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l4 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or (p.x = 0 or p.x = 2) and (p.l4 and p.y = 2) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 1))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or (p.x = 0 or p.x = 2) and (p.l4 and p.y = 2) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 1))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3))) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3))))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3))) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3))))) -> p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l3 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l3 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) -> <bdd 21n 17p> [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 21n 17p> -> <bdd 24n 18p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 18p> -> <bdd 22n 19p> [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: <bdd 22n 19p> -> <bdd 21n 19p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 21n 19p> -> <bdd 24n 20p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 20p> -> <bdd 21n 20p> [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - Backward controlled-behavior: <bdd 21n 20p> -> p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 2 and (p.l2 and (p.y = 2 or p.y = 3)) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3))))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 1 and ((p.l2 or p.l4) and p.y = 2) or p.x = 1 and ((p.l2 or p.l4) and (p.y = 1 or p.y = 3)))) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l3 and p.y = 2) or (p.x = 3 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 2 and (p.l2 and (p.y = 2 or p.y = 3)) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3))))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 1 and ((p.l2 or p.l4) and p.y = 2) or p.x = 1 and ((p.l2 or p.l4) and (p.y = 1 or p.y = 3)))) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l3 and p.y = 2) or (p.x = 3 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) -> <bdd 21n 20p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 8: - Backward controlled-behavior: <bdd 21n 20p> -> <bdd 23n 21p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 23n 21p> -> <bdd 23n 21p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 9: - Backward controlled-behavior: <bdd 23n 21p> -> <bdd 23n 22p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 23n 22p> -> <bdd 25n 22p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 25n 22p> -> <bdd 23n 22p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 10: - Backward controlled-behavior: <bdd 23n 22p> -> <bdd 22n 23p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 22n 23p> -> <bdd 24n 24p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 24p> -> <bdd 24n 25p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 11: - Backward controlled-behavior: <bdd 24n 25p> -> <bdd 21n 27p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 21n 27p> -> <bdd 24n 26p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 24n 26p> -> <bdd 20n 26p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 20n 26p> -> (p.x != 0 or (not p.l1 or p.y != 0)) and ((p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and (p.x != 0 or (not p.l5 or p.y != 3))) and ((p.x != 0 or not p.l3) and (p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 14: - Backward controlled-behavior: (p.x != 0 or (not p.l1 or p.y != 0)) and ((p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and (p.x != 0 or (not p.l5 or p.y != 3))) and ((p.x != 0 or not p.l3) and (p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) -> (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [fixed point]. Controlled behavior: true -> (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))). @@ -268,30 +206,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 and p.y = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.l1 and p.y = 0 -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) [forward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 4: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 5: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> <bdd 23n 11p> [forward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 6: - No change this iteration. - Forward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) -> <bdd 23n 11p>. @@ -302,60 +216,12 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 23n 30p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] Backward controlled-behavior: p.l5 and p.y = 1 -> p.x = 1 and (p.l5 and p.y = 1) [restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 5: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 6: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 7: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 8: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 9: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 10: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 11: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> <bdd 22n 8p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 22n 8p> -> <bdd 21n 9p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 21n 9p> -> <bdd 21n 10p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 14: - Backward controlled-behavior: <bdd 21n 10p> -> <bdd 23n 11p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_reach_nonblock.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_reach_nonblock.cif.out index b17cf8ec76b9285d1f0960895db998f4ba6cf2be..aab653d2c257dfb207e6da5e5fbddc588d965b13 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_reach_nonblock.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_ctrl_reach_nonblock.cif.out @@ -194,38 +194,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 and p.y = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.l1 and p.y = 0 -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) [forward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> <bdd 23n 11p> [forward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - No change this iteration. - Forward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior: true -> <bdd 23n 11p>. @@ -234,51 +207,6 @@ Synthesis round 1: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] Backward controlled-behavior: p.l5 and p.y = 1 -> p.x = 1 and (p.l5 and p.y = 1) [restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 5: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 6: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 7: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 8: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 9: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 10: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 11: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> <bdd 22n 8p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 22n 8p> -> <bdd 21n 9p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 21n 9p> -> <bdd 21n 10p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 14: - Backward controlled-behavior: <bdd 21n 10p> -> <bdd 23n 11p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior not changed. @@ -289,9 +217,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 23n 30p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_ctrl_reach.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_ctrl_reach.cif.out index 611d9578ac30df8bb473b885176015177df65d71..1aca791be3d391028627a500a3acb55eabde6bba 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_ctrl_reach.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_ctrl_reach.cif.out @@ -194,65 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l5 and p.y = 1 -> p.l5 and p.y = 1 or p.l4 and p.y = 1 [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.l5 and p.y = 1 or p.l4 and p.y = 1 -> (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or p.x = 1 and (p.l5 and p.y = 1)) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l4 and p.y = 1))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or p.x = 1 and (p.l5 and p.y = 1)) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l4 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or (p.x = 0 or p.x = 2) and (p.l4 and p.y = 2) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 1))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or (p.x = 0 or p.x = 2) and (p.l4 and p.y = 2) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 1))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3))) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3))))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3))) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3))))) -> p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l3 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l3 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) -> <bdd 21n 17p> [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 21n 17p> -> <bdd 24n 18p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 18p> -> <bdd 22n 19p> [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: <bdd 22n 19p> -> <bdd 21n 19p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 21n 19p> -> <bdd 24n 20p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 20p> -> <bdd 21n 20p> [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - Backward controlled-behavior: <bdd 21n 20p> -> p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 2 and (p.l2 and (p.y = 2 or p.y = 3)) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3))))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 1 and ((p.l2 or p.l4) and p.y = 2) or p.x = 1 and ((p.l2 or p.l4) and (p.y = 1 or p.y = 3)))) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l3 and p.y = 2) or (p.x = 3 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 2 and (p.l2 and (p.y = 2 or p.y = 3)) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3))))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 1 and ((p.l2 or p.l4) and p.y = 2) or p.x = 1 and ((p.l2 or p.l4) and (p.y = 1 or p.y = 3)))) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l3 and p.y = 2) or (p.x = 3 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) -> <bdd 21n 20p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 8: - Backward controlled-behavior: <bdd 21n 20p> -> <bdd 23n 21p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 23n 21p> -> <bdd 23n 21p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 9: - Backward controlled-behavior: <bdd 23n 21p> -> <bdd 23n 22p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 23n 22p> -> <bdd 25n 22p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 25n 22p> -> <bdd 23n 22p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 10: - Backward controlled-behavior: <bdd 23n 22p> -> <bdd 22n 23p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 22n 23p> -> <bdd 24n 24p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 24p> -> <bdd 24n 25p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 11: - Backward controlled-behavior: <bdd 24n 25p> -> <bdd 21n 27p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 21n 27p> -> <bdd 24n 26p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 24n 26p> -> <bdd 20n 26p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 20n 26p> -> (p.x != 0 or (not p.l1 or p.y != 0)) and ((p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and (p.x != 0 or (not p.l5 or p.y != 3))) and ((p.x != 0 or not p.l3) and (p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 14: - Backward controlled-behavior: (p.x != 0 or (not p.l1 or p.y != 0)) and ((p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and (p.x != 0 or (not p.l5 or p.y != 3))) and ((p.x != 0 or not p.l3) and (p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) -> (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [fixed point]. Controlled behavior: true -> (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))). @@ -260,38 +201,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 0 and (p.l5 and (p.y = 0 or p.y = 2)) or (p.x = 0 and (p.l5 and p.y = 3) or p.x = 0 and p.l3) or (p.x = 0 and p.l2 or (p.x = 0 and (p.l4 and p.y = 0) or p.x = 2 and (p.l5 and (p.y = 0 or p.y = 2)))) or (p.x = 2 and (p.l5 and p.y = 3) or (p.x = 2 and (p.l3 and p.y = 0) or p.x = 2 and (p.l4 and p.y = 0)) or ((p.x = 1 or p.x = 3) and (p.l5 and (p.y = 0 or p.y = 2)) or (p.x = 1 or p.x = 3) and (p.l5 and p.y = 3) or ((p.x = 1 or p.x = 3) and (p.l3 and p.y = 0) or (p.x = 1 or p.x = 3) and (p.l4 and p.y = 0)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 and p.y = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.l1 and p.y = 0 -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) [forward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 4: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 5: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> <bdd 23n 11p> [forward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 6: - No change this iteration. - Forward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) -> <bdd 23n 11p>. @@ -303,51 +217,6 @@ Synthesis round 2: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] Backward controlled-behavior: p.l5 and p.y = 1 -> p.x = 1 and (p.l5 and p.y = 1) [restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 5: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 6: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 7: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 8: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 9: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 10: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 11: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> <bdd 22n 8p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 22n 8p> -> <bdd 21n 9p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 21n 9p> -> <bdd 21n 10p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 14: - Backward controlled-behavior: <bdd 21n 10p> -> <bdd 23n 11p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior not changed. @@ -355,9 +224,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 23n 30p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_reach_ctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_reach_ctrl.cif.out index 538a02d3ba1e7f42191ac71e50dc734a529c6ff8..e98515d85fd8258d2e5a6e912f1deefbf7db9868 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_reach_ctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_nonblock_reach_ctrl.cif.out @@ -194,65 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l5 and p.y = 1 -> p.l5 and p.y = 1 or p.l4 and p.y = 1 [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.l5 and p.y = 1 or p.l4 and p.y = 1 -> (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or p.x = 1 and (p.l5 and p.y = 1)) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l4 and p.y = 1))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or p.x = 1 and (p.l5 and p.y = 1)) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l4 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or (p.x = 0 or p.x = 2) and (p.l4 and p.y = 2) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 1))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l5 and p.y = 1) or (p.x = 0 or p.x = 2) and (p.l4 and p.y = 2) or ((p.x = 0 or p.x = 2) and (p.l4 and p.y = 1) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 1))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1) or (p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and p.y = 1)) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and p.y = 1))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and p.y = 1) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and p.y = 1)))) -> p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3))) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3))))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or (p.x = 0 and (p.l4 and p.y = 2) or p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3))) or (p.x = 2 and (p.l5 and p.y = 1) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3))))) -> p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l3 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and p.y = 1) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3)))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l5 and p.y = 1) or (p.x = 3 and (p.l3 and p.y = 1) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) -> <bdd 21n 17p> [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 21n 17p> -> <bdd 24n 18p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 18p> -> <bdd 22n 19p> [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: <bdd 22n 19p> -> <bdd 21n 19p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 21n 19p> -> <bdd 24n 20p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 20p> -> <bdd 21n 20p> [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - Backward controlled-behavior: <bdd 21n 20p> -> p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 2 and (p.l2 and (p.y = 2 or p.y = 3)) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3))))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 1 and ((p.l2 or p.l4) and p.y = 2) or p.x = 1 and ((p.l2 or p.l4) and (p.y = 1 or p.y = 3)))) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l3 and p.y = 2) or (p.x = 3 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.l5 and p.y = 1) or p.x = 0 and (p.l4 and p.y = 2) or (p.x = 0 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 2 and (p.l5 and p.y = 1)) or (p.x = 2 and (p.l3 and p.y = 2) or p.x = 2 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 2 and (p.l2 and (p.y = 2 or p.y = 3)) or (p.x = 2 and (p.l4 and p.y = 2) or p.x = 2 and (p.l4 and (p.y = 1 or p.y = 3))))) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 2) or (p.x = 1 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 1 and ((p.l2 or p.l4) and p.y = 2) or p.x = 1 and ((p.l2 or p.l4) and (p.y = 1 or p.y = 3)))) or (p.x = 3 and (p.l5 and p.y = 1) or p.x = 3 and (p.l3 and p.y = 2) or (p.x = 3 and (p.l3 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l4 and p.y = 2) or p.x = 3 and (p.l4 and (p.y = 1 or p.y = 3)))))) -> <bdd 21n 20p> [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 8: - Backward controlled-behavior: <bdd 21n 20p> -> <bdd 23n 21p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 23n 21p> -> <bdd 23n 21p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 9: - Backward controlled-behavior: <bdd 23n 21p> -> <bdd 23n 22p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 23n 22p> -> <bdd 25n 22p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 25n 22p> -> <bdd 23n 22p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 10: - Backward controlled-behavior: <bdd 23n 22p> -> <bdd 22n 23p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 22n 23p> -> <bdd 24n 24p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 24n 24p> -> <bdd 24n 25p> [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 11: - Backward controlled-behavior: <bdd 24n 25p> -> <bdd 21n 27p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 21n 27p> -> <bdd 24n 26p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 24n 26p> -> <bdd 20n 26p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 20n 26p> -> (p.x != 0 or (not p.l1 or p.y != 0)) and ((p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and (p.x != 0 or (not p.l5 or p.y != 3))) and ((p.x != 0 or not p.l3) and (p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 14: - Backward controlled-behavior: (p.x != 0 or (not p.l1 or p.y != 0)) and ((p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and (p.x != 0 or (not p.l5 or p.y != 3))) and ((p.x != 0 or not p.l3) and (p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) -> (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) [fixed point]. Controlled behavior: true -> (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))). @@ -260,30 +201,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 and p.y = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.l1 and p.y = 0 -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) [forward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 4: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 5: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> <bdd 23n 11p> [forward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0)))))] - - Forward reachability iteration 6: - No change this iteration. - Forward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior: (p.x != 0 or not p.l5 or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (not p.l5 or p.y != 3)) and (p.x != 0 or not p.l3)) and ((p.x != 0 or not p.l2) and ((p.x != 0 or (not p.l4 or p.y != 0)) and (p.x != 2 or not p.l5 or (p.y = 1 or p.y = 3)))) and ((p.x != 2 or (not p.l5 or p.y != 3)) and ((p.x != 2 or (not p.l3 or p.y != 0)) and (p.x != 2 or (not p.l4 or p.y != 0))) and ((p.x = 0 or p.x = 2 or (not p.l5 or (p.y = 1 or p.y = 3))) and (p.x = 0 or p.x = 2 or (not p.l5 or p.y != 3)) and ((p.x = 0 or p.x = 2 or (not p.l3 or p.y != 0)) and (p.x = 0 or p.x = 2 or (not p.l4 or p.y != 0))))) -> <bdd 23n 11p>. @@ -291,9 +208,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 23n 30p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Need another round. @@ -303,51 +217,6 @@ Synthesis round 2: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] Backward controlled-behavior: p.l5 and p.y = 1 -> p.x = 1 and (p.l5 and p.y = 1) [restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 5: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 6: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 7: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 8: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 9: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 10: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 11: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> <bdd 22n 8p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 22n 8p> -> <bdd 21n 9p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 21n 9p> -> <bdd 21n 10p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 14: - Backward controlled-behavior: <bdd 21n 10p> -> <bdd 23n 11p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_ctrl_nonblock.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_ctrl_nonblock.cif.out index 0004fccd3458a04c2ea438ce759b8809fb038fff..155e95746fffcc6f756af90fbe61e1dfe3a0c54e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_ctrl_nonblock.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_ctrl_nonblock.cif.out @@ -194,30 +194,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 and p.y = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.l1 and p.y = 0 -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) [forward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> <bdd 23n 11p> [forward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - No change this iteration. - Forward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior: true -> <bdd 23n 11p>. @@ -225,60 +201,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 23n 30p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] Backward controlled-behavior: p.l5 and p.y = 1 -> p.x = 1 and (p.l5 and p.y = 1) [restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 5: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 6: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 7: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 8: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 9: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 10: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 11: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> <bdd 22n 8p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 22n 8p> -> <bdd 21n 9p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 21n 9p> -> <bdd 21n 10p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 14: - Backward controlled-behavior: <bdd 21n 10p> -> <bdd 23n 11p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_nonblock_ctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_nonblock_ctrl.cif.out index 2b96e5100ae2fdf2d5ae26f63d8e2164e6bd5c3c..e1f6218e45b3560e0d244e8ff549ca71d05ebfff 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_nonblock_ctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fixed_point_order_reach_nonblock_ctrl.cif.out @@ -194,30 +194,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.l1 and p.y = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.l1 and p.y = 0 -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) [forward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and ((p.l1 or p.l2) and p.y = 0)) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and (p.l2 and (p.y = 0 or p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l2 and (p.y = 0 or p.y = 2)) or p.x = 3 and (p.l2 and p.y = 1))) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) [forward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and (p.l1 and p.y = 0) or p.x = 1 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l1 and p.y = 0) or p.x = 2 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [forward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 3) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l1 and p.y = 0)) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and (p.y = 2 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) [forward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 0 and (p.l1 and p.y = 0) or p.x = 2 and (p.l1 and p.y = 0) or (p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l1 and p.y = 0) or p.x = 1 and (p.l3 and p.y = 3))) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l1 and p.y = 0) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2))) -> <bdd 23n 11p> [forward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - No change this iteration. - Forward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior: true -> <bdd 23n 11p>. @@ -226,51 +202,6 @@ Synthesis round 1: Backward controlled-behavior: p.l5 and p.y = 1 [marker predicate] Backward controlled-behavior: p.l5 and p.y = 1 -> p.x = 1 and (p.l5 and p.y = 1) [restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) [backward reach with edge: (event: p.u4) (guard: p.l4 and p.y = 1) (assignments: p := p.l5), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l4 and p.y = 1) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and p.y = 1)) -> p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.u4) (guard: p.l4 and (p.y = 2 or p.y = 3)) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) [backward reach with edge: (event: p.c3) (guard: p.x = 1 and p.l3) (assignments: p := p.l4), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 5: - Backward controlled-behavior: p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 6: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) [backward reach with edge: (event: p.c3) (guard: (p.x = 2 or p.x = 3) and p.l3) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 7: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) [backward reach with edge: (event: p.u2) (guard: p.l2 and p.y = 3) (assignments: p := p.l3), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 8: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and p.y = 3))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 9: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and (p.l2 and (p.y = 2 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 10: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or p.x = 1 and (p.l5 and p.y = 1) or (p.x = 1 and (p.l3 and p.y = 3) or p.x = 1 and (p.l4 and p.y = 2)) or (p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.l3 and p.y = 3) or (p.x = 3 and (p.l2 and p.y = 2) or p.x = 3 and (p.l2 and (p.y = 1 or p.y = 3)))) -> p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) [backward reach with edge: (event: p.u2) (guard: (p.l2 or p.l4) and ((not p.l2 or p.y != 3) and not p.l4)) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 11: - Backward controlled-behavior: p.x = 2 and (p.l3 and p.y = 3) or (p.x = 1 and (p.l5 and p.y = 1) or p.x = 1 and (p.l3 and p.y = 3)) or (p.x = 1 and (p.l4 and p.y = 2) or p.x = 1 and (p.l4 and (p.y = 1 or p.y = 3)) or (p.x = 3 and (p.l3 and p.y = 3) or p.x = 3 and p.l2)) -> <bdd 22n 8p> [backward reach with edge: (event: p.c1) (guard: p.x = 3 and p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 12: - Backward controlled-behavior: <bdd 22n 8p> -> <bdd 21n 9p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 13: - Backward controlled-behavior: <bdd 21n 9p> -> <bdd 21n 10p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 14: - Backward controlled-behavior: <bdd 21n 10p> -> <bdd 23n 11p> [backward reach with edge: (event: p.c1) (guard: (p.x = 0 or p.x = 2) and p.l1 or p.x = 1 and p.l1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 23n 11p>] - - Backward reachability iteration 15: - No change this iteration. - Backward controlled-behavior: <bdd 23n 11p> [fixed point]. Controlled behavior not changed. @@ -278,9 +209,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 23n 30p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out index 73f02f453dad7a4eac5672693215b467ab39d580..b8dfebc522a2d44da2bdb6b001ac5ffcfa027b10 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out @@ -187,9 +187,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out index ab8d961f30eddc50116ca438b0b34fc56f5bbfff..e6e3909856b23a0fbee676f5151aa80275ec143d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out @@ -187,9 +187,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -202,17 +199,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: (p.v = 1 or (p.v = 3 or p.v = 5)) and (p.v = 0 or 2 <= p.v and p.v <= 4) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: (p.v = 1 or (p.v = 3 or p.v = 5)) and (p.v = 0 or 2 <= p.v and p.v <= 4) -> p.v = 2 or p.v = 3 [forward reach with edge: (event: f) (guard: p.v = 3) (assignments: p.v := p.v - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v = 2 or p.v = 3 -> p.v = 0 and p.w = 0 or p.v = 4 and p.w = 4 or (p.v = 2 and not(p.w = 2 or p.w = 3) or p.v = 2 and (p.w = 2 or p.w = 3)) or (p.v = 1 and p.w = 1 or p.v = 5 and p.w = 5 or (p.v = 3 and not(p.w = 2 or p.w = 3) or p.v = 3 and (p.w = 2 or p.w = 3))) [forward reach with edge: (event: g) (guard: p.v = 2) (assignments: p.v := p.w), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: p.v = 0 and p.w = 0 or p.v = 4 and p.w = 4 or (p.v = 2 and not(p.w = 2 or p.w = 3) or p.v = 2 and (p.w = 2 or p.w = 3)) or (p.v = 1 and p.w = 1 or p.v = 5 and p.w = 5 or (p.v = 3 and not(p.w = 2 or p.w = 3) or p.v = 3 and (p.w = 2 or p.w = 3))) -> (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or p.w = 1 or (p.w = 3 or p.w = 5)) and ((p.v != 5 or p.w != 1) and (p.v != 5 or p.w != 3)))) [forward reach with edge: (event: f) (guard: p.v = 2) (assignments: p.v := p.v - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or p.w = 1 or (p.w = 3 or p.w = 5)) and ((p.v != 5 or p.w != 1) and (p.v != 5 or p.w != 3)))) -> (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or 2 <= p.w and p.w <= 5) and (p.v != 5 or not(p.w = 2 or p.w = 3)))) [forward reach with edge: (event: f) (guard: p.v = 4) (assignments: p.v := p.v + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or 2 <= p.w and p.w <= 5) and (p.v != 5 or not(p.w = 2 or p.w = 3)))) [fixed point]. Controlled behavior: true -> (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or 2 <= p.w and p.w <= 5) and (p.v != 5 or not(p.w = 2 or p.w = 3)))). @@ -224,9 +210,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or 2 <= p.w and p.w <= 5) and (p.v != 5 or not(p.w = 2 or p.w = 3)))) [restricted to current/previous controlled-behavior predicate: (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or 2 <= p.w and p.w <= 5) and (p.v != 5 or not(p.w = 2 or p.w = 3))))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: (p.v != 0 or p.w != 4) and (p.v != 0 or p.w != 2) and ((p.v != 0 or p.w = 0 or (p.w = 2 or p.w = 4)) and (p.v != 4 or p.w != 0)) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)) and ((p.v != 5 or 2 <= p.w and p.w <= 5) and (p.v != 5 or not(p.w = 2 or p.w = 3)))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out index 2e646818565b72dd23df3453b09f58e1acbec21a..878be2656fb950fb5ca0f8c8d940e8262578a10f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out @@ -199,9 +199,6 @@ Synthesis round 1: Backward controlled-behavior: p1.l0 [marker predicate] Backward controlled-behavior: p1.l0 -> (p2.y = 2 or p2.y = 3 or (p1.x = 2 or (p1.x = 3 or p1.l0))) and (p2.y = 2 or p2.y = 3 or (not(p1.x = 2 or p1.x = 3) or p1.l0)) and ((not(p2.y = 2 or p2.y = 3) or p1.x = 2 or (p1.x = 3 or p1.l0)) and (not(p2.y = 2 or p2.y = 3) or (not(p1.x = 2 or p1.x = 3) or p1.l0))) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: (p2.y = 2 or p2.y = 3 or (p1.x = 2 or (p1.x = 3 or p1.l0))) and (p2.y = 2 or p2.y = 3 or (not(p1.x = 2 or p1.x = 3) or p1.l0)) and ((not(p2.y = 2 or p2.y = 3) or p1.x = 2 or (p1.x = 3 or p1.l0)) and (not(p2.y = 2 or p2.y = 3) or (not(p1.x = 2 or p1.x = 3) or p1.l0))) [fixed point]. Controlled behavior: true -> (p2.y = 2 or p2.y = 3 or (p1.x = 2 or (p1.x = 3 or p1.l0))) and (p2.y = 2 or p2.y = 3 or (not(p1.x = 2 or p1.x = 3) or p1.l0)) and ((not(p2.y = 2 or p2.y = 3) or p1.x = 2 or (p1.x = 3 or p1.l0)) and (not(p2.y = 2 or p2.y = 3) or (not(p1.x = 2 or p1.x = 3) or p1.l0))). @@ -214,9 +211,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p2.y = 0 and (p1.x = 0 and p1.l0) [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior: (p2.y = 2 or p2.y = 3 or (p1.x = 2 or (p1.x = 3 or p1.l0))) and (p2.y = 2 or p2.y = 3 or (not(p1.x = 2 or p1.x = 3) or p1.l0)) and ((not(p2.y = 2 or p2.y = 3) or p1.x = 2 or (p1.x = 3 or p1.l0)) and (not(p2.y = 2 or p2.y = 3) or (not(p1.x = 2 or p1.x = 3) or p1.l0))) -> p2.y = 0 and (p1.x = 0 and p1.l0). Need another round. @@ -226,9 +220,6 @@ Synthesis round 2: Backward controlled-behavior: p1.l0 [marker predicate] Backward controlled-behavior: p1.l0 -> p2.y = 0 and (p1.x = 0 and p1.l0) [restricted to current/previous controlled-behavior predicate: p2.y = 0 and (p1.x = 0 and p1.l0)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p2.y = 0 and (p1.x = 0 and p1.l0) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out index 80b50cac8a1ebd9eec76d56e1e8e623176c51dff..86cbe53245450ff42200370ff1433703fd9e63e1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out @@ -194,24 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) -> p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) [backward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) -> p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - No change this iteration. - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior: true -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))). @@ -224,24 +206,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and p.y = 0) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 3: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) -> p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out index b067ff58008489994675166e42e3039a2eb837c7..1018b6180c5c4796733a66d8a70a5ad8c2231113 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out @@ -194,24 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) -> p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) [backward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) -> p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - No change this iteration. - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior: true -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))). @@ -224,24 +206,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and p.y = 0) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 3: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) -> p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/initial_bad.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/initial_bad.cif.out index 893559fe19952f8d1f353aa34fb3d31c835016c5..620b02893f67ea4c5f8dbbd439676b4f834b28b5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/initial_bad.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/initial_bad.cif.out @@ -182,16 +182,6 @@ Synthesis round 1: Backward controlled-behavior: p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 9)) or (p.l0 and p.x = 5 or p.l0 and (p.x = 3 or p.x = 7) or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) [marker predicate] Backward controlled-behavior: p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 9)) or (p.l0 and p.x = 5 or p.l0 and (p.x = 3 or p.x = 7) or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) -> p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 9)) or (p.l0 and p.x = 5 or p.l0 and p.x = 7 or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) [restricted to current/previous controlled-behavior predicate: <bdd 17n 27p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 9)) or (p.l0 and p.x = 5 or p.l0 and p.x = 7 or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) -> p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.l0 and p.x = 7 or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) [backward reach with edge: (event: u1) (guard: p.l0) (assignments: p := p.l1), restricted to current/previous controlled-behavior predicate: <bdd 17n 27p>] - Backward controlled-behavior: p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.l0 and p.x = 7 or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) -> p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.l0 and p.x = 7 or p.l2 and p.x = 16 or (p.l1 and p.x = 16 or p.l1 and p.x = 13)) [backward reach with edge: (event: u2) (guard: p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 17n 27p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13))) or (p.l0 and p.x = 7 or p.l2 and p.x = 16 or (p.l1 and p.x = 16 or p.l1 and p.x = 13)) -> <bdd 21n 10p> [backward reach with edge: (event: u1) (guard: p.l0) (assignments: p := p.l1), restricted to current/previous controlled-behavior predicate: <bdd 17n 27p>] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: <bdd 21n 10p> [fixed point]. Controlled behavior: <bdd 17n 27p> -> <bdd 21n 10p>. @@ -199,16 +189,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 21n 24p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: <bdd 21n 24p> -> <bdd 13n 22p> [backward reach with edge: (event: u1) (guard: p.l0) (assignments: p := p.l1)] - Backward uncontrolled bad-state: <bdd 13n 22p> -> (not p.l0 or p.x != 16) and (not p.l0 or p.x != 13) and ((not p.l2 or p.x != 16) and (not p.l1 or p.x != 16)) [backward reach with edge: (event: u2) (guard: p.l1) (assignments: p := p.l2)] - - Backward reachability iteration 2: - Backward uncontrolled bad-state: (not p.l0 or p.x != 16) and (not p.l0 or p.x != 13) and ((not p.l2 or p.x != 16) and (not p.l1 or p.x != 16)) -> (p.l1 or p.x != 16) and (not p.l1 or p.x != 16) [backward reach with edge: (event: u1) (guard: p.l0) (assignments: p := p.l1)] - - Backward reachability iteration 3: - No change this iteration. - Backward uncontrolled bad-state: (p.l1 or p.x != 16) and (not p.l1 or p.x != 16) [fixed point]. Controlled behavior: <bdd 21n 10p> -> not p.l1 and p.x = 16 or p.l1 and p.x = 16. @@ -217,13 +197,6 @@ Synthesis round 1: Forward controlled-behavior: not p.l2 and not p.l1 [initialization predicate] Forward controlled-behavior: not p.l2 and not p.l1 -> p.l0 and p.x = 16 [restricted to current/previous controlled-behavior predicate: not p.l1 and p.x = 16 or p.l1 and p.x = 16] - Forward reachability iteration 1: - Forward controlled-behavior: p.l0 and p.x = 16 -> not p.l2 and p.x = 16 [forward reach with edge: (event: u1) (guard: p.l0) (assignments: p := p.l1), restricted to current/previous controlled-behavior predicate: not p.l1 and p.x = 16 or p.l1 and p.x = 16] - Forward controlled-behavior: not p.l2 and p.x = 16 -> not p.l1 and p.x = 16 or p.l1 and p.x = 16 [forward reach with edge: (event: u2) (guard: p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: not p.l1 and p.x = 16 or p.l1 and p.x = 16] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: not p.l1 and p.x = 16 or p.l1 and p.x = 16 [fixed point]. Controlled behavior not changed. @@ -235,15 +208,6 @@ Synthesis round 2: Backward controlled-behavior: p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 9)) or (p.l0 and p.x = 5 or p.l0 and (p.x = 3 or p.x = 7) or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) [marker predicate] Backward controlled-behavior: p.l0 and (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) or (p.l0 and (p.x = 4 or p.x = 6) or p.l0 and (p.x = 1 or p.x = 9)) or (p.l0 and p.x = 5 or p.l0 and (p.x = 3 or p.x = 7) or (p.l2 and p.x = 16 or p.l1 and p.x = 13)) -> p.l2 and p.x = 16 [restricted to current/previous controlled-behavior predicate: not p.l1 and p.x = 16 or p.l1 and p.x = 16] - Backward reachability iteration 1: - Backward controlled-behavior: p.l2 and p.x = 16 -> p.l2 and p.x = 16 or p.l1 and p.x = 16 [backward reach with edge: (event: u2) (guard: p.l1) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: not p.l1 and p.x = 16 or p.l1 and p.x = 16] - - Backward reachability iteration 2: - Backward controlled-behavior: p.l2 and p.x = 16 or p.l1 and p.x = 16 -> not p.l1 and p.x = 16 or p.l1 and p.x = 16 [backward reach with edge: (event: u1) (guard: p.l0) (assignments: p := p.l1), restricted to current/previous controlled-behavior predicate: not p.l1 and p.x = 16 or p.l1 and p.x = 16] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: not p.l1 and p.x = 16 or p.l1 and p.x = 16 [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out index 9b7c6f6ff71c9d6fd2287fe87e41ae536f209fb8..c27a798ad358c7df3863106194ba24eb4ac7e93c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out @@ -175,9 +175,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> io.b and (io.i = 3 and io.e = A) [restricted to current/previous controlled-behavior predicate: io.b and (io.i = 3 and io.e = A)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: io.b and (io.i = 3 and io.e = A) [fixed point]. Controlled behavior not changed. @@ -185,12 +182,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: not io.b or (io.i != 3 or io.e = B) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: not io.b or (io.i != 3 or io.e = B) -> true [backward reach with edge: (event: io.b) (guard: true) (assignments: io.b+ != io.b)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: true [fixed point]. Controlled behavior: io.b and (io.i = 3 and io.e = A) -> false. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars2.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars2.cif.out index 715b236e2f1ed6c6f061e0daafd410a43a6a8b6c..d6a2b091351d0d308d66be0f81937687204dcad3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars2.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars2.cif.out @@ -85,25 +85,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out index e5fc97b1eff2ce6ae44f70bb3bb11b266685fd48..bb7245a84d4edfeed6d016eaddff09889f969ed8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out @@ -180,14 +180,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p_sensor.off and p_act.off [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p_sensor.off and p_act.off -> not io.sensor and p_act.off or io.sensor and (p_sensor.off and p_act.off) [backward reach with edge: (event: u_off) (guard: not io.sensor and p_sensor.on) (assignments: p_sensor := p_sensor.off), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not io.sensor and p_act.off or io.sensor and (p_sensor.off and p_act.off) -> not io.sensor or p_sensor.off [backward reach with edge: (event: c_off) (guard: p_act.on) (assignments: p_act := p_act.off), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not io.sensor or p_sensor.off -> true [backward reach with edge: (event: io.sensor) (guard: true) (assignments: io.sensor+ != io.sensor), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -195,21 +187,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: not io.sensor and (p_sensor.off and p_act.off) or io.sensor and (p_sensor.on and p_act.off) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: not io.sensor and (p_sensor.off and p_act.off) or io.sensor and (p_sensor.on and p_act.off) -> (io.sensor or p_sensor.off) and (not io.sensor or p_sensor.on) [forward reach with edge: (event: c_on) (guard: p_act.off) (assignments: p_act := p_act.on), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (io.sensor or p_sensor.off) and (not io.sensor or p_sensor.on) -> true [forward reach with edge: (event: io.sensor) (guard: true) (assignments: io.sensor+ != io.sensor), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars4.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars4.cif.out index 85430dcbcbf9f469489181ba3b2becec0b90188b..af2185ae740b3a3deaa623440308e276ba3e4cfb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars4.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars4.cif.out @@ -86,12 +86,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: io.sensor = 2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: io.sensor = 2 -> true [backward reach with edge: (event: io.sensor) (guard: true) (assignments: io.sensor+ != io.sensor), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -99,20 +93,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: io.sensor = 1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: io.sensor = 1 -> true [forward reach with edge: (event: io.sensor) (guard: true) (assignments: io.sensor+ != io.sensor), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars5.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars5.cif.out index dfeb3f8b79ad9b46d4828f1efbe92511f8aa5db2..469179ab5b01ef82ee2f47743f7642c67f8eb0cd 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars5.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars5.cif.out @@ -88,12 +88,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: io.sensor = 2 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: io.sensor = 2 -> true [backward reach with edge: (event: io.sensor) (guard: true) (assignments: io.sensor+ != io.sensor), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -101,20 +95,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: io.sensor = 1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: io.sensor = 1 -> true [forward reach with edge: (event: io.sensor) (guard: true) (assignments: io.sensor+ != io.sensor), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars6.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars6.cif.out index 8b9fd2b16b4a4d7b0c42a5450cfefb1227f4ff0a..4793b9ca486ec055b14185a38630d1d2aaa48f28 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars6.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars6.cif.out @@ -123,13 +123,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: not io.sensor2 and not io.sensor3 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: not io.sensor2 and not io.sensor3 -> not io.sensor3 [backward reach with edge: (event: io.sensor2) (guard: true) (assignments: io.sensor2+ != io.sensor2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not io.sensor3 -> true [backward reach with edge: (event: io.sensor3) (guard: true) (assignments: io.sensor3+ != io.sensor3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -137,21 +130,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: io.sensor1 and io.sensor2 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: io.sensor1 and io.sensor2 -> io.sensor2 [forward reach with edge: (event: io.sensor1) (guard: true) (assignments: io.sensor1+ != io.sensor1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: io.sensor2 -> true [forward reach with edge: (event: io.sensor2) (guard: true) (assignments: io.sensor2+ != io.sensor2), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out index 6a3ee35f47d5693f617080930bb6283d347ebdb4..2d01fe741f9e288256b398076d1379ba96ce786d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out @@ -185,12 +185,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.done [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.done -> p.done or p.b [backward reach with edge: (event: p.u_ok) (guard: p.test and p.b) (assignments: p := p.done), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.done or p.b [fixed point]. Controlled behavior: true -> p.done or p.b. @@ -198,22 +192,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.test and not p.b [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.test and (not p.b and not io.sensor) or p.test and (p.b and io.sensor) [initialization predicate] Forward controlled-behavior: p.test and (not p.b and not io.sensor) or p.test and (p.b and io.sensor) -> p.test and (p.b and io.sensor) [restricted to current/previous controlled-behavior predicate: p.done or p.b] - Forward reachability iteration 1: - Forward controlled-behavior: p.test and (p.b and io.sensor) -> p.b and io.sensor [forward reach with edge: (event: p.u_ok) (guard: p.test and p.b) (assignments: p := p.done), restricted to current/previous controlled-behavior predicate: p.done or p.b] - Forward controlled-behavior: p.b and io.sensor -> p.b [forward reach with edge: (event: io.sensor) (guard: true) (assignments: io.sensor+ != io.sensor), restricted to current/previous controlled-behavior predicate: p.done or p.b] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.b [fixed point]. Controlled behavior: p.done or p.b -> p.b. @@ -225,12 +209,6 @@ Synthesis round 2: Backward controlled-behavior: p.done [marker predicate] Backward controlled-behavior: p.done -> p.done and p.b [restricted to current/previous controlled-behavior predicate: p.b] - Backward reachability iteration 1: - Backward controlled-behavior: p.done and p.b -> p.b [backward reach with edge: (event: p.u_ok) (guard: p.test and p.b) (assignments: p := p.done), restricted to current/previous controlled-behavior predicate: p.b] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.b [fixed point]. Controlled behavior not changed. @@ -238,9 +216,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: not p.b [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_comp.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_comp.cif.out index e3b9604ca4aa213ae57d7e353ee9c8980c43216e..200aa3d9851597eabe5942893664850ddb38309e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_comp.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_comp.cif.out @@ -129,9 +129,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -139,56 +136,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: a.x = 1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: a.x = 1 -> a.x = 2 or a.x = 1 [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x = 2 or a.x = 1 -> a.x = 2 or (a.x = 1 or a.x = 3) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: a.x = 2 or (a.x = 1 or a.x = 3) -> a.x = 4 or a.x = 2 or (a.x = 1 or a.x = 3) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x = 4 or a.x = 2 or (a.x = 1 or a.x = 3) -> a.x = 4 or a.x = 2 or (a.x = 1 or (a.x = 5 or a.x = 3)) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: a.x = 4 or a.x = 2 or (a.x = 1 or (a.x = 5 or a.x = 3)) -> a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or (a.x = 5 or a.x = 3)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or (a.x = 5 or a.x = 3)) -> a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) -> a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) -> a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) -> a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) -> a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) -> a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) -> a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 5 or a.x = 9) or (a.x = 13 or a.x = 3 or (a.x = 11 or a.x = 7))) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 7: - Forward controlled-behavior: a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 5 or a.x = 9) or (a.x = 13 or a.x = 3 or (a.x = 11 or a.x = 7))) -> not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and not(a.x = 18 or a.x = 22)) and (not(a.x = 17 or (a.x = 21 or a.x = 25)) and a.x != 19 and (a.x != 23 and a.x != 15)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and not(a.x = 18 or a.x = 22)) and (not(a.x = 17 or (a.x = 21 or a.x = 25)) and a.x != 19 and (a.x != 23 and a.x != 15)) -> not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 8: - Forward controlled-behavior: not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) -> a.x != 0 and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (not(a.x = 18 or a.x = 22) and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 9: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (not(a.x = 18 or a.x = 22) and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [forward reach with edge: (event: i) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 10: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 11: - No change this iteration. - Forward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [fixed point]. Controlled behavior: true -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))). @@ -200,9 +152,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [restricted to current/previous controlled-behavior predicate: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23)))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [fixed point]. Controlled behavior not changed. @@ -210,9 +159,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: a.x = 0 or (a.x = 24 or a.x = 22) or (a.x = 25 or (a.x = 21 or a.x = 23)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out index ba5b1c404709dfcb071574d66715a3e8a98673c3..31028027e0328fd5c5702354ff51ba774e33a877 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out @@ -253,21 +253,6 @@ Synthesis round 1: Backward controlled-behavior: a.l2 [marker predicate] Backward controlled-behavior: a.l2 -> not(2 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 15 or 18 <= a.x and a.x <= 23)) and a.l2 or (a.x = 4 or a.x = 5 or (a.x = 20 or a.x = 21)) and a.l2 or ((a.x = 12 or a.x = 13) and a.l2 or ((a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) and a.l2 or (a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) and a.l2)) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not(2 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 15 or 18 <= a.x and a.x <= 23)) and a.l2 or (a.x = 4 or a.x = 5 or (a.x = 20 or a.x = 21)) and a.l2 or ((a.x = 12 or a.x = 13) and a.l2 or ((a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) and a.l2 or (a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) and a.l2)) -> (a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) and a.l2 or (a.x = 4 or a.x = 20) and a.l2 or (a.x = 12 and a.l2 or ((a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) and a.l2 or (a.x = 10 or a.x = 14) and a.l2)) or ((a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) and a.l2 or (a.x = 5 or a.x = 21 and a.l2) or (a.x = 13 and a.l2 or ((a.x = 3 or a.x = 7 or (a.x = 19 or a.x = 23)) and a.l2 or (a.x = 11 or a.x = 15) and a.l2))) [backward reach with edge: (event: b) (guard: a.x = 5 and a.l1) (assignments: a := a.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) and a.l2 or (a.x = 4 or a.x = 20) and a.l2 or (a.x = 12 and a.l2 or ((a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) and a.l2 or (a.x = 10 or a.x = 14) and a.l2)) or ((a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) and a.l2 or (a.x = 5 or a.x = 21 and a.l2) or (a.x = 13 and a.l2 or ((a.x = 3 or a.x = 7 or (a.x = 19 or a.x = 23)) and a.l2 or (a.x = 11 or a.x = 15) and a.l2))) -> (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and (not(a.x = 20 or a.x = 21) or a.l2) and ((not(a.x = 12 or a.x = 13) or a.l2) and ((not(a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) or a.l2) and (not(a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) or a.l2))) [backward reach with edge: (event: i) (guard: (a.x = 0 or a.x = 4) and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and (not(a.x = 20 or a.x = 21) or a.l2) and ((not(a.x = 12 or a.x = 13) or a.l2) and ((not(a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) or a.l2) and (not(a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) or a.l2))) -> (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((not(a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) or a.l2) and ((not(a.x = 10 or a.x = 14) or a.l2) and (not(a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) or a.l2))) and ((a.x != 21 or a.l2) and ((a.x != 13 or a.l2) and (a.x != 19 or a.l2)) and ((a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((not(a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) or a.l2) and ((not(a.x = 10 or a.x = 14) or a.l2) and (not(a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) or a.l2))) and ((a.x != 21 or a.l2) and ((a.x != 13 or a.l2) and (a.x != 19 or a.l2)) and ((a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) -> (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) [backward reach with edge: (event: i) (guard: (a.x = 0 or a.x = 4) and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) -> (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((a.x != 18 or a.l2) and (a.x != 10 or a.l2) and ((not(a.x = 6 or a.x = 22) or a.l2) and (a.x != 14 or a.l2))) and ((a.x != 17 or a.l2) and (not(a.x = 9 or a.x = 25) or a.l2) and ((a.x != 21 or a.l2) and (a.x != 13 or a.l2)) and ((a.x != 19 or a.l2) and (a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((a.x != 18 or a.l2) and (a.x != 10 or a.l2) and ((not(a.x = 6 or a.x = 22) or a.l2) and (a.x != 14 or a.l2))) and ((a.x != 17 or a.l2) and (not(a.x = 9 or a.x = 25) or a.l2) and ((a.x != 21 or a.l2) and (a.x != 13 or a.l2)) and ((a.x != 19 or a.l2) and (a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) -> (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) [backward reach with edge: (event: i) (guard: (a.x = 0 or a.x = 4) and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - No change this iteration. - Backward controlled-behavior: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) [fixed point]. Controlled behavior: true -> (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))). @@ -275,57 +260,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (a.x = 16 or a.x = 17) and a.l1 or (a.x = 8 or a.x = 9 or (a.x = 24 or a.x = 25)) and a.l1 or ((a.x = 20 or a.x = 21) and a.l1 or (a.x = 12 or a.x = 13) and a.l1) or ((a.x = 18 or a.x = 19) and a.l1 or (a.x = 10 or a.x = 11) and a.l1 or ((a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) and a.l1 or (a.x = 14 or a.x = 15) and a.l1)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: a.x = 1 and a.l1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: a.x = 1 and a.l1 -> a.x = 2 and a.l1 or a.x = 1 and a.l1 [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 2 and a.l1 or a.x = 1 and a.l1 -> a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1 [forward reach with edge: (event: i) (guard: (a.x = 0 or a.x = 4) and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 2: - Forward controlled-behavior: a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1 -> a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1) -> a.x = 4 and a.l1 or a.x = 2 and a.l1 or ((a.x = 1 or a.x = 5) and a.l1 or a.x = 3 and a.l1) [forward reach with edge: (event: i) (guard: (a.x = 0 or a.x = 4) and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 4 and a.l1 or a.x = 2 and a.l1 or ((a.x = 1 or a.x = 5) and a.l1 or a.x = 3 and a.l1) -> a.x = 4 and a.l1 or a.x = 2 and a.l1 or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) [forward reach with edge: (event: c) (guard: a.x = 5 and a.l1) (assignments: a := a.l2), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 3: - Forward controlled-behavior: a.x = 4 and a.l1 or a.x = 2 and a.l1 or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) -> a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) -> a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) [forward reach with edge: (event: i) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 4: - Forward controlled-behavior: a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) [forward reach with edge: (event: i) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 5: - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: i) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 6: - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: i) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 7: - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: i) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 8: - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: i) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 9: - Forward controlled-behavior: a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [forward reach with edge: (event: i) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 10: - Forward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 11: - No change this iteration. - Forward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [fixed point]. Controlled behavior: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))). @@ -337,20 +276,6 @@ Synthesis round 2: Backward controlled-behavior: a.l2 [marker predicate] Backward controlled-behavior: a.l2 -> (a.x = 16 or a.x = 20) and a.l2 or (a.x = 8 or a.x = 12) and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2) or ((a.x = 6 or a.x = 14) and a.l2 or (a.x = 17 or a.x = 19) and a.l2 or ((a.x = 9 or a.x = 11) and a.l2 or (a.x = 5 or a.x = 7 or (a.x = 13 or a.x = 15)) and a.l2)) [restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - Backward reachability iteration 1: - Backward controlled-behavior: (a.x = 16 or a.x = 20) and a.l2 or (a.x = 8 or a.x = 12) and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2) or ((a.x = 6 or a.x = 14) and a.l2 or (a.x = 17 or a.x = 19) and a.l2 or ((a.x = 9 or a.x = 11) and a.l2 or (a.x = 5 or a.x = 7 or (a.x = 13 or a.x = 15)) and a.l2)) -> (a.x = 16 or a.x = 20) and a.l2 or ((a.x = 8 or a.x = 12) and a.l2 or a.x = 18 and a.l2) or (a.x = 10 and a.l2 or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2)) or (a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [backward reach with edge: (event: b) (guard: a.x = 5 and a.l1) (assignments: a := a.l2), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - Backward controlled-behavior: (a.x = 16 or a.x = 20) and a.l2 or ((a.x = 8 or a.x = 12) and a.l2 or a.x = 18 and a.l2) or (a.x = 10 and a.l2 or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2)) or (a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 20 and a.l2 or a.x = 12 and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [backward reach with edge: (event: i) (guard: (a.x = 0 or a.x = 4) and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 2: - Backward controlled-behavior: a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 20 and a.l2 or a.x = 12 and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 17 and a.l2 or a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 3 and a.l1 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - Backward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 17 and a.l2 or a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 3 and a.l1 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [backward reach with edge: (event: i) (guard: (a.x = 0 or a.x = 4) and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 3: - Backward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 4: - No change this iteration. - Backward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [fixed point]. Controlled behavior not changed. @@ -358,9 +283,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 15n 27p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_simple.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_simple.cif.out index 257131e926b886a0d93d5158b7011a9541c3fff8..336527ddb18550e50ad1928e0b2b1312729b5412 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_simple.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_simple.cif.out @@ -88,25 +88,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: a.l1 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: true -> a.l1. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: a.l2 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: a.l1 [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_comp.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_comp.cif.out index 21c9b628bb3f874e34aa32ea7f30d995b067a758..e082ed73c18ca8abc03dfe0cbaadcc92dfa8bb09 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_comp.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_comp.cif.out @@ -109,9 +109,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -124,66 +121,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: a.x = 1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: a.x = 1 -> a.x = 2 or a.x = 1 [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: a.x = 2 or a.x = 1 -> a.x = 2 or (a.x = 1 or a.x = 3) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: a.x = 2 or (a.x = 1 or a.x = 3) -> a.x = 4 or a.x = 2 or (a.x = 1 or a.x = 3) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: a.x = 4 or a.x = 2 or (a.x = 1 or a.x = 3) -> a.x = 4 or a.x = 2 or (a.x = 1 or (a.x = 5 or a.x = 3)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: a.x = 4 or a.x = 2 or (a.x = 1 or (a.x = 5 or a.x = 3)) -> a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or (a.x = 5 or a.x = 3)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - Forward controlled-behavior: a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or (a.x = 5 or a.x = 3)) -> a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 7: - Forward controlled-behavior: a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) -> a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 8: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) -> a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 9: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) -> a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 10: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) -> a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 11: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) -> a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 12: - Forward controlled-behavior: a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) -> a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 5 or a.x = 9) or (a.x = 13 or a.x = 3 or (a.x = 11 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 13: - Forward controlled-behavior: a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 5 or a.x = 9) or (a.x = 13 or a.x = 3 or (a.x = 11 or a.x = 7))) -> not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and not(a.x = 18 or a.x = 22)) and (not(a.x = 17 or (a.x = 21 or a.x = 25)) and a.x != 19 and (a.x != 23 and a.x != 15)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 14: - Forward controlled-behavior: not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and not(a.x = 18 or a.x = 22)) and (not(a.x = 17 or (a.x = 21 or a.x = 25)) and a.x != 19 and (a.x != 23 and a.x != 15)) -> not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 15: - Forward controlled-behavior: not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) -> a.x != 0 and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 16: - Forward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (not(a.x = 18 or a.x = 22) and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 17: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (not(a.x = 18 or a.x = 22) and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 18: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 19: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 20: - No change this iteration. - Forward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [fixed point]. Controlled behavior: true -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))). @@ -195,9 +132,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [restricted to current/previous controlled-behavior predicate: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23)))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out index 4df7875811a2433dd69a209c59b90fcd66365761..49281b59e9f4fbcf3b7688f3cd202c36bb6edeeb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out @@ -220,27 +220,6 @@ Synthesis round 1: Backward controlled-behavior: a.l2 [marker predicate] Backward controlled-behavior: a.l2 -> not(2 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 15 or 18 <= a.x and a.x <= 23)) and a.l2 or (a.x = 4 or a.x = 5 or (a.x = 20 or a.x = 21)) and a.l2 or ((a.x = 12 or a.x = 13) and a.l2 or ((a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) and a.l2 or (a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) and a.l2)) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not(2 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 15 or 18 <= a.x and a.x <= 23)) and a.l2 or (a.x = 4 or a.x = 5 or (a.x = 20 or a.x = 21)) and a.l2 or ((a.x = 12 or a.x = 13) and a.l2 or ((a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) and a.l2 or (a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) and a.l2)) -> (a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) and a.l2 or (a.x = 4 or a.x = 20) and a.l2 or (a.x = 12 and a.l2 or ((a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) and a.l2 or (a.x = 10 or a.x = 14) and a.l2)) or ((a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) and a.l2 or (a.x = 5 or a.x = 21 and a.l2) or (a.x = 13 and a.l2 or ((a.x = 3 or a.x = 7 or (a.x = 19 or a.x = 23)) and a.l2 or (a.x = 11 or a.x = 15) and a.l2))) [backward reach with edge: (event: b) (guard: a.x = 5 and a.l1) (assignments: a := a.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) and a.l2 or (a.x = 4 or a.x = 20) and a.l2 or (a.x = 12 and a.l2 or ((a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) and a.l2 or (a.x = 10 or a.x = 14) and a.l2)) or ((a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) and a.l2 or (a.x = 5 or a.x = 21 and a.l2) or (a.x = 13 and a.l2 or ((a.x = 3 or a.x = 7 or (a.x = 19 or a.x = 23)) and a.l2 or (a.x = 11 or a.x = 15) and a.l2))) -> (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and (not(a.x = 20 or a.x = 21) or a.l2) and ((not(a.x = 12 or a.x = 13) or a.l2) and ((not(a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) or a.l2) and (not(a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) or a.l2))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and (not(a.x = 20 or a.x = 21) or a.l2) and ((not(a.x = 12 or a.x = 13) or a.l2) and ((not(a.x = 2 or a.x = 3 or (a.x = 6 or a.x = 7) or (a.x = 18 or a.x = 19 or (a.x = 22 or a.x = 23))) or a.l2) and (not(a.x = 10 or a.x = 11 or (a.x = 14 or a.x = 15)) or a.l2))) -> (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((not(a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) or a.l2) and ((not(a.x = 10 or a.x = 14) or a.l2) and (not(a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) or a.l2))) and ((a.x != 21 or a.l2) and ((a.x != 13 or a.l2) and (a.x != 19 or a.l2)) and ((a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((not(a.x = 2 or a.x = 6 or (a.x = 18 or a.x = 22)) or a.l2) and ((not(a.x = 10 or a.x = 14) or a.l2) and (not(a.x = 1 or a.x = 9 or (a.x = 17 or a.x = 25)) or a.l2))) and ((a.x != 21 or a.l2) and ((a.x != 13 or a.l2) and (a.x != 19 or a.l2)) and ((a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) -> (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: (2 <= a.x and a.x <= 7 or 10 <= a.x and a.x <= 15 or (18 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) -> (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((a.x != 18 or a.l2) and (a.x != 10 or a.l2) and ((not(a.x = 6 or a.x = 22) or a.l2) and (a.x != 14 or a.l2))) and ((a.x != 17 or a.l2) and (not(a.x = 9 or a.x = 25) or a.l2) and ((a.x != 21 or a.l2) and (a.x != 13 or a.l2)) and ((a.x != 19 or a.l2) and (a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: (not(a.x = 0 or a.x = 8 or (a.x = 16 or a.x = 24)) or a.l2) and ((a.x != 20 or a.l2) and (a.x != 12 or a.l2)) and ((a.x != 18 or a.l2) and (a.x != 10 or a.l2) and ((not(a.x = 6 or a.x = 22) or a.l2) and (a.x != 14 or a.l2))) and ((a.x != 17 or a.l2) and (not(a.x = 9 or a.x = 25) or a.l2) and ((a.x != 21 or a.l2) and (a.x != 13 or a.l2)) and ((a.x != 19 or a.l2) and (a.x != 11 or a.l2) and ((not(a.x = 7 or a.x = 23) or a.l2) and (a.x != 15 or a.l2)))) -> (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - No change this iteration. - Backward controlled-behavior: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) [fixed point]. Controlled behavior: true -> (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))). @@ -253,67 +232,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: a.x = 1 and a.l1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: a.x = 1 and a.l1 -> a.x = 2 and a.l1 or a.x = 1 and a.l1 [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 2: - Forward controlled-behavior: a.x = 2 and a.l1 or a.x = 1 and a.l1 -> a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1 [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 3: - Forward controlled-behavior: a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1 -> a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 4: - Forward controlled-behavior: a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 1 or a.x = 3) and a.l1) -> a.x = 4 and a.l1 or a.x = 2 and a.l1 or ((a.x = 1 or a.x = 5) and a.l1 or a.x = 3 and a.l1) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - Forward controlled-behavior: a.x = 4 and a.l1 or a.x = 2 and a.l1 or ((a.x = 1 or a.x = 5) and a.l1 or a.x = 3 and a.l1) -> a.x = 4 and a.l1 or a.x = 2 and a.l1 or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) [forward reach with edge: (event: b) (guard: a.x = 5 and a.l1) (assignments: a := a.l2), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 5: - Forward controlled-behavior: a.x = 4 and a.l1 or a.x = 2 and a.l1 or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) -> a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 6: - Forward controlled-behavior: a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or (a.x = 5 or a.x = 3 and a.l1)) -> a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 7: - Forward controlled-behavior: a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 8: - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2)) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 9: - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or a.x = 6 and a.l2) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 10: - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or a.x = 9 and a.l2 or (a.x = 5 or (a.x = 3 and a.l1 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 11: - Forward controlled-behavior: a.x = 8 and a.l2 or a.x = 4 and a.l1 or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 12: - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 13: - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or a.x = 6 and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 14: - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or a.x = 7 and a.l2))) -> a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 15: - Forward controlled-behavior: a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 16: - Forward controlled-behavior: a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 17: - Forward controlled-behavior: a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 18: - Forward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 19: - Forward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 12 and a.l2) or (a.x = 2 and a.l1 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [forward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l2 or (8 <= a.x and (a.x <= 11 and a.l2) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l2)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2)))] - - Forward reachability iteration 20: - No change this iteration. - Forward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [fixed point]. Controlled behavior: (not(a.x = 16 or a.x = 17) or a.l2) and (0 <= a.x and a.x <= 7 or (10 <= a.x and a.x <= 23 or a.l2)) and ((not(a.x = 20 or a.x = 21) or a.l2) and (not(a.x = 12 or a.x = 13) or a.l2)) and ((not(a.x = 18 or a.x = 19) or a.l2) and (not(a.x = 10 or a.x = 11) or a.l2) and ((not(a.x = 6 or a.x = 7 or (a.x = 22 or a.x = 23)) or a.l2) and (not(a.x = 14 or a.x = 15) or a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))). @@ -325,24 +243,6 @@ Synthesis round 2: Backward controlled-behavior: a.l2 [marker predicate] Backward controlled-behavior: a.l2 -> (a.x = 16 or a.x = 20) and a.l2 or (a.x = 8 or a.x = 12) and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2) or ((a.x = 6 or a.x = 14) and a.l2 or (a.x = 17 or a.x = 19) and a.l2 or ((a.x = 9 or a.x = 11) and a.l2 or (a.x = 5 or a.x = 7 or (a.x = 13 or a.x = 15)) and a.l2)) [restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - Backward reachability iteration 1: - Backward controlled-behavior: (a.x = 16 or a.x = 20) and a.l2 or (a.x = 8 or a.x = 12) and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2) or ((a.x = 6 or a.x = 14) and a.l2 or (a.x = 17 or a.x = 19) and a.l2 or ((a.x = 9 or a.x = 11) and a.l2 or (a.x = 5 or a.x = 7 or (a.x = 13 or a.x = 15)) and a.l2)) -> (a.x = 16 or a.x = 20) and a.l2 or ((a.x = 8 or a.x = 12) and a.l2 or a.x = 18 and a.l2) or (a.x = 10 and a.l2 or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2)) or (a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [backward reach with edge: (event: b) (guard: a.x = 5 and a.l1) (assignments: a := a.l2), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 2: - Backward controlled-behavior: (a.x = 16 or a.x = 20) and a.l2 or ((a.x = 8 or a.x = 12) and a.l2 or a.x = 18 and a.l2) or (a.x = 10 and a.l2 or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2)) or (a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 20 and a.l2 or a.x = 12 and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 3: - Backward controlled-behavior: a.x = 16 and a.l2 or (a.x = 8 and a.l2 or a.x = 4 and a.l1) or (a.x = 20 and a.l2 or a.x = 12 and a.l2 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 17 and a.l2 or a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 3 and a.l1 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 4: - Backward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2)) or (a.x = 17 and a.l2 or a.x = 9 and a.l2 or (a.x = 5 or a.x = 13 and a.l2) or (a.x = 3 and a.l1 or a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 5: - Backward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or a.x = 10 and a.l2)) or ((a.x = 6 or a.x = 14) and a.l2 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) -> a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [backward reach with edge: (event: e) (guard: (0 <= a.x and a.x <= 3 or 16 <= a.x and a.x <= 19) and a.l1 or (8 <= a.x and (a.x <= 11 and a.l1) or (4 <= a.x and a.x <= 7 or 12 <= a.x and a.x <= 15) and a.l1)) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2))))] - - Backward reachability iteration 6: - No change this iteration. - Backward controlled-behavior: a.x = 16 and a.l2 or a.x = 8 and a.l2 or (a.x = 4 and a.l1 or a.x = 20 and a.l2) or (a.x = 12 and a.l2 or a.x = 2 and a.l1 or (a.x = 18 and a.l2 or (a.x = 10 and a.l2 or (a.x = 6 or a.x = 14) and a.l2))) or (a.x = 1 and a.l1 or a.x = 17 and a.l2 or (a.x = 9 and a.l2 or a.x = 5) or (a.x = 13 and a.l2 or a.x = 3 and a.l1 or (a.x = 19 and a.l2 or (a.x = 11 and a.l2 or (a.x = 7 or a.x = 15) and a.l2)))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/loc_refs.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/loc_refs.cif.out index ed05aaf0163e7ef272e541c8522de5d5ba58ed8e..d903053e3bc620b904407013a76cff3bf58a516c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/loc_refs.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/loc_refs.cif.out @@ -191,12 +191,6 @@ Synthesis round 1: Backward controlled-behavior: pe.a [marker predicate] Backward controlled-behavior: pe.a -> not pe.c and not pe.b [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not pe.c and not pe.b -> not pe.c [backward reach with edge: (event: e1) (guard: pe.b) (assignments: pe := pe.a), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: not pe.c [fixed point]. Controlled behavior: true -> not pe.c. @@ -209,12 +203,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: pe.a and (q1.x = 0 and q1.y = 1) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: pe.a and (q1.x = 0 and q1.y = 1) -> not pe.c and (q1.x = 0 and q1.y = 1) [forward reach with edge: (event: e1) (guard: pe.a) (assignments: pe := pe.b), restricted to current/previous controlled-behavior predicate: not pe.c] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: not pe.c and (q1.x = 0 and q1.y = 1) [fixed point]. Controlled behavior: not pe.c -> not pe.c and (q1.x = 0 and q1.y = 1). @@ -226,12 +214,6 @@ Synthesis round 2: Backward controlled-behavior: pe.a [marker predicate] Backward controlled-behavior: pe.a -> pe.a and (q1.x = 0 and q1.y = 1) [restricted to current/previous controlled-behavior predicate: not pe.c and (q1.x = 0 and q1.y = 1)] - Backward reachability iteration 1: - Backward controlled-behavior: pe.a and (q1.x = 0 and q1.y = 1) -> not pe.c and (q1.x = 0 and q1.y = 1) [backward reach with edge: (event: e1) (guard: pe.b) (assignments: pe := pe.a), restricted to current/previous controlled-behavior predicate: not pe.c and (q1.x = 0 and q1.y = 1)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: not pe.c and (q1.x = 0 and q1.y = 1) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out index f7319130c5f746df632915a32bc1e5ece7cde508..18bc0f9aa2d2bef847e127649c11379c9454a8f9 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out @@ -193,12 +193,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 or p.x = 3) and p.l2) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 or p.x = 3) and p.l2) -> (p.x != 4 or p.l2) and (p.x != 6 and (0 <= p.x and p.x <= 4 or p.x = 6)) [backward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: p.x != 7 or p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x != 4 or p.l2) and (p.x != 6 and (0 <= p.x and p.x <= 4 or p.x = 6)) [fixed point]. Controlled behavior: p.x != 7 or p.l2 -> (p.x != 4 or p.l2) and (p.x != 6 and (0 <= p.x and p.x <= 4 or p.x = 6)). @@ -206,21 +200,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x = 4 and p.l1 or p.x = 6 or (p.x = 5 or p.x = 7) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and p.l1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and p.l1 -> (p.x = 0 or p.x = 2) and p.l1 [forward reach with edge: (event: c) (guard: p.l1 -> (p.x = 0 or p.x = 1 or (p.x = 4 or p.x = 5)) and p.l1 or (p.x = 2 or p.x = 3) and p.l1) (assignments: p.x := p.x + 2), restricted to current/previous controlled-behavior predicate: (p.x != 4 or p.l2) and (p.x != 6 and (0 <= p.x and p.x <= 4 or p.x = 6))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 -> (p.x = 0 or p.x = 2) and p.l1 or (p.x = 1 or p.x = 3) and p.l2 [forward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 4 or p.l2) and (p.x != 6 and (0 <= p.x and p.x <= 4 or p.x = 6))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or (p.x = 1 or p.x = 3) and p.l2 [fixed point]. Controlled behavior: (p.x != 4 or p.l2) and (p.x != 6 and (0 <= p.x and p.x <= 4 or p.x = 6)) -> (p.x = 0 or p.x = 2) and p.l1 or (p.x = 1 or p.x = 3) and p.l2. @@ -232,12 +216,6 @@ Synthesis round 2: Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 or p.x = 3) and p.l2) [marker predicate] Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l2 or (p.x = 2 and p.l2 or (p.x = 1 or p.x = 3) and p.l2) -> (p.x = 1 or p.x = 3) and p.l2 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l1 or (p.x = 1 or p.x = 3) and p.l2] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 1 or p.x = 3) and p.l2 -> (p.x = 0 or p.x = 2) and p.l1 or (p.x = 1 or p.x = 3) and p.l2 [backward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l1 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l1 or (p.x = 1 or p.x = 3) and p.l2] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l1 or (p.x = 1 or p.x = 3) and p.l2 [fixed point]. Controlled behavior not changed. @@ -245,9 +223,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 1 or (3 <= p.x and p.x <= 7 or p.l2)) and (not(p.x = 1 or p.x = 3) or p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out index 517ee3c04ebb47efecb77687cb083096b07ae1ae..b691016339d5b1e1052cca68ff98a0f17b18aad0 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out @@ -230,23 +230,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) -> <bdd 24n 7p> [backward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 24n 7p> -> <bdd 23n 7p> [backward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 23n 7p> -> <bdd 24n 8p> [backward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 24n 8p> -> <bdd 22n 7p> [backward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 22n 7p> -> <bdd 24n 9p> [backward reach with edge: (event: c5) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 24n 9p> -> <bdd 23n 8p> [backward reach with edge: (event: c6) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l6), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 23n 8p> -> <bdd 24n 10p> [backward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l1 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l1 or ((p.x = 3 or p.x = 11) and p.l1 or p.x = 7 and p.l1)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 24n 10p> -> <bdd 23n 14p> [backward reach with edge: (event: u) (guard: p.l2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l2 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l2 or ((p.x = 3 or p.x = 11) and p.l2 or p.x = 7 and p.l2)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 23n 14p> -> <bdd 22n 15p> [backward reach with edge: (event: u) (guard: p.l3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l3 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l3 or ((p.x = 3 or p.x = 11) and p.l3 or p.x = 7 and p.l3)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: <bdd 22n 15p> -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l3) or p.x = 9 and p.l4 or (p.x = 9 and p.l2 or (p.x = 9 and (p.l1 or p.l5) or p.x = 9 and p.l3))) or (p.x = 5 and p.l4 or p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l3) or (p.x = 3 and p.l4 or p.x = 3 and p.l2)) or (p.x = 3 and (p.l1 or p.l3) or p.x = 11 and p.l6 or (p.x = 7 and p.l4 or (p.x = 7 and p.l2 or p.x = 7 and (p.l1 or p.l3))))) [backward reach with edge: (event: u) (guard: p.l4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l4 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l4 or ((p.x = 3 or p.x = 11) and p.l4 or p.x = 7 and p.l4)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l3) or p.x = 9 and p.l4 or (p.x = 9 and p.l2 or (p.x = 9 and (p.l1 or p.l5) or p.x = 9 and p.l3))) or (p.x = 5 and p.l4 or p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l3) or (p.x = 3 and p.l4 or p.x = 3 and p.l2)) or (p.x = 3 and (p.l1 or p.l3) or p.x = 11 and p.l6 or (p.x = 7 and p.l4 or (p.x = 7 and p.l2 or p.x = 7 and (p.l1 or p.l3))))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or (p.x = 1 or p.x = 9) and p.l2) or ((p.x = 1 or p.x = 9) and (p.l1 or p.l5) or (p.x = 1 or p.x = 9) and p.l3 or (p.x = 5 and p.l4 or (p.x = 5 and p.l2 or p.x = 5 and (p.l1 or p.l5)))) or (p.x = 5 and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)) or (p.x = 11 and p.l6 or p.x = 7 and p.l4 or (p.x = 7 and p.l2 or (p.x = 7 and (p.l1 or p.l5) or p.x = 7 and p.l3)))) [backward reach with edge: (event: u) (guard: p.l5 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l5 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l5 or ((p.x = 3 or p.x = 11) and p.l5 or p.x = 7 and p.l5)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or (p.x = 1 or p.x = 9) and p.l2) or ((p.x = 1 or p.x = 9) and (p.l1 or p.l5) or (p.x = 1 or p.x = 9) and p.l3 or (p.x = 5 and p.l4 or (p.x = 5 and p.l2 or p.x = 5 and (p.l1 or p.l5)))) or (p.x = 5 and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)) or (p.x = 11 and p.l6 or p.x = 7 and p.l4 or (p.x = 7 and p.l2 or (p.x = 7 and (p.l1 or p.l5) or p.x = 7 and p.l3)))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or (p.x = 1 or p.x = 9) and (p.l2 or p.l6)) or ((p.x = 1 or p.x = 9) and (p.l1 or p.l5) or (p.x = 1 or p.x = 9) and p.l3 or (p.x = 5 and p.l4 or (p.x = 5 and (p.l2 or p.l6) or p.x = 5 and (p.l1 or p.l5)))) or (p.x = 5 and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)) or (p.x = 11 and p.l6 or p.x = 7 and p.l4 or (p.x = 7 and (p.l2 or p.l6) or (p.x = 7 and (p.l1 or p.l5) or p.x = 7 and p.l3)))) [backward reach with edge: (event: u) (guard: p.l6 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l6 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l6 or ((p.x = 3 or p.x = 11) and p.l6 or p.x = 7 and p.l6)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5)))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or (p.x = 1 or p.x = 9) and (p.l2 or p.l6)) or ((p.x = 1 or p.x = 9) and (p.l1 or p.l5) or (p.x = 1 or p.x = 9) and p.l3 or (p.x = 5 and p.l4 or (p.x = 5 and (p.l2 or p.l6) or p.x = 5 and (p.l1 or p.l5)))) or (p.x = 5 and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)) or (p.x = 11 and p.l6 or p.x = 7 and p.l4 or (p.x = 7 and (p.l2 or p.l6) or (p.x = 7 and (p.l1 or p.l5) or p.x = 7 and p.l3)))) [fixed point]. Controlled behavior: (p.x != 15 or not p.l4) and ((p.x != 15 or not p.l2 and not p.l6) and (p.x != 15 or not p.l1 and (not p.l3 and not p.l5))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or (p.x = 1 or p.x = 9) and (p.l2 or p.l6)) or ((p.x = 1 or p.x = 9) and (p.l1 or p.l5) or (p.x = 1 or p.x = 9) and p.l3 or (p.x = 5 and p.l4 or (p.x = 5 and (p.l2 or p.l6) or p.x = 5 and (p.l1 or p.l5)))) or (p.x = 5 and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)) or (p.x = 11 and p.l6 or p.x = 7 and p.l4 or (p.x = 7 and (p.l2 or p.l6) or (p.x = 7 and (p.l1 or p.l5) or p.x = 7 and p.l3)))). @@ -254,12 +237,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l4 or (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l2 or p.l6) or ((p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l1 or (p.l3 or p.l5)) or (p.x = 4 or p.x = 6) and p.l4) or ((p.x = 4 or p.x = 6) and (p.l2 or p.l6) or (p.x = 4 or p.x = 6) and (p.l1 or (p.l3 or p.l5)) or (p.x = 12 or p.x = 14)) or ((p.x = 1 or p.x = 9) and p.l0 or p.x = 5 and p.l0 or (p.x = 13 or p.x = 3 and p.l0) or (p.x = 11 and (p.l0 or p.l4) or p.x = 11 and p.l2 or (p.x = 11 and (p.l1 or (p.l3 or p.l5)) or (p.x = 7 and p.l0 or p.x = 15)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l4 or (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l2 or p.l6) or ((p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l1 or (p.l3 or p.l5)) or (p.x = 4 or p.x = 6) and p.l4) or ((p.x = 4 or p.x = 6) and (p.l2 or p.l6) or (p.x = 4 or p.x = 6) and (p.l1 or (p.l3 or p.l5)) or (p.x = 12 or p.x = 14)) or ((p.x = 1 or p.x = 9) and p.l0 or p.x = 5 and p.l0 or (p.x = 13 or p.x = 3 and p.l0) or (p.x = 11 and (p.l0 or p.l4) or p.x = 11 and p.l2 or (p.x = 11 and (p.l1 or (p.l3 or p.l5)) or (p.x = 7 and p.l0 or p.x = 15)))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l4 or ((p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l2 or p.l6) or (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l1 or (p.l3 or p.l5))) or ((p.x = 4 or p.x = 6) and p.l4 or (p.x = 4 or p.x = 6) and (p.l2 or p.l6) or ((p.x = 4 or p.x = 6) and (p.l1 or (p.l3 or p.l5)) or p.x = 12)) or (p.x = 14 or ((p.x = 1 or p.x = 9) and p.l0 or p.x = 5 and p.l0) or (p.x = 13 or (p.x = 3 or p.x = 7) and p.l0 or (p.x = 11 or p.x = 15))) [backward reach with edge: (event: u) (guard: p.l6 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l6 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l6 or ((p.x = 3 or p.x = 11) and p.l6 or p.x = 7 and p.l6)) (assignments: p.x := p.x + 1, p := p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l4 or ((p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l2 or p.l6) or (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and (p.l1 or (p.l3 or p.l5))) or ((p.x = 4 or p.x = 6) and p.l4 or (p.x = 4 or p.x = 6) and (p.l2 or p.l6) or ((p.x = 4 or p.x = 6) and (p.l1 or (p.l3 or p.l5)) or p.x = 12)) or (p.x = 14 or ((p.x = 1 or p.x = 9) and p.l0 or p.x = 5 and p.l0) or (p.x = 13 or (p.x = 3 or p.x = 7) and p.l0 or (p.x = 11 or p.x = 15))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or (p.x = 1 or p.x = 9) and (p.l2 or p.l6)) or ((p.x = 1 or p.x = 9) and (p.l1 or p.l5) or (p.x = 1 or p.x = 9) and p.l3 or (p.x = 5 and p.l4 or (p.x = 5 and (p.l2 or p.l6) or p.x = 5 and (p.l1 or p.l5)))) or (p.x = 5 and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)) or (p.x = 11 and p.l6 or p.x = 7 and p.l4 or (p.x = 7 and (p.l2 or p.l6) or (p.x = 7 and (p.l1 or p.l5) or p.x = 7 and p.l3)))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))). @@ -268,17 +245,6 @@ Synthesis round 1: Forward controlled-behavior: p.l0 [initialization predicate] Forward controlled-behavior: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l1 or (p.x = 5 and p.l1 or (p.x = 3 or p.x = 7) and p.l1)) [forward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l1 or (p.x = 5 and p.l1 or (p.x = 3 or p.x = 7) and p.l1)) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and p.l1) or (p.x = 5 and p.l2 or p.x = 5 and p.l1 or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and p.l1)) [forward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and p.l1) or (p.x = 5 and p.l2 or p.x = 5 and p.l1 or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and p.l1)) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and (p.l1 or p.l3)) or (p.x = 5 and p.l2 or p.x = 5 and (p.l1 or p.l3) or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and (p.l1 or p.l3))) [forward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and (p.l1 or p.l3)) or (p.x = 5 and p.l2 or p.x = 5 and (p.l1 or p.l3) or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and (p.l1 or p.l3))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and (p.l1 or p.l3))) or (p.x = 5 and p.l4 or (p.x = 5 and p.l2 or p.x = 5 and (p.l1 or p.l3)) or ((p.x = 3 or p.x = 7) and p.l4 or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and (p.l1 or p.l3)))) [forward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or (p.x = 4 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 9) and p.l4 or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and (p.l1 or p.l3))) or (p.x = 5 and p.l4 or (p.x = 5 and p.l2 or p.x = 5 and (p.l1 or p.l3)) or ((p.x = 3 or p.x = 7) and p.l4 or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and (p.l1 or p.l3)))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and p.l2 or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) [forward reach with edge: (event: c5) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and p.l2 or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and p.l2 or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) -> (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) [forward reach with edge: (event: c6) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l6), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) [fixed point]. Controlled behavior not changed. @@ -290,22 +256,6 @@ Synthesis round 2: Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) [marker predicate] Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) -> p.x = 1 and p.l1 or p.x = 9 and p.l5 or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and p.l1 or p.x = 9 and p.l5 or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) -> <bdd 22n 6p> [backward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: <bdd 22n 6p> -> <bdd 21n 6p> [backward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: <bdd 21n 6p> -> <bdd 22n 7p> [backward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: <bdd 22n 7p> -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 and p.l1 or p.x = 9 and p.l5) or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) [backward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 and p.l1 or p.x = 9 and p.l5) or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) -> <bdd 22n 8p> [backward reach with edge: (event: c5) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: <bdd 22n 8p> -> <bdd 22n 10p> [backward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l1 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l1 or ((p.x = 3 or p.x = 11) and p.l1 or p.x = 7 and p.l1)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: <bdd 22n 10p> -> <bdd 22n 13p> [backward reach with edge: (event: u) (guard: p.l2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l2 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l2 or ((p.x = 3 or p.x = 11) and p.l2 or p.x = 7 and p.l2)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: <bdd 22n 13p> -> (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or (p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l3) or p.x = 9 and p.l5)) or (p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l3) or p.x = 3 and p.l2) or (p.x = 3 and (p.l1 or p.l3) or p.x = 7 and p.l4 or (p.x = 7 and p.l2 or p.x = 7 and (p.l1 or p.l3)))) [backward reach with edge: (event: u) (guard: p.l3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l3 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l3 or ((p.x = 3 or p.x = 11) and p.l3 or p.x = 7 and p.l3)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or (p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l3) or p.x = 9 and p.l5)) or (p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l3) or p.x = 3 and p.l2) or (p.x = 3 and (p.l1 or p.l3) or p.x = 7 and p.l4 or (p.x = 7 and p.l2 or p.x = 7 and (p.l1 or p.l3)))) -> (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or (p.x = 1 and p.l4 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l3))) or (p.x = 9 and p.l5 or (p.x = 5 and p.l4 or p.x = 5 and p.l2) or (p.x = 5 and (p.l1 or p.l3) or (p.x = 3 or p.x = 7) and p.l4 or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and (p.l1 or p.l3)))) [backward reach with edge: (event: u) (guard: p.l4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l4 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l4 or ((p.x = 3 or p.x = 11) and p.l4 or p.x = 7 and p.l4)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or (p.x = 1 and p.l4 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l3))) or (p.x = 9 and p.l5 or (p.x = 5 and p.l4 or p.x = 5 and p.l2) or (p.x = 5 and (p.l1 or p.l3) or (p.x = 3 or p.x = 7) and p.l4 or ((p.x = 3 or p.x = 7) and p.l2 or (p.x = 3 or p.x = 7) and (p.l1 or p.l3)))) -> (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or p.x = 1 and p.l4) or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 9 and p.l5)) or (p.x = 5 and p.l4 or p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and p.l2 or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) [backward reach with edge: (event: u) (guard: p.l5 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l5 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l5 or ((p.x = 3 or p.x = 11) and p.l5 or p.x = 7 and p.l5)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or p.x = 1 and p.l4) or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 9 and p.l5)) or (p.x = 5 and p.l4 or p.x = 5 and p.l2 or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and p.l2 or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) -> (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or p.x = 1 and p.l4) or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 9 and p.l5)) or (p.x = 5 and p.l4 or p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) [backward reach with edge: (event: u) (guard: p.l6 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l6 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l6 or ((p.x = 3 or p.x = 11) and p.l6 or p.x = 7 and p.l6)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3)))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or p.x = 1 and p.l4) or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 9 and p.l5)) or (p.x = 5 and p.l4 or p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2 or (p.x = 8 or p.x = 10)) and p.l0 or ((p.x = 4 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 9) and p.l4) or ((p.x = 1 or p.x = 9) and (p.l2 or p.l6) or (p.x = 1 or p.x = 9) and (p.l1 or p.l5) or ((p.x = 1 or p.x = 9) and p.l3 or p.x = 5 and p.l4)) or (p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) -> (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or p.x = 1 and p.l4) or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 9 and p.l5)) or (p.x = 5 and p.l4 or p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))). @@ -313,12 +263,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 17n 22p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: <bdd 17n 22p> -> (not(p.x = 0 or p.x = 8) or not p.l0) and ((p.x != 4 or not p.l0) and (not(p.x = 2 or p.x = 6) or not p.l0)) and ((not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l4) and (not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l2 and not p.l6) and ((not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l1 and not p.l5) and (not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l3))) [backward reach with edge: (event: u) (guard: p.l5 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l5 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l5 or ((p.x = 3 or p.x = 11) and p.l5 or p.x = 7 and p.l5)) (assignments: p.x := p.x + 1, p := p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (not(p.x = 0 or p.x = 8) or not p.l0) and ((p.x != 4 or not p.l0) and (not(p.x = 2 or p.x = 6) or not p.l0)) and ((not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l4) and (not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l2 and not p.l6) and ((not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l1 and not p.l5) and (not(p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) or not p.l3))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or p.x = 1 and p.l4) or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 9 and p.l5)) or (p.x = 5 and p.l4 or p.x = 5 and (p.l2 or p.l6) or (p.x = 5 and (p.l1 or p.l5) or p.x = 5 and p.l3) or ((p.x = 3 or p.x = 7) and p.l4 or (p.x = 3 or p.x = 7) and (p.l2 or p.l6) or ((p.x = 3 or p.x = 7) and (p.l1 or p.l5) or (p.x = 3 or p.x = 7) and p.l3))) -> (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3)). @@ -327,17 +271,6 @@ Synthesis round 2: Forward controlled-behavior: p.l0 [initialization predicate] Forward controlled-behavior: p.l0 -> (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) -> (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l1) [forward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l1) -> (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l1)) [forward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l1)) -> (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l3))) [forward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or p.x = 4 and p.l0 or ((p.x = 2 or p.x = 6) and p.l0 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l3))) -> (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l3))) [forward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l3))) -> (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3)) [forward reach with edge: (event: c5) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l2 or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3)) -> (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3)) [forward reach with edge: (event: c6) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l6), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3)) [fixed point]. Controlled behavior not changed. @@ -349,21 +282,6 @@ Synthesis round 3: Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) [marker predicate] Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) -> p.x = 1 and p.l1 or p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4) [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and p.l1 or p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4) -> <bdd 21n 5p> [backward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: <bdd 21n 5p> -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) [backward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) -> <bdd 21n 6p> [backward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: <bdd 21n 6p> -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) [backward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 7 and p.l4)) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 and p.l1 or p.x = 5 and (p.l1 or p.l3)) or (p.x = 3 and p.l2 or (p.x = 3 and p.l1 or p.x = 7 and p.l4)) [backward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l1 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l1 or ((p.x = 3 or p.x = 11) and p.l1 or p.x = 7 and p.l1)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 and p.l1 or p.x = 5 and (p.l1 or p.l3)) or (p.x = 3 and p.l2 or (p.x = 3 and p.l1 or p.x = 7 and p.l4)) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or p.x = 1 and p.l2 or (p.x = 1 and p.l1 or p.x = 5 and p.l2) or (p.x = 5 and (p.l1 or p.l3) or p.x = 3 and p.l2 or (p.x = 3 and p.l1 or p.x = 7 and p.l4)) [backward reach with edge: (event: u) (guard: p.l2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l2 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l2 or ((p.x = 3 or p.x = 11) and p.l2 or p.x = 7 and p.l2)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or p.x = 1 and p.l2 or (p.x = 1 and p.l1 or p.x = 5 and p.l2) or (p.x = 5 and (p.l1 or p.l3) or p.x = 3 and p.l2 or (p.x = 3 and p.l1 or p.x = 7 and p.l4)) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or ((p.x = 1 or p.x = 5) and p.l2 or (p.x = 1 or p.x = 5) and (p.l1 or p.l3)) or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l3) or p.x = 7 and p.l4)) [backward reach with edge: (event: u) (guard: p.l3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l3 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l3 or ((p.x = 3 or p.x = 11) and p.l3 or p.x = 7 and p.l3)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or ((p.x = 1 or p.x = 5) and p.l2 or (p.x = 1 or p.x = 5) and (p.l1 or p.l3)) or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l3) or p.x = 7 and p.l4)) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and p.l2 or (p.x = 1 or p.x = 5) and (p.l1 or p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l3) or p.x = 7 and p.l4)) [backward reach with edge: (event: u) (guard: p.l4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l4 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l4 or ((p.x = 3 or p.x = 11) and p.l4 or p.x = 7 and p.l4)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and p.l2 or (p.x = 1 or p.x = 5) and (p.l1 or p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l3) or p.x = 7 and p.l4)) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and p.l2 or ((p.x = 1 or p.x = 5) and (p.l1 or p.l5) or (p.x = 1 or p.x = 5) and p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or (p.x = 3 and p.l3 or p.x = 7 and p.l4))) [backward reach with edge: (event: u) (guard: p.l5 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l5 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l5 or ((p.x = 3 or p.x = 11) and p.l5 or p.x = 7 and p.l5)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and p.l2 or ((p.x = 1 or p.x = 5) and (p.l1 or p.l5) or (p.x = 1 or p.x = 5) and p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or (p.x = 3 and p.l3 or p.x = 7 and p.l4))) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 5) and (p.l1 or p.l5) or (p.x = 1 or p.x = 5) and p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or (p.x = 3 and p.l3 or p.x = 7 and p.l4))) [backward reach with edge: (event: u) (guard: p.l6 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l6 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l6 or ((p.x = 3 or p.x = 11) and p.l6 or p.x = 7 and p.l6)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 5) and (p.l1 or p.l5) or (p.x = 1 or p.x = 5) and p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or (p.x = 3 and p.l3 or p.x = 7 and p.l4))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 8) and p.l0 or (p.x = 4 and p.l0 or (p.x = 2 or p.x = 6) and p.l0) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l4 or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3 or (p.x = 5 or p.x = 7)) and p.l3)) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 5) and (p.l1 or p.l5) or (p.x = 1 or p.x = 5) and p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or (p.x = 3 and p.l3 or p.x = 7 and p.l4))). @@ -371,12 +289,6 @@ Synthesis round 3: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 1 or p.x = 3 or (p.x = 5 or (7 <= p.x and p.x <= 15 or not p.l0))) and (not(p.x = 1 or p.x = 5) or not p.l4) and ((not(p.x = 1 or p.x = 5) or not p.l2 and not p.l6) and ((not(p.x = 1 or p.x = 5) or not p.l1 and not p.l5) and (not(p.x = 1 or p.x = 5) or not p.l3))) and ((p.x != 3 or not p.l4) and (p.x != 3 or not p.l2 and not p.l6) and ((p.x != 3 or not p.l1 and not p.l5) and ((p.x != 3 or not p.l3) and (p.x != 7 or not p.l4)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.x = 1 or p.x = 3 or (p.x = 5 or (7 <= p.x and p.x <= 15 or not p.l0))) and (not(p.x = 1 or p.x = 5) or not p.l4) and ((not(p.x = 1 or p.x = 5) or not p.l2 and not p.l6) and ((not(p.x = 1 or p.x = 5) or not p.l1 and not p.l5) and (not(p.x = 1 or p.x = 5) or not p.l3))) and ((p.x != 3 or not p.l4) and (p.x != 3 or not p.l2 and not p.l6) and ((p.x != 3 or not p.l1 and not p.l5) and ((p.x != 3 or not p.l3) and (p.x != 7 or not p.l4)))) -> (p.x = 1 or p.x = 3 or (p.x = 5 or (7 <= p.x and p.x <= 15 or not p.l0))) and (not(p.x = 1 or p.x = 5) or not p.l4) and ((not(p.x = 1 or p.x = 5) or not p.l2 and not p.l6) and (not(p.x = 1 or p.x = 5) or not p.l1 and not p.l5)) and ((not(p.x = 1 or p.x = 5) or not p.l3) and (p.x != 3 or not p.l4) and ((p.x != 3 or not p.l2 and not p.l6) and ((p.x != 3 or not p.l1 and not p.l5) and (p.x != 3 or not p.l3)))) [backward reach with edge: (event: u) (guard: p.l4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l4 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l4 or ((p.x = 3 or p.x = 11) and p.l4 or p.x = 7 and p.l4)) (assignments: p.x := p.x + 1, p := p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (p.x = 1 or p.x = 3 or (p.x = 5 or (7 <= p.x and p.x <= 15 or not p.l0))) and (not(p.x = 1 or p.x = 5) or not p.l4) and ((not(p.x = 1 or p.x = 5) or not p.l2 and not p.l6) and (not(p.x = 1 or p.x = 5) or not p.l1 and not p.l5)) and ((not(p.x = 1 or p.x = 5) or not p.l3) and (p.x != 3 or not p.l4) and ((p.x != 3 or not p.l2 and not p.l6) and ((p.x != 3 or not p.l1 and not p.l5) and (p.x != 3 or not p.l3)))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 5) and (p.l1 or p.l5) or (p.x = 1 or p.x = 5) and p.l3)) or (p.x = 3 and p.l4 or p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or (p.x = 3 and p.l3 or p.x = 7 and p.l4))) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))). @@ -385,17 +297,6 @@ Synthesis round 3: Forward controlled-behavior: p.l0 [initialization predicate] Forward controlled-behavior: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) [forward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or ((p.x = 1 or p.x = 5) and p.l1 or p.x = 3 and p.l1) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l2 or ((p.x = 1 or p.x = 5) and p.l1 or (p.x = 3 and p.l2 or p.x = 3 and p.l1)) [forward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l2 or ((p.x = 1 or p.x = 5) and p.l1 or (p.x = 3 and p.l2 or p.x = 3 and p.l1)) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l2 or ((p.x = 1 or p.x = 5) and (p.l1 or p.l3) or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3))) [forward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l2 or ((p.x = 1 or p.x = 5) and (p.l1 or p.l3) or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3))) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or ((p.x = 1 or p.x = 5) and p.l4 or (p.x = 1 or p.x = 5) and p.l2) or ((p.x = 1 or p.x = 5) and (p.l1 or p.l3) or p.x = 3 and p.l4 or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3))) [forward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or ((p.x = 1 or p.x = 5) and p.l4 or (p.x = 1 or p.x = 5) and p.l2) or ((p.x = 1 or p.x = 5) and (p.l1 or p.l3) or p.x = 3 and p.l4 or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3))) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and p.l2 or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) [forward reach with edge: (event: c5) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and p.l2 or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) [forward reach with edge: (event: c6) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l6), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) [fixed point]. Controlled behavior not changed. @@ -407,20 +308,6 @@ Synthesis round 4: Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) [marker predicate] Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) -> p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2) [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2) -> p.x = 0 and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2) [backward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: p.x = 0 and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2) [backward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2)) [backward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l1 or (p.x = 5 and p.l3 or p.x = 3 and p.l2)) -> (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or p.x = 1 and p.l1) or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 3 and p.l1)) [backward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l1 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l1 or ((p.x = 3 or p.x = 11) and p.l1 or p.x = 7 and p.l1)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or p.x = 1 and p.l1) or (p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 3 and p.l1)) -> (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or p.x = 1 and p.l2) or (p.x = 1 and p.l1 or p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 3 and p.l1)) [backward reach with edge: (event: u) (guard: p.l2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l2 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l2 or ((p.x = 3 or p.x = 11) and p.l2 or p.x = 7 and p.l2)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or p.x = 1 and p.l2) or (p.x = 1 and p.l1 or p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 3 and p.l1)) -> (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l3) or p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3))) [backward reach with edge: (event: u) (guard: p.l3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l3 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l3 or ((p.x = 3 or p.x = 11) and p.l3 or p.x = 7 and p.l3)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l3) or p.x = 5 and p.l3 or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3))) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l3) or p.x = 5 and p.l3 or (p.x = 3 and p.l4 or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3)))) [backward reach with edge: (event: u) (guard: p.l4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l4 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l4 or ((p.x = 3 or p.x = 11) and p.l4 or p.x = 7 and p.l4)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l3) or p.x = 5 and p.l3 or (p.x = 3 and p.l4 or (p.x = 3 and p.l2 or p.x = 3 and (p.l1 or p.l3)))) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l5))) or (p.x = 1 and p.l3 or (p.x = 5 and p.l3 or p.x = 3 and p.l4) or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) [backward reach with edge: (event: u) (guard: p.l5 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l5 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l5 or ((p.x = 3 or p.x = 11) and p.l5 or p.x = 7 and p.l5)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l5))) or (p.x = 1 and p.l3 or (p.x = 5 and p.l3 or p.x = 3 and p.l4) or (p.x = 3 and p.l2 or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5))) or (p.x = 1 and p.l3 or (p.x = 5 and p.l3 or p.x = 3 and p.l4) or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) [backward reach with edge: (event: u) (guard: p.l6 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l6 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l6 or ((p.x = 3 or p.x = 11) and p.l6 or p.x = 7 and p.l6)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3)))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5))) or (p.x = 1 and p.l3 or (p.x = 5 and p.l3 or p.x = 3 and p.l4) or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and p.l0 or (p.x = 1 or p.x = 5) and p.l4 or ((p.x = 1 or p.x = 5) and (p.l2 or p.l6) or (p.x = 1 or p.x = 5) and (p.l1 or p.l5)) or ((p.x = 1 or p.x = 5) and p.l3 or p.x = 3 and p.l4 or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5))) or (p.x = 1 and p.l3 or (p.x = 5 and p.l3 or p.x = 3 and p.l4) or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))). @@ -428,12 +315,6 @@ Synthesis round 4: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (not(p.x = 0 or p.x = 4) or not p.l0) and (p.x != 2 or not p.l0) and ((p.x != 1 or not p.l4) and ((p.x != 1 or not p.l2 and not p.l6) and (p.x != 1 or not p.l1 and not p.l5))) and ((p.x != 1 or not p.l3) and ((p.x != 5 or not p.l3) and (p.x != 3 or not p.l4)) and ((p.x != 3 or not p.l2 and not p.l6) and ((p.x != 3 or not p.l1 and not p.l5) and (p.x != 3 or not p.l3)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (not(p.x = 0 or p.x = 4) or not p.l0) and (p.x != 2 or not p.l0) and ((p.x != 1 or not p.l4) and ((p.x != 1 or not p.l2 and not p.l6) and (p.x != 1 or not p.l1 and not p.l5))) and ((p.x != 1 or not p.l3) and ((p.x != 5 or not p.l3) and (p.x != 3 or not p.l4)) and ((p.x != 3 or not p.l2 and not p.l6) and ((p.x != 3 or not p.l1 and not p.l5) and (p.x != 3 or not p.l3)))) -> (not(p.x = 0 or p.x = 4) or not p.l0) and ((p.x != 2 or not p.l0) and (not(p.x = 1 or p.x = 3) or not p.l4)) and ((not(p.x = 1 or p.x = 3) or not p.l2 and not p.l6) and ((not(p.x = 1 or p.x = 3) or not p.l1 and not p.l5) and (not(p.x = 1 or p.x = 3) or not p.l3))) [backward reach with edge: (event: u) (guard: p.l3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l3 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l3 or ((p.x = 3 or p.x = 11) and p.l3 or p.x = 7 and p.l3)) (assignments: p.x := p.x + 1, p := p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (not(p.x = 0 or p.x = 4) or not p.l0) and ((p.x != 2 or not p.l0) and (not(p.x = 1 or p.x = 3) or not p.l4)) and ((not(p.x = 1 or p.x = 3) or not p.l2 and not p.l6) and ((not(p.x = 1 or p.x = 3) or not p.l1 and not p.l5) and (not(p.x = 1 or p.x = 3) or not p.l3))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or (p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or p.x = 1 and (p.l1 or p.l5))) or (p.x = 1 and p.l3 or (p.x = 5 and p.l3 or p.x = 3 and p.l4) or (p.x = 3 and (p.l2 or p.l6) or (p.x = 3 and (p.l1 or p.l5) or p.x = 3 and p.l3))) -> (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3)). @@ -442,17 +323,6 @@ Synthesis round 4: Forward controlled-behavior: p.l0 [initialization predicate] Forward controlled-behavior: p.l0 -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 -> (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l1) [forward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l1) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or ((p.x = 1 or p.x = 3) and p.l2 or (p.x = 1 or p.x = 3) and p.l1) [forward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or ((p.x = 1 or p.x = 3) and p.l2 or (p.x = 1 or p.x = 3) and p.l1) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or ((p.x = 1 or p.x = 3) and p.l2 or (p.x = 1 or p.x = 3) and (p.l1 or p.l3)) [forward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or ((p.x = 1 or p.x = 3) and p.l2 or (p.x = 1 or p.x = 3) and (p.l1 or p.l3)) -> (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or ((p.x = 1 or p.x = 3) and p.l4 or ((p.x = 1 or p.x = 3) and p.l2 or (p.x = 1 or p.x = 3) and (p.l1 or p.l3))) [forward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or p.x = 2 and p.l0 or ((p.x = 1 or p.x = 3) and p.l4 or ((p.x = 1 or p.x = 3) and p.l2 or (p.x = 1 or p.x = 3) and (p.l1 or p.l3))) -> (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and p.l2 or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3)) [forward reach with edge: (event: c5) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and p.l2 or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3)) -> (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3)) [forward reach with edge: (event: c6) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l6), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3)) [fixed point]. Controlled behavior not changed. @@ -464,18 +334,6 @@ Synthesis round 5: Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) [marker predicate] Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) -> p.x = 1 and p.l1 or p.x = 3 and p.l2 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and p.l1 or p.x = 3 and p.l2 -> p.x = 0 and p.l0 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) [backward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Backward controlled-behavior: p.x = 0 and p.l0 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) [backward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) [backward reach with edge: (event: u) (guard: p.l2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l2 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l2 or ((p.x = 3 or p.x = 11) and p.l2 or p.x = 7 and p.l2)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l2 or (p.x = 1 and p.l1 or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l3) or p.x = 3 and p.l2) [backward reach with edge: (event: u) (guard: p.l3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l3 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l3 or ((p.x = 3 or p.x = 11) and p.l3 or p.x = 7 and p.l3)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l3) or p.x = 3 and p.l2) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l3) or p.x = 3 and p.l2)) [backward reach with edge: (event: u) (guard: p.l4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l4 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l4 or ((p.x = 3 or p.x = 11) and p.l4 or p.x = 7 and p.l4)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l3) or p.x = 3 and p.l2)) -> (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 3 and p.l2)) [backward reach with edge: (event: u) (guard: p.l5 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l5 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l5 or ((p.x = 3 or p.x = 11) and p.l5 or p.x = 7 and p.l5)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and p.l2) or (p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 3 and p.l2)) -> (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and (p.l2 or p.l6)) or (p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 3 and p.l2)) [backward reach with edge: (event: u) (guard: p.l6 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l6 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l6 or ((p.x = 3 or p.x = 11) and p.l6 or p.x = 7 and p.l6)) (assignments: p.x := p.x + 1, p := p.l0), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and (p.l2 or p.l6)) or (p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 3 and p.l2)) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 4) and p.l0 or (p.x = 2 and p.l0 or (p.x = 1 or p.x = 3) and p.l4) or ((p.x = 1 or p.x = 3) and (p.l2 or p.l6) or ((p.x = 1 or p.x = 3) and (p.l1 or p.l5) or (p.x = 1 or p.x = 3) and p.l3)) -> (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and (p.l2 or p.l6)) or (p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 3 and p.l2)). @@ -483,12 +341,6 @@ Synthesis round 5: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 1 or (3 <= p.x and p.x <= 15 or not p.l0)) and ((p.x != 1 or not p.l4) and (p.x != 1 or not p.l2 and not p.l6)) and ((p.x != 1 or not p.l1 and not p.l5) and ((p.x != 1 or not p.l3) and (p.x != 3 or not p.l2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.x = 1 or (3 <= p.x and p.x <= 15 or not p.l0)) and ((p.x != 1 or not p.l4) and (p.x != 1 or not p.l2 and not p.l6)) and ((p.x != 1 or not p.l1 and not p.l5) and ((p.x != 1 or not p.l3) and (p.x != 3 or not p.l2))) -> (p.x = 1 or (3 <= p.x and p.x <= 15 or not p.l0)) and (p.x != 1 or not p.l4) and ((p.x != 1 or not p.l2 and not p.l6) and ((p.x != 1 or not p.l1 and not p.l5) and (p.x != 1 or not p.l3))) [backward reach with edge: (event: u) (guard: p.l2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l2 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l2 or ((p.x = 3 or p.x = 11) and p.l2 or p.x = 7 and p.l2)) (assignments: p.x := p.x + 1, p := p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (p.x = 1 or (3 <= p.x and p.x <= 15 or not p.l0)) and (p.x != 1 or not p.l4) and ((p.x != 1 or not p.l2 and not p.l6) and ((p.x != 1 or not p.l1 and not p.l5) and (p.x != 1 or not p.l3))) [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l4 or p.x = 1 and (p.l2 or p.l6)) or (p.x = 1 and (p.l1 or p.l5) or (p.x = 1 and p.l3 or p.x = 3 and p.l2)) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3)). @@ -497,17 +349,6 @@ Synthesis round 5: Forward controlled-behavior: p.l0 [initialization predicate] Forward controlled-behavior: p.l0 -> (p.x = 0 or p.x = 2) and p.l0 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - Forward reachability iteration 1: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l1 [forward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l1 -> (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l2 or p.x = 1 and p.l1) [forward reach with edge: (event: c2) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l2), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l2 or p.x = 1 and p.l1) -> (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l3)) [forward reach with edge: (event: c3) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l3), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l3)) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l3)) [forward reach with edge: (event: c4) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l4), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and p.l2 or p.x = 1 and (p.l1 or p.l3)) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3)) [forward reach with edge: (event: c5) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l5), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and p.l2 or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3)) -> (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3)) [forward reach with edge: (event: c6) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l6), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3)) [fixed point]. Controlled behavior not changed. @@ -519,12 +360,6 @@ Synthesis round 6: Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) [marker predicate] Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) -> p.x = 1 and p.l1 [restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 1 and p.l1 -> p.x = 0 and p.l0 or p.x = 1 and p.l1 [backward reach with edge: (event: c1) (guard: p.l0 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l0 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l0 or ((p.x = 3 or p.x = 11) and p.l0 or p.x = 7 and p.l0)) (assignments: p.x := p.x + 1, p := p.l1), restricted to current/previous controlled-behavior predicate: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 0 and p.l0 or p.x = 1 and p.l1 [fixed point]. Controlled behavior: (p.x = 0 or p.x = 2) and p.l0 or p.x = 1 and p.l4 or (p.x = 1 and (p.l2 or p.l6) or (p.x = 1 and (p.l1 or p.l5) or p.x = 1 and p.l3)) -> p.x = 0 and p.l0 or p.x = 1 and p.l1. @@ -532,12 +367,6 @@ Synthesis round 6: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x != 0 or not p.l0) and (p.x != 1 or not p.l1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.x != 0 or not p.l0) and (p.x != 1 or not p.l1) -> p.x != 0 or not p.l0 [backward reach with edge: (event: u) (guard: p.l1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6) or (p.x = 8 or p.x = 10 or (p.x = 12 or p.x = 14))) and p.l1 or (p.x = 1 or p.x = 5 or (p.x = 9 or p.x = 13)) and p.l1 or ((p.x = 3 or p.x = 11) and p.l1 or p.x = 7 and p.l1)) (assignments: p.x := p.x + 1, p := p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: p.x != 0 or not p.l0 [fixed point]. Controlled behavior: p.x = 0 and p.l0 or p.x = 1 and p.l1 -> p.x = 0 and p.l0. @@ -546,9 +375,6 @@ Synthesis round 6: Forward controlled-behavior: p.l0 [initialization predicate] Forward controlled-behavior: p.l0 -> p.x = 0 and p.l0 [restricted to current/previous controlled-behavior predicate: p.x = 0 and p.l0] - Forward reachability iteration 1: - No change this iteration. - Forward controlled-behavior: p.x = 0 and p.l0 [fixed point]. Controlled behavior not changed. @@ -560,9 +386,6 @@ Synthesis round 7: Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) [marker predicate] Backward controlled-behavior: p.x = 1 and p.l1 or (p.x = 9 and p.l5 or p.x = 5 and p.l3) or (p.x = 3 and p.l2 or (p.x = 11 and p.l6 or p.x = 7 and p.l4)) -> false [restricted to current/previous controlled-behavior predicate: p.x = 0 and p.l0] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: false [fixed point]. Controlled behavior: p.x = 0 and p.l0 -> false. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out index c1da3c11381798787100a5872494efb853189229..9ffe562f81efb48a35dafc689470548f022c3717 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out @@ -199,17 +199,6 @@ Synthesis round 1: Backward controlled-behavior: <bdd 24n 16p> [marker predicate] Backward controlled-behavior: <bdd 24n 16p> -> <bdd 23n 21p> [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: <bdd 23n 21p> -> <bdd 26n 25p> [backward reach with edge: (event: c1) (guard: p1.l1 and p2.l0) (assignments: p1 := p1.l2, p2 := p2.l1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 26n 25p> -> <bdd 27n 27p> [backward reach with edge: (event: c1) (guard: p1.l1 and p2.l1) (assignments: p1 := p1.l2, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 27n 27p> -> <bdd 22n 18p> [backward reach with edge: (event: c2) (guard: p2.l2) (assignments: p2 := p2.l3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: <bdd 22n 18p> -> (not p1.l0 or not p2.l4) and (not p1.l0 or (not p2.l2 and not p2.l3 or p1.x != 4)) and ((not p1.l2 or (not p2.l0 and not p2.l1 or p1.x != 0)) and ((not p1.l2 or not p2.l4) and (not p1.l2 or not p2.l2 and not p2.l3 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)))) and ((not p1.l1 or (not p2.l0 or p1.x != 0)) and ((not p1.l1 or not p2.l4) and (not p1.l1 or not p2.l2)) and ((not p1.l1 or not p2.l1 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)) and ((not p1.l1 or not p2.l3) and not p1.l3))) [backward reach with edge: (event: c1) (guard: p1.l1 and p2.l1) (assignments: p1 := p1.l2, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: (not p1.l0 or not p2.l4) and (not p1.l0 or (not p2.l2 and not p2.l3 or p1.x != 4)) and ((not p1.l2 or (not p2.l0 and not p2.l1 or p1.x != 0)) and ((not p1.l2 or not p2.l4) and (not p1.l2 or not p2.l2 and not p2.l3 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)))) and ((not p1.l1 or (not p2.l0 or p1.x != 0)) and ((not p1.l1 or not p2.l4) and (not p1.l1 or not p2.l2)) and ((not p1.l1 or not p2.l1 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)) and ((not p1.l1 or not p2.l3) and not p1.l3))) [fixed point]. Controlled behavior: true -> (not p1.l0 or not p2.l4) and (not p1.l0 or (not p2.l2 and not p2.l3 or p1.x != 4)) and ((not p1.l2 or (not p2.l0 and not p2.l1 or p1.x != 0)) and ((not p1.l2 or not p2.l4) and (not p1.l2 or not p2.l2 and not p2.l3 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)))) and ((not p1.l1 or (not p2.l0 or p1.x != 0)) and ((not p1.l1 or not p2.l4) and (not p1.l1 or not p2.l2)) and ((not p1.l1 or not p2.l1 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)) and ((not p1.l1 or not p2.l3) and not p1.l3))). @@ -222,9 +211,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p1.l0 and (p2.l0 and p1.x = 0) [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior: (not p1.l0 or not p2.l4) and (not p1.l0 or (not p2.l2 and not p2.l3 or p1.x != 4)) and ((not p1.l2 or (not p2.l0 and not p2.l1 or p1.x != 0)) and ((not p1.l2 or not p2.l4) and (not p1.l2 or not p2.l2 and not p2.l3 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)))) and ((not p1.l1 or (not p2.l0 or p1.x != 0)) and ((not p1.l1 or not p2.l4) and (not p1.l1 or not p2.l2)) and ((not p1.l1 or not p2.l1 or (1 <= p1.x and p1.x <= 3 or p1.x = 5)) and ((not p1.l1 or not p2.l3) and not p1.l3))) -> p1.l0 and (p2.l0 and p1.x = 0). Need another round. @@ -234,9 +220,6 @@ Synthesis round 2: Backward controlled-behavior: <bdd 24n 16p> [marker predicate] Backward controlled-behavior: <bdd 24n 16p> -> p1.l0 and (p2.l0 and p1.x = 0) [restricted to current/previous controlled-behavior predicate: p1.l0 and (p2.l0 and p1.x = 0)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p1.l0 and (p2.l0 and p1.x = 0) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking2.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking2.cif.out index f0f8f80112ac8fdb1237a2013ed40793e28d2455..3b2c127dfb28e26e27881a20545c98ab825f0f9c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking2.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking2.cif.out @@ -175,9 +175,6 @@ Synthesis round 1: Backward controlled-behavior: p.l1 and (p.x = 2 or p.x = 3) or p.l2 and p.x = 3 [marker predicate] Backward controlled-behavior: p.l1 and (p.x = 2 or p.x = 3) or p.l2 and p.x = 3 -> p.l1 and (p.x = 2 or p.x = 3) or p.l2 and p.x = 3 [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.l1 and (p.x = 2 or p.x = 3) or p.l2 and p.x = 3 [fixed point]. Controlled behavior: true -> p.l1 and (p.x = 2 or p.x = 3) or p.l2 and p.x = 3. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out index 50e0e2a3a87257c67328ff1d02e842fa600af41e..b6151d30db0a99caf95d262217101c9a0f3e13f5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out @@ -204,13 +204,6 @@ Synthesis round 1: Backward controlled-behavior: p2.l0 and p1.l0 [marker predicate] Backward controlled-behavior: p2.l0 and p1.l0 -> not(p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) or (p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not(p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) or (p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1)) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [backward reach with edge: (event: b) (guard: p2.l2 and p1.l1 -> (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l2 and p1.l1) or ((p1.x = 1 or p1.x = 5) and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l2 and p1.l1))) (assignments: p1.x := p1.x + 1, p1 := p1.l0, p2 := p2.l0), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1)) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1)))) [backward reach with edge: (event: c) (guard: p2.l1) (assignments: p2 := p2.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1)))) [fixed point]. Controlled behavior: true -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1)))). @@ -223,32 +216,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) -> p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) [forward reach with edge: (event: a) (guard: (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l0 and p1.l0) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0))) (assignments: p1 := p1.l1, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) -> p1.x = 0 and (p2.l0 and p1.l0) or (p1.x = 0 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0)) [forward reach with edge: (event: b) (guard: p2.l2 and p1.l1 -> (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l2 and p1.l1) or ((p1.x = 1 or p1.x = 5) and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l2 and p1.l1))) (assignments: p1.x := p1.x + 1, p1 := p1.l0, p2 := p2.l0), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - - Forward reachability iteration 2: - Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) or (p1.x = 0 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0)) -> p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l1 and p1.l1)) [forward reach with edge: (event: a) (guard: p1.x = 1 and (p2.l0 and p1.l0)) (assignments: p1 := p1.l1, p2 := p2.l1), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l1 and p1.l1)) -> p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1))) [forward reach with edge: (event: c) (guard: p2.l1) (assignments: p2 := p2.l2), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - - Forward reachability iteration 3: - Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1))) -> p1.x = 0 and (p2.l0 and p1.l0) or (p1.x = 0 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l0 and p1.l0)) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1))) [forward reach with edge: (event: b) (guard: p2.l2 and p1.l1 -> (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l2 and p1.l1) or ((p1.x = 1 or p1.x = 5) and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l2 and p1.l1))) (assignments: p1.x := p1.x + 1, p1 := p1.l0, p2 := p2.l0), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - - Forward reachability iteration 4: - Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) or (p1.x = 0 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l0 and p1.l0)) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1))) -> (p1.x = 0 or p1.x = 2) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 2) and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1))) [forward reach with edge: (event: a) (guard: (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l0 and p1.l0) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0))) (assignments: p1 := p1.l1, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - Forward controlled-behavior: (p1.x = 0 or p1.x = 2) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 2) and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1))) -> (p1.x = 0 or p1.x = 2) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 2) and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0)) or (p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l1 and p1.l1) or p1.x = 3 and (p2.l0 and p1.l0))) [forward reach with edge: (event: b) (guard: p2.l2 and p1.l1 -> (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l2 and p1.l1) or ((p1.x = 1 or p1.x = 5) and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l2 and p1.l1))) (assignments: p1.x := p1.x + 1, p1 := p1.l0, p2 := p2.l0), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - - Forward reachability iteration 5: - Forward controlled-behavior: (p1.x = 0 or p1.x = 2) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 2) and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0)) or (p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l1 and p1.l1) or p1.x = 3 and (p2.l0 and p1.l0))) -> (p1.x = 0 or p1.x = 2) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 2) and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0)) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1))) [forward reach with edge: (event: a) (guard: (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l0 and p1.l0) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0))) (assignments: p1 := p1.l1, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - Forward controlled-behavior: (p1.x = 0 or p1.x = 2) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 2) and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0)) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1))) -> p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) or (p1.x = 4 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [forward reach with edge: (event: b) (guard: p2.l2 and p1.l1 -> (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l2 and p1.l1) or ((p1.x = 1 or p1.x = 5) and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l2 and p1.l1))) (assignments: p1.x := p1.x + 1, p1 := p1.l0, p2 := p2.l0), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - - Forward reachability iteration 6: - Forward controlled-behavior: p1.x = 0 and (p2.l0 and p1.l0) or p1.x = 0 and (p2.l2 and p1.l1) or (p1.x = 4 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1)) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [forward reach with edge: (event: a) (guard: (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l0 and p1.l0) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0))) (assignments: p1 := p1.l1, p2 := p2.l2), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - Forward controlled-behavior: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1)) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [forward reach with edge: (event: b) (guard: p2.l2 and p1.l1 -> (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l2 and p1.l1) or ((p1.x = 1 or p1.x = 5) and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l2 and p1.l1))) (assignments: p1.x := p1.x + 1, p1 := p1.l0, p2 := p2.l0), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1))))] - - Forward reachability iteration 7: - No change this iteration. - Forward controlled-behavior: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [fixed point]. Controlled behavior: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or ((p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 0 or p1.x = 4) and (p2.l1 and p1.l1)) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 2 and (p2.l1 and p1.l1))) or (p1.x = 1 and (p2.l0 and p1.l0) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1)) or (p1.x = 5 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l1 and p1.l1)))) -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))). @@ -260,13 +227,6 @@ Synthesis round 2: Backward controlled-behavior: p2.l0 and p1.l0 [marker predicate] Backward controlled-behavior: p2.l0 and p1.l0 -> not(p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) or (p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) [restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1))))] - Backward reachability iteration 1: - Backward controlled-behavior: not(p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) or (p1.x = 2 or p1.x = 3) and (p2.l0 and p1.l0) -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1)) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [backward reach with edge: (event: b) (guard: p2.l2 and p1.l1 -> (p1.x = 0 or (p1.x = 2 or p1.x = 4)) and (p2.l2 and p1.l1) or ((p1.x = 1 or p1.x = 5) and (p2.l2 and p1.l1) or p1.x = 3 and (p2.l2 and p1.l1))) (assignments: p1.x := p1.x + 1, p1 := p1.l0, p2 := p2.l0), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1))))] - Backward controlled-behavior: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or p1.x = 2 and (p2.l2 and p1.l1)) or (p1.x = 1 and (p2.l0 and p1.l0) or p1.x = 1 and (p2.l2 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) -> (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [backward reach with edge: (event: c) (guard: p2.l1) (assignments: p2 := p2.l2), restricted to current/previous controlled-behavior predicate: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1))))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p1.x = 0 or p1.x = 4) and (p2.l0 and p1.l0) or (p1.x = 0 or p1.x = 4) and (p2.l2 and p1.l1) or (p1.x = 2 and (p2.l0 and p1.l0) or (p1.x = 2 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l0 and p1.l0))) or (p1.x = 1 and (p2.l2 and p1.l1) or p1.x = 1 and (p2.l1 and p1.l1) or (p1.x = 5 and (p2.l0 and p1.l0) or (p1.x = 3 and (p2.l0 and p1.l0) or p1.x = 3 and (p2.l2 and p1.l1)))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_preds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_preds.cif.out index 2cb38523fba9c020f315a9744f1be71a0350e9e3..13c740b4f660455451d57a4cdc16f9ba4bb8f899 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_preds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_preds.cif.out @@ -93,9 +93,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.x = 4 or (p.x = 6 or p.x = 5) [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: true -> p.x = 4 or (p.x = 6 or p.x = 5). Finished: no initialization possible. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out index a6dc222fb8223627f48f19fb44e8352cd3efab6a..77b7036c23768bccbdd30a1c680004b7a629327f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out @@ -212,20 +212,6 @@ Synthesis round 1: Backward controlled-behavior: r2.l1 and r3.l1 [marker predicate] Backward controlled-behavior: r2.l1 and r3.l1 -> not(p.x = 2 or (p.x = 3 or p.x = 6) or (p.x = 7 or (p.x = 10 or p.x = 11))) and (r2.l1 and r3.l1) or ((p.x = 2 or p.x = 3 or (p.x = 10 or p.x = 11)) and (r2.l1 and r3.l1) or (p.x = 6 or p.x = 7) and (r2.l1 and r3.l1)) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not(p.x = 2 or (p.x = 3 or p.x = 6) or (p.x = 7 or (p.x = 10 or p.x = 11))) and (r2.l1 and r3.l1) or ((p.x = 2 or p.x = 3 or (p.x = 10 or p.x = 11)) and (r2.l1 and r3.l1) or (p.x = 6 or p.x = 7) and (r2.l1 and r3.l1)) -> (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l1) or ((p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l1)) or ((p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or p.x = 6 and (r2.l1 and r3.l1) or (p.x = 6 and (r2.l2 and r3.l3) or (p.x = 1 or p.x = 9) and (r2.l1 and r3.l1))) or ((p.x = 1 or p.x = 9) and (r2.l2 and r3.l3) or p.x = 5 and (r2.l1 and r3.l1) or (p.x = 5 and (r2.l2 and r3.l3) or p.x = 13 and (r2.l1 and r3.l1)) or ((p.x = 3 or p.x = 11) and (r2.l1 and r3.l1) or (p.x = 3 or p.x = 11) and (r2.l2 and r3.l3) or (p.x = 7 and (r2.l1 and r3.l1) or p.x = 7 and (r2.l2 and r3.l3)))) [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or (p.x = 6 and (r2.l2 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l1) or ((p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l1)) or ((p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or p.x = 6 and (r2.l1 and r3.l1) or (p.x = 6 and (r2.l2 and r3.l3) or (p.x = 1 or p.x = 9) and (r2.l1 and r3.l1))) or ((p.x = 1 or p.x = 9) and (r2.l2 and r3.l3) or p.x = 5 and (r2.l1 and r3.l1) or (p.x = 5 and (r2.l2 and r3.l3) or p.x = 13 and (r2.l1 and r3.l1)) or ((p.x = 3 or p.x = 11) and (r2.l1 and r3.l1) or (p.x = 3 or p.x = 11) and (r2.l2 and r3.l3) or (p.x = 7 and (r2.l1 and r3.l1) or p.x = 7 and (r2.l2 and r3.l3)))) -> (p.x = 0 or p.x = 8) and (r2.l1 and not r3.l3) or (p.x = 0 or p.x = 8) and (r2.l2 and r3.l3) or (p.x = 4 and (r2.l1 and not r3.l3) or p.x = 4 and (r2.l2 and r3.l3)) or (p.x = 12 and (r2.l1 and r3.l1) or p.x = 12 and (r2.l2 and r3.l3) or ((p.x = 2 or p.x = 10) and (r2.l1 and not r3.l3) or ((p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or p.x = 6 and (r2.l1 and not r3.l3)))) or (p.x = 6 and (r2.l2 and r3.l3) or (p.x = 1 or p.x = 9) and (r2.l1 and not r3.l3) or ((p.x = 1 or p.x = 9) and (r2.l2 and r3.l3) or (p.x = 5 and (r2.l1 and not r3.l3) or p.x = 5 and (r2.l2 and r3.l3))) or (p.x = 13 and (r2.l1 and r3.l1) or (p.x = 3 or p.x = 11) and (r2.l1 and not r3.l3) or ((p.x = 3 or p.x = 11) and (r2.l2 and r3.l3) or (p.x = 7 and (r2.l1 and not r3.l3) or p.x = 7 and (r2.l2 and r3.l3))))) [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l2) or (p.x = 6 and (r2.l1 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x = 0 or p.x = 8) and (r2.l1 and not r3.l3) or (p.x = 0 or p.x = 8) and (r2.l2 and r3.l3) or (p.x = 4 and (r2.l1 and not r3.l3) or p.x = 4 and (r2.l2 and r3.l3)) or (p.x = 12 and (r2.l1 and r3.l1) or p.x = 12 and (r2.l2 and r3.l3) or ((p.x = 2 or p.x = 10) and (r2.l1 and not r3.l3) or ((p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or p.x = 6 and (r2.l1 and not r3.l3)))) or (p.x = 6 and (r2.l2 and r3.l3) or (p.x = 1 or p.x = 9) and (r2.l1 and not r3.l3) or ((p.x = 1 or p.x = 9) and (r2.l2 and r3.l3) or (p.x = 5 and (r2.l1 and not r3.l3) or p.x = 5 and (r2.l2 and r3.l3))) or (p.x = 13 and (r2.l1 and r3.l1) or (p.x = 3 or p.x = 11) and (r2.l1 and not r3.l3) or ((p.x = 3 or p.x = 11) and (r2.l2 and r3.l3) or (p.x = 7 and (r2.l1 and not r3.l3) or p.x = 7 and (r2.l2 and r3.l3))))) -> <bdd 20n 21p> [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l1) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l1) or (p.x = 6 and (r2.l2 and r3.l1) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l1) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l1)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: <bdd 20n 21p> -> <bdd 23n 31p> [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l3) or (p.x = 6 and (r2.l1 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 23n 31p> -> <bdd 24n 26p> [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l2) or (p.x = 6 and (r2.l2 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - No change this iteration. - Backward controlled-behavior: <bdd 24n 26p> [fixed point]. Controlled behavior: true -> <bdd 24n 26p>. @@ -238,33 +224,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) -> p.x = 0 and (r2.l1 and r3.l1) or p.x = 1 and (r2.l2 and r3.l2) [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l1) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l1) or (p.x = 6 and (r2.l1 and r3.l1) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l1) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l1)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l2), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - Forward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) or p.x = 1 and (r2.l2 and r3.l2) -> p.x = 0 and (r2.l1 and r3.l1) or (p.x = 2 and (r2.l1 and r3.l3) or p.x = 1 and (r2.l2 and r3.l2)) [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l2) or (p.x = 6 and (r2.l2 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) or (p.x = 2 and (r2.l1 and r3.l3) or p.x = 1 and (r2.l2 and r3.l2)) -> p.x = 0 and (r2.l1 and r3.l1) or p.x = 2 and (r2.l1 and r3.l3) or (p.x = 1 and (r2.l2 and r3.l2) or p.x = 3 and (r2.l2 and r3.l1)) [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l3) or (p.x = 6 and (r2.l1 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - Forward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) or p.x = 2 and (r2.l1 and r3.l3) or (p.x = 1 and (r2.l2 and r3.l2) or p.x = 3 and (r2.l2 and r3.l1)) -> <bdd 22n 5p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l1) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l1) or (p.x = 6 and (r2.l2 and r3.l1) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l1) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l1)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l2), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 22n 5p> -> <bdd 24n 6p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l2) or (p.x = 6 and (r2.l1 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - Forward controlled-behavior: <bdd 24n 6p> -> <bdd 24n 7p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or (p.x = 6 and (r2.l2 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - - Forward reachability iteration 4: - Forward controlled-behavior: <bdd 24n 7p> -> <bdd 24n 8p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l1) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l1) or (p.x = 6 and (r2.l1 and r3.l1) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l1) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l1)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l2), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - Forward controlled-behavior: <bdd 24n 8p> -> <bdd 25n 9p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l2) or (p.x = 6 and (r2.l2 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - - Forward reachability iteration 5: - Forward controlled-behavior: <bdd 25n 9p> -> <bdd 26n 10p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l3) or (p.x = 6 and (r2.l1 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - Forward controlled-behavior: <bdd 26n 10p> -> <bdd 26n 11p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l1) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l1) or (p.x = 6 and (r2.l2 and r3.l1) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l1) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l1)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l2), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - - Forward reachability iteration 6: - Forward controlled-behavior: <bdd 26n 11p> -> <bdd 26n 12p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l2) or (p.x = 6 and (r2.l1 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - Forward controlled-behavior: <bdd 26n 12p> -> <bdd 26n 13p> [forward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or (p.x = 6 and (r2.l2 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: <bdd 24n 26p>] - - Forward reachability iteration 7: - No change this iteration. - Forward controlled-behavior: <bdd 26n 13p> [fixed point]. Controlled behavior: <bdd 24n 26p> -> <bdd 26n 13p>. @@ -276,20 +235,6 @@ Synthesis round 2: Backward controlled-behavior: r2.l1 and r3.l1 [marker predicate] Backward controlled-behavior: r2.l1 and r3.l1 -> p.x = 0 and (r2.l1 and r3.l1) or (p.x = 12 and (r2.l1 and r3.l1) or p.x = 6 and (r2.l1 and r3.l1)) [restricted to current/previous controlled-behavior predicate: <bdd 26n 13p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) or (p.x = 12 and (r2.l1 and r3.l1) or p.x = 6 and (r2.l1 and r3.l1)) -> p.x = 0 and (r2.l1 and r3.l1) or p.x = 12 and (r2.l1 and r3.l1) or (p.x = 6 and (r2.l1 and r3.l1) or (p.x = 5 and (r2.l2 and r3.l3) or p.x = 11 and (r2.l2 and r3.l3))) [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l3) or (p.x = 6 and (r2.l2 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: <bdd 26n 13p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) or p.x = 12 and (r2.l1 and r3.l1) or (p.x = 6 and (r2.l1 and r3.l1) or (p.x = 5 and (r2.l2 and r3.l3) or p.x = 11 and (r2.l2 and r3.l3))) -> p.x = 0 and (r2.l1 and r3.l1) or (p.x = 4 and (r2.l1 and r3.l2) or p.x = 12 and (r2.l1 and r3.l1)) or (p.x = 10 and (r2.l1 and r3.l2) or p.x = 6 and (r2.l1 and r3.l1) or (p.x = 5 and (r2.l2 and r3.l3) or p.x = 11 and (r2.l2 and r3.l3))) [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l2) or (p.x = 6 and (r2.l1 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: <bdd 26n 13p>] - Backward controlled-behavior: p.x = 0 and (r2.l1 and r3.l1) or (p.x = 4 and (r2.l1 and r3.l2) or p.x = 12 and (r2.l1 and r3.l1)) or (p.x = 10 and (r2.l1 and r3.l2) or p.x = 6 and (r2.l1 and r3.l1) or (p.x = 5 and (r2.l2 and r3.l3) or p.x = 11 and (r2.l2 and r3.l3))) -> <bdd 22n 9p> [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l1) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l1) or (p.x = 6 and (r2.l2 and r3.l1) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l1) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l1)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l2), restricted to current/previous controlled-behavior predicate: <bdd 26n 13p>] - - Backward reachability iteration 3: - Backward controlled-behavior: <bdd 22n 9p> -> <bdd 24n 11p> [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l1 and r3.l3) or (p.x = 2 or p.x = 10) and (r2.l1 and r3.l3) or (p.x = 6 and (r2.l1 and r3.l3) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l1 and r3.l3) or (p.x = 5 or p.x = 7) and (r2.l1 and r3.l3)))) (assignments: p.x := p.x + 1, r2 := r2.l2, r3 := r3.l1), restricted to current/previous controlled-behavior predicate: <bdd 26n 13p>] - Backward controlled-behavior: <bdd 24n 11p> -> <bdd 26n 13p> [backward reach with edge: (event: a) (guard: (p.x = 0 or p.x = 4 or (p.x = 8 or p.x = 12)) and (r2.l2 and r3.l2) or (p.x = 2 or p.x = 10) and (r2.l2 and r3.l2) or (p.x = 6 and (r2.l2 and r3.l2) or ((p.x = 1 or p.x = 3 or (p.x = 9 or p.x = 11)) and (r2.l2 and r3.l2) or (p.x = 5 or p.x = 7) and (r2.l2 and r3.l2)))) (assignments: p.x := p.x + 1, r2 := r2.l1, r3 := r3.l3), restricted to current/previous controlled-behavior predicate: <bdd 26n 13p>] - - Backward reachability iteration 4: - No change this iteration. - Backward controlled-behavior: <bdd 26n 13p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out index 290edaf7511bec0a6f9f1e6dc9e2942ff9f49dcb..2d3d652d94e50b1421f4d1c317112a47d8fb8dd0 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out @@ -193,9 +193,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 12n 25p> [restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 12n 25p> [fixed point]. Controlled behavior not changed. @@ -208,42 +205,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 5 and p.y = 6 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 5 and p.y = 6 -> p.x = 6 and p.y = 6 or p.x = 5 and p.y = 6 [forward reach with edge: (event: a) (guard: true -> true) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - Forward controlled-behavior: p.x = 6 and p.y = 6 or p.x = 5 and p.y = 6 -> p.x = 6 and p.y = 6 or p.x = 6 and p.y = 5 or (p.x = 5 and p.y = 6 or p.x = 5 and p.y = 5) [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 6 and p.y = 6 or p.x = 6 and p.y = 5 or (p.x = 5 and p.y = 6 or p.x = 5 and p.y = 5) -> p.x = 6 and p.y = 6 or p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and p.y = 6 or (p.x = 5 or p.x = 7) and p.y = 5) [forward reach with edge: (event: a) (guard: true -> true) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - Forward controlled-behavior: p.x = 6 and p.y = 6 or p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and p.y = 6 or (p.x = 5 or p.x = 7) and p.y = 5) -> p.x = 4 and p.y = 6 or p.x = 6 and p.y = 6 or (p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and p.y = 6 or (p.x = 5 or p.x = 7) and p.y = 5)) [forward reach with edge: (event: b) (guard: true -> p.x != 0) (assignments: p.x := p.x - 1, p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - Forward controlled-behavior: p.x = 4 and p.y = 6 or p.x = 6 and p.y = 6 or (p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and p.y = 6 or (p.x = 5 or p.x = 7) and p.y = 5)) -> p.x = 4 and p.y = 6 or (p.x = 4 and p.y = 5 or p.x = 6 and (p.y = 4 or p.y = 6)) or (p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and (p.y = 4 or p.y = 6) or (p.x = 5 or p.x = 7) and p.y = 5)) [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 3: - Forward controlled-behavior: p.x = 4 and p.y = 6 or (p.x = 4 and p.y = 5 or p.x = 6 and (p.y = 4 or p.y = 6)) or (p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and (p.y = 4 or p.y = 6) or (p.x = 5 or p.x = 7) and p.y = 5)) -> p.x = 8 and (p.y = 4 or p.y = 6) or p.x = 8 and p.y = 5 or (p.x = 4 and p.y = 6 or p.x = 4 and p.y = 5) or (p.x = 6 and (p.y = 4 or p.y = 6) or p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and (p.y = 4 or p.y = 6) or (p.x = 5 or p.x = 7) and p.y = 5)) [forward reach with edge: (event: a) (guard: true -> true) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - Forward controlled-behavior: p.x = 8 and (p.y = 4 or p.y = 6) or p.x = 8 and p.y = 5 or (p.x = 4 and p.y = 6 or p.x = 4 and p.y = 5) or (p.x = 6 and (p.y = 4 or p.y = 6) or p.x = 6 and p.y = 5 or ((p.x = 5 or p.x = 7) and (p.y = 4 or p.y = 6) or (p.x = 5 or p.x = 7) and p.y = 5)) -> p.x = 8 and (p.y = 4 or p.y = 6) or p.x = 8 and p.y = 5 or (p.x = 4 and p.y = 6 or (p.x = 4 and p.y = 5 or p.x = 6 and (p.y = 4 or p.y = 6))) or (p.x = 6 and p.y = 5 or (p.x = 5 and (p.y = 4 or p.y = 6) or p.x = 5 and p.y = 5) or (p.x = 3 and p.y = 6 or (p.x = 7 and (p.y = 4 or p.y = 6) or p.x = 7 and p.y = 5))) [forward reach with edge: (event: b) (guard: true -> p.x != 0) (assignments: p.x := p.x - 1, p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - Forward controlled-behavior: p.x = 8 and (p.y = 4 or p.y = 6) or p.x = 8 and p.y = 5 or (p.x = 4 and p.y = 6 or (p.x = 4 and p.y = 5 or p.x = 6 and (p.y = 4 or p.y = 6))) or (p.x = 6 and p.y = 5 or (p.x = 5 and (p.y = 4 or p.y = 6) or p.x = 5 and p.y = 5) or (p.x = 3 and p.y = 6 or (p.x = 7 and (p.y = 4 or p.y = 6) or p.x = 7 and p.y = 5))) -> p.x = 8 and (p.y = 4 or p.y = 6) or p.x = 8 and p.y = 5 or (p.x = 8 and p.y = 3 or p.x = 4 and (p.y = 4 or p.y = 6)) or (p.x = 4 and p.y = 5 or p.x = 6 and (p.y = 4 or p.y = 6) or (p.x = 6 and p.y = 5 or p.x = 6 and p.y = 3)) or (p.x = 5 and (p.y = 4 or p.y = 6) or p.x = 5 and p.y = 5 or (p.x = 5 and p.y = 3 or p.x = 3 and p.y = 6) or (p.x = 3 and p.y = 5 or p.x = 7 and (p.y = 4 or p.y = 6) or (p.x = 7 and p.y = 5 or p.x = 7 and p.y = 3))) [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 4: - Forward controlled-behavior: p.x = 8 and (p.y = 4 or p.y = 6) or p.x = 8 and p.y = 5 or (p.x = 8 and p.y = 3 or p.x = 4 and (p.y = 4 or p.y = 6)) or (p.x = 4 and p.y = 5 or p.x = 6 and (p.y = 4 or p.y = 6) or (p.x = 6 and p.y = 5 or p.x = 6 and p.y = 3)) or (p.x = 5 and (p.y = 4 or p.y = 6) or p.x = 5 and p.y = 5 or (p.x = 5 and p.y = 3 or p.x = 3 and p.y = 6) or (p.x = 3 and p.y = 5 or p.x = 7 and (p.y = 4 or p.y = 6) or (p.x = 7 and p.y = 5 or p.x = 7 and p.y = 3))) -> <bdd 22n 17p> [forward reach with edge: (event: b) (guard: true -> p.x != 0) (assignments: p.x := p.x - 1, p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - Forward controlled-behavior: <bdd 22n 17p> -> <bdd 23n 23p> [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 5: - Forward controlled-behavior: <bdd 23n 23p> -> <bdd 23n 25p> [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 6: - Forward controlled-behavior: <bdd 23n 25p> -> <bdd 22n 23p> [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 7: - Forward controlled-behavior: <bdd 22n 23p> -> <bdd 20n 23p> [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 8: - Forward controlled-behavior: <bdd 20n 23p> -> p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and ((p.x != 8 or p.y != 7) and (p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)))) and ((p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and (p.x != 2 or not(p.y = 0 or p.y = 8))) and ((p.x != 2 or p.y != 10) and ((p.x != 2 or p.y != 9) and (p.x != 2 or p.y != 7)))) and (p.x != 10 and (p.x != 6 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 6 or p.y != 9) and ((p.x != 6 or p.y != 7) and not(p.x = 1 or p.x = 9))) and ((p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7)) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7))))) [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 9: - Forward controlled-behavior: p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and ((p.x != 8 or p.y != 7) and (p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)))) and ((p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and (p.x != 2 or not(p.y = 0 or p.y = 8))) and ((p.x != 2 or p.y != 10) and ((p.x != 2 or p.y != 9) and (p.x != 2 or p.y != 7)))) and (p.x != 10 and (p.x != 6 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 6 or p.y != 9) and ((p.x != 6 or p.y != 7) and not(p.x = 1 or p.x = 9))) and ((p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7)) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7))))) -> p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and (p.x != 8 or p.y != 7)) and ((p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)) and (p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and ((not(p.x = 2 or p.x = 6) or (0 <= p.y and p.y <= 7 or p.y = 9)) and (not(p.x = 2 or p.x = 6) or p.y != 9)))) and ((not(p.x = 2 or p.x = 6) or p.y != 7) and p.x != 10 and (not(p.x = 1 or p.x = 9) and (p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9))) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7))))) [forward reach with edge: (event: c) (guard: true -> p.y != 0) (assignments: p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: <bdd 12n 25p>] - - Forward reachability iteration 10: - No change this iteration. - Forward controlled-behavior: p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and (p.x != 8 or p.y != 7)) and ((p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)) and (p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and ((not(p.x = 2 or p.x = 6) or (0 <= p.y and p.y <= 7 or p.y = 9)) and (not(p.x = 2 or p.x = 6) or p.y != 9)))) and ((not(p.x = 2 or p.x = 6) or p.y != 7) and p.x != 10 and (not(p.x = 1 or p.x = 9) and (p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9))) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7))))) [fixed point]. Controlled behavior: <bdd 12n 25p> -> p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and (p.x != 8 or p.y != 7)) and ((p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)) and (p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and ((not(p.x = 2 or p.x = 6) or (0 <= p.y and p.y <= 7 or p.y = 9)) and (not(p.x = 2 or p.x = 6) or p.y != 9)))) and ((not(p.x = 2 or p.x = 6) or p.y != 7) and p.x != 10 and (not(p.x = 1 or p.x = 9) and (p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9))) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7))))). @@ -255,9 +216,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and (p.x != 8 or p.y != 7)) and ((p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)) and (p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and ((not(p.x = 2 or p.x = 6) or (0 <= p.y and p.y <= 7 or p.y = 9)) and (not(p.x = 2 or p.x = 6) or p.y != 9)))) and ((not(p.x = 2 or p.x = 6) or p.y != 7) and p.x != 10 and (not(p.x = 1 or p.x = 9) and (p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9))) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7))))) [restricted to current/previous controlled-behavior predicate: p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and (p.x != 8 or p.y != 7)) and ((p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)) and (p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and ((not(p.x = 2 or p.x = 6) or (0 <= p.y and p.y <= 7 or p.y = 9)) and (not(p.x = 2 or p.x = 6) or p.y != 9)))) and ((not(p.x = 2 or p.x = 6) or p.y != 7) and p.x != 10 and (not(p.x = 1 or p.x = 9) and (p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9))) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7)))))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x != 0 and (p.x != 8 or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((p.x != 8 or p.y != 9) and (p.x != 8 or p.y != 7)) and ((p.x != 4 or (0 <= p.y and p.y <= 7 or p.y = 9)) and (p.x != 4 or p.y != 9) and ((p.x != 4 or p.y != 7) and ((not(p.x = 2 or p.x = 6) or (0 <= p.y and p.y <= 7 or p.y = 9)) and (not(p.x = 2 or p.x = 6) or p.y != 9)))) and ((not(p.x = 2 or p.x = 6) or p.y != 7) and p.x != 10 and (not(p.x = 1 or p.x = 9) and (p.x != 5 or (0 <= p.y and p.y <= 7 or p.y = 9))) and ((p.x != 5 or p.y != 9) and (p.x != 5 or p.y != 7) and ((not(p.x = 3 or p.x = 7) or (0 <= p.y and p.y <= 7 or p.y = 9)) and ((not(p.x = 3 or p.x = 7) or p.y != 9) and (not(p.x = 3 or p.x = 7) or p.y != 7))))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out index dfafd558506dc9da6a8468d52aed338cc470963d..2f0216fd0d42915a43eb17d1fa51006ed6209d04 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out @@ -212,9 +212,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -225,17 +222,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 3 and p.y = 6 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 3 and p.y = 6 -> p.x = 4 and p.y = 5 or p.x = 3 and p.y = 6 [forward reach with edge: (event: b) (guard: true -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and (p.y = 6 or p.y = 7) or ((p.x = 1 or p.x = 5) and (p.y = 6 or p.y = 7) or p.x = 3 and (p.y = 6 or p.y = 7))) (assignments: p.x := p.x + 1, p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 4 and p.y = 5 or p.x = 3 and p.y = 6 -> p.x = 4 and p.y = 5 or (p.x = 5 and p.y = 4 or p.x = 3 and p.y = 6) [forward reach with edge: (event: e) (guard: true -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.y != 0))) and (not(p.x = 1 or p.x = 5) or p.y != 0) and ((p.x != 3 or p.y != 0) and p.x != 7)) (assignments: p.x := p.x + 1, p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 4 and p.y = 5 or (p.x = 5 and p.y = 4 or p.x = 3 and p.y = 6) -> p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or p.x = 3 and p.y = 6) [forward reach with edge: (event: a) (guard: true -> 2 <= p.x and p.x <= 7 and ((not(p.x = 4 or p.x = 5) or p.y != 0) and (p.x = 0 or p.x = 1 or (p.x = 4 or p.x = 5)))) (assignments: p.x := p.x + 1, p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or p.x = 3 and p.y = 6) -> p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or (p.x = 3 and p.y = 6 or p.x = 7 and p.y = 2)) [forward reach with edge: (event: c) (guard: true -> (p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.y != 0))) and ((p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.y != 5))) and (not(p.x = 1 or p.x = 5) or p.y != 0)) and ((not(p.x = 1 or p.x = 5) or p.y != 5) and (p.x != 3 or p.y != 0) and ((p.x != 3 or p.y != 5) and p.x != 7))) (assignments: p.x := p.x + 1, p.y := p.y - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or (p.x = 3 and p.y = 6 or p.x = 7 and p.y = 2)) [fixed point]. Controlled behavior: true -> p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or (p.x = 3 and p.y = 6 or p.x = 7 and p.y = 2)). @@ -247,9 +233,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or (p.x = 3 and p.y = 6 or p.x = 7 and p.y = 2)) [restricted to current/previous controlled-behavior predicate: p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or (p.x = 3 and p.y = 6 or p.x = 7 and p.y = 2))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 4 and p.y = 5 or p.x = 6 and p.y = 3 or (p.x = 5 and p.y = 4 or (p.x = 3 and p.y = 6 or p.x = 7 and p.y = 2)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out index db2e71d037b349538ea08c02716ee5b8a6e71367..1ff49baf6edd87174eb0f2b0d31e704938eb5cfc 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out @@ -199,17 +199,6 @@ Synthesis round 1: Backward controlled-behavior: machine1.Idle and machine2.Idle [marker predicate] Backward controlled-behavior: machine1.Idle and machine2.Idle -> machine1.Idle and (machine1.producing = 0 and machine2.Idle) or machine1.Idle and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) [restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - Backward reachability iteration 1: - Backward controlled-behavior: machine1.Idle and (machine1.producing = 0 and machine2.Idle) or machine1.Idle and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) -> not machine1.Producing and (machine1.producing = 0 and machine2.Idle) or not machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) [backward reach with edge: (event: machine1.u_finished) (guard: machine1.CoolDown) (assignments: machine1 := machine1.Idle), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - Backward controlled-behavior: not machine1.Producing and (machine1.producing = 0 and machine2.Idle) or not machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) -> not machine1.Producing and (machine1.producing = 0 and not machine2.Producing) or not machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing) [backward reach with edge: (event: machine2.u_finished) (guard: machine2.CoolDown) (assignments: machine2 := machine2.Idle), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - - Backward reachability iteration 2: - Backward controlled-behavior: not machine1.Producing and (machine1.producing = 0 and not machine2.Producing) or not machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing) -> not machine1.Producing and (machine1.producing = 0 and not machine2.Producing) or not machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing) or (machine1.Producing and (machine1.producing = 0 and not machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing)) [backward reach with edge: (event: machine1.u_waiting) (guard: machine1.Producing) (assignments: machine1.producing := 0, machine1 := machine1.CoolDown), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - Backward controlled-behavior: not machine1.Producing and (machine1.producing = 0 and not machine2.Producing) or not machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing) or (machine1.Producing and (machine1.producing = 0 and not machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing)) -> (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) [backward reach with edge: (event: machine2.u_waiting) (guard: machine2.Producing) (assignments: machine2.producing := 0, machine2 := machine2.CoolDown), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) [fixed point]. Controlled behavior not changed. @@ -217,26 +206,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: not machine1.Producing and (machine1.producing = 1 and machine2.producing = 1) or machine1.Producing and (machine1.producing = 1 and machine2.producing = 1) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: machine1.Idle and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: machine1.Idle and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) -> machine1.Idle and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) [forward reach with edge: (event: machine1.c_start) (guard: machine1.Idle) (assignments: machine1.producing := 1, machine1 := machine1.Producing), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - Forward controlled-behavior: machine1.Idle and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) [forward reach with edge: (event: machine1.u_waiting) (guard: machine1.Producing) (assignments: machine1.producing := 0, machine1 := machine1.CoolDown), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - Forward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle)) [forward reach with edge: (event: machine2.c_start) (guard: machine2.Idle) (assignments: machine2.producing := 1, machine2 := machine2.Producing), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - Forward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle)) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle)) [forward reach with edge: (event: machine2.u_waiting) (guard: machine2.Producing) (assignments: machine2.producing := 0, machine2 := machine2.CoolDown), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - - Forward reachability iteration 2: - Forward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and machine2.Idle)) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing)) [forward reach with edge: (event: machine1.c_start) (guard: machine1.Idle) (assignments: machine1.producing := 1, machine1 := machine1.Producing), restricted to current/previous controlled-behavior predicate: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0))] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing)) [fixed point]. Controlled behavior: (machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) and (not machine1.Producing or (machine1.producing = 0 or machine2.producing = 0)) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing)). @@ -248,17 +222,6 @@ Synthesis round 2: Backward controlled-behavior: machine1.Idle and machine2.Idle [marker predicate] Backward controlled-behavior: machine1.Idle and machine2.Idle -> machine1.Idle and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) [restricted to current/previous controlled-behavior predicate: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing))] - Backward reachability iteration 1: - Backward controlled-behavior: machine1.Idle and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) [backward reach with edge: (event: machine1.u_finished) (guard: machine1.CoolDown) (assignments: machine1 := machine1.Idle), restricted to current/previous controlled-behavior predicate: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing))] - Backward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and machine2.Idle) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) [backward reach with edge: (event: machine2.u_finished) (guard: machine2.CoolDown) (assignments: machine2 := machine2.Idle), restricted to current/previous controlled-behavior predicate: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing))] - - Backward reachability iteration 2: - Backward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing) [backward reach with edge: (event: machine1.u_waiting) (guard: machine1.Producing) (assignments: machine1.producing := 0, machine1 := machine1.CoolDown), restricted to current/previous controlled-behavior predicate: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing))] - Backward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing) -> not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing)) [backward reach with edge: (event: machine2.u_waiting) (guard: machine2.Producing) (assignments: machine2.producing := 0, machine2 := machine2.CoolDown), restricted to current/previous controlled-behavior predicate: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing))] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: not machine1.Producing and machine1.producing = 0 and (machine2.producing = 0 and not machine2.Producing) or (not machine1.Producing and machine1.producing = 0 and (machine2.producing = 1 and machine2.Producing) or machine1.Producing and machine1.producing = 1 and (machine2.producing = 0 and not machine2.Producing)) [fixed point]. Controlled behavior not changed. @@ -266,9 +229,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (machine1.Producing or machine1.producing = 1 or (machine2.producing = 1 or machine2.Producing)) and ((machine1.Producing or machine1.producing = 1 or (machine2.producing = 0 or not machine2.Producing)) and (not machine1.Producing or machine1.producing = 0 or (machine2.producing = 1 or machine2.Producing))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out index 70ba78ecb863265b75a5a6d94f20a92a63f0f6c2..874e0bc9a4342b5f51e8fd3c1360f1b05565de4a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out @@ -184,17 +184,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: machine1.Idle and machine2.Idle [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: machine1.Idle and machine2.Idle -> not machine1.Producing and machine2.Idle [backward reach with edge: (event: machine1.u_finished) (guard: machine1.CoolDown) (assignments: machine1 := machine1.Idle), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - Backward controlled-behavior: not machine1.Producing and machine2.Idle -> not machine1.Producing and not machine2.Producing [backward reach with edge: (event: machine2.u_finished) (guard: machine2.CoolDown) (assignments: machine2 := machine2.Idle), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - - Backward reachability iteration 2: - Backward controlled-behavior: not machine1.Producing and not machine2.Producing -> (machine1.Producing or not machine2.Producing) and (not machine1.Producing or not machine2.Producing) [backward reach with edge: (event: machine1.u_waiting) (guard: machine1.Producing) (assignments: machine1 := machine1.CoolDown), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - Backward controlled-behavior: (machine1.Producing or not machine2.Producing) and (not machine1.Producing or not machine2.Producing) -> not machine1.Producing or not machine2.Producing [backward reach with edge: (event: machine2.u_waiting) (guard: machine2.Producing) (assignments: machine2 := machine2.CoolDown), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: not machine1.Producing or not machine2.Producing [fixed point]. Controlled behavior not changed. @@ -202,26 +191,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: machine1.Producing and machine2.Producing [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: machine1.Idle and machine2.Idle [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: machine1.Idle and machine2.Idle -> not machine1.CoolDown and machine2.Idle [forward reach with edge: (event: machine1.c_start) (guard: machine1.Idle) (assignments: machine1 := machine1.Producing), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - Forward controlled-behavior: not machine1.CoolDown and machine2.Idle -> not machine1.Producing and machine2.Idle or machine1.Producing and machine2.Idle [forward reach with edge: (event: machine1.u_waiting) (guard: machine1.Producing) (assignments: machine1 := machine1.CoolDown), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - Forward controlled-behavior: not machine1.Producing and machine2.Idle or machine1.Producing and machine2.Idle -> not machine1.Producing and not machine2.CoolDown or machine1.Producing and machine2.Idle [forward reach with edge: (event: machine2.c_start) (guard: machine2.Idle) (assignments: machine2 := machine2.Producing), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - Forward controlled-behavior: not machine1.Producing and not machine2.CoolDown or machine1.Producing and machine2.Idle -> (not machine1.Producing or not machine2.CoolDown) and (not machine1.Producing or not machine2.Producing) [forward reach with edge: (event: machine2.u_waiting) (guard: machine2.Producing) (assignments: machine2 := machine2.CoolDown), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - - Forward reachability iteration 2: - Forward controlled-behavior: (not machine1.Producing or not machine2.CoolDown) and (not machine1.Producing or not machine2.Producing) -> not machine1.Producing or not machine2.Producing [forward reach with edge: (event: machine1.c_start) (guard: machine1.Idle) (assignments: machine1 := machine1.Producing), restricted to current/previous controlled-behavior predicate: not machine1.Producing or not machine2.Producing] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: not machine1.Producing or not machine2.Producing [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out index a91eb2a0d7950ee151999d1b04663bdfa019772f..70a989332619362dbdac87c38097a9132aa169bb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out @@ -208,25 +208,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: g.r.loc1 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: g.r.loc2 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: g.r.loc1 [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_conflict.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_conflict.cif.out index b2ad7f508d81a9c383f91fc8e88e6f1298e59851..42b9821cbc9719a787edf997f7b5ed12b7461484 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_conflict.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_conflict.cif.out @@ -78,9 +78,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -91,9 +88,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_non_empty.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_non_empty.cif.out index 102797b5235ab67cee2aa86e9d01edd845d29fd6..4626bb961bc2cba5b9eee5b2531f83043bf25292 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_non_empty.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace_non_empty.cif.out @@ -79,25 +79,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out index 36cb8eafcbcf77a79dde0c0c7e0734317d691f08..ed2a87019ba8d6fe317cf349ce1234f9f176a1a7 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out @@ -193,9 +193,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: false [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: true -> false. Finished: all states are bad. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out index 2f635fe7f096be9d55b9380a3202acf73a3a8f0d..8d24b057c16b49b0d4a5c25a08a03006a9a22a4c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out @@ -194,12 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.l0 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.l0 -> not p.l1 [backward reach with edge: (event: p.u) (guard: p.l2) (assignments: p := p.l0), restricted to current/previous controlled-behavior predicate: not p.l1] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: not p.l1 [fixed point]. Controlled behavior not changed. @@ -207,13 +201,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.l1 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: p.l1 -> (p.x1 or p.l1) and (not p.x1 or not p.l2) [backward reach with edge: (event: p.u) (guard: p.x1 and p.l0) (assignments: p := p.l1)] - Backward uncontrolled bad-state: (p.x1 or p.l1) and (not p.x1 or not p.l2) -> p.x1 or p.l1 [backward reach with edge: (event: p.u) (guard: p.l2) (assignments: p := p.l0)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: p.x1 or p.l1 [fixed point]. Controlled behavior: not p.l1 -> not p.x1 and not p.l1. @@ -221,13 +208,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: not p.x1 and (p.l0 and not p.x2) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: not p.x1 and (p.l0 and not p.x2) -> not p.x1 and p.l0 [forward reach with edge: (event: p.c2) (guard: p.l0) (assignments: p.x2 := true), restricted to current/previous controlled-behavior predicate: not p.x1 and not p.l1] - Forward controlled-behavior: not p.x1 and p.l0 -> not p.x1 and p.l0 or not p.x1 and (p.l2 and p.x2) [forward reach with edge: (event: p.u) (guard: p.l0 and p.x2) (assignments: p := p.l2), restricted to current/previous controlled-behavior predicate: not p.x1 and not p.l1] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: not p.x1 and p.l0 or not p.x1 and (p.l2 and p.x2) [fixed point]. Controlled behavior: not p.x1 and not p.l1 -> not p.x1 and p.l0 or not p.x1 and (p.l2 and p.x2). @@ -239,12 +219,6 @@ Synthesis round 2: Backward controlled-behavior: p.l0 [marker predicate] Backward controlled-behavior: p.l0 -> not p.x1 and p.l0 [restricted to current/previous controlled-behavior predicate: not p.x1 and p.l0 or not p.x1 and (p.l2 and p.x2)] - Backward reachability iteration 1: - Backward controlled-behavior: not p.x1 and p.l0 -> not p.x1 and p.l0 or not p.x1 and (p.l2 and p.x2) [backward reach with edge: (event: p.u) (guard: p.l2) (assignments: p := p.l0), restricted to current/previous controlled-behavior predicate: not p.x1 and p.l0 or not p.x1 and (p.l2 and p.x2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: not p.x1 and p.l0 or not p.x1 and (p.l2 and p.x2) [fixed point]. Controlled behavior not changed. @@ -252,9 +226,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x1 or not p.l0) and (p.x1 or (not p.l2 or not p.x2)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/plant_alphabet.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/plant_alphabet.cif.out index ac3c422a7c445fb3e07cb1602bcfa363df685cd1..d01e3365862359c9456d802ed65f1831ffda19e7 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/plant_alphabet.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/plant_alphabet.cif.out @@ -87,9 +87,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p1.l0 [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior: true -> p1.l0. Computing backward uncontrolled bad-state predicate: @@ -100,9 +97,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p1.l0 [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/pred_static_eval.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/pred_static_eval.cif.out index 4ee95027eb3447cc4cc4571c77779f6caef4f767..bef6202c7e42c18c3072098e3564f651fd6256b5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/pred_static_eval.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/pred_static_eval.cif.out @@ -181,9 +181,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> not p.b1 and (p.b2 and not p.b3) [restricted to current/previous controlled-behavior predicate: not p.b1 and (p.b2 and not p.b3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: not p.b1 and (p.b2 and not p.b3) [fixed point]. Controlled behavior not changed. @@ -191,17 +188,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.b1 or (not p.b2 or p.b3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: not p.b1 and (p.b2 and not p.b3) [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out index 0d473773eac732d037bf53b3adddd98d4db21678..ad3c2cdec36bd89e74b1eafb4a2340187cd28053 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out @@ -258,9 +258,6 @@ Synthesis round 1: Backward controlled-behavior: p.l0 [marker predicate] Backward controlled-behavior: p.l0 -> <bdd 21n 960p> [restricted to current/previous controlled-behavior predicate: <bdd 20n 960p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 21n 960p> [fixed point]. Controlled behavior: <bdd 20n 960p> -> <bdd 21n 960p>. @@ -273,9 +270,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: <bdd 22n 1p> [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior: <bdd 21n 960p> -> <bdd 22n 1p>. Need another round. @@ -285,9 +279,6 @@ Synthesis round 2: Backward controlled-behavior: p.l0 [marker predicate] Backward controlled-behavior: p.l0 -> <bdd 22n 1p> [restricted to current/previous controlled-behavior predicate: <bdd 22n 1p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 22n 1p> [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/range.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/range.cif.out index d6f0b8f96498490168d8f5ecea6307100ae7b251..8ccb0786ce06b23589aefb5e744649cd7761b5d6 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/range.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/range.cif.out @@ -96,9 +96,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -111,20 +108,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer.x = 2 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer.x = 2 -> buffer.x = 2 or buffer.x = 3 [forward reach with edge: (event: buffer.add) (guard: true -> true) (assignments: buffer.x := buffer.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: buffer.x = 2 or buffer.x = 3 -> buffer.x = 2 or (buffer.x = 1 or buffer.x = 3) [forward reach with edge: (event: buffer.remove) (guard: true -> buffer.x != 0) (assignments: buffer.x := buffer.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer.x = 2 or (buffer.x = 1 or buffer.x = 3) -> buffer.x != 0 and buffer.x != 5 [forward reach with edge: (event: buffer.add) (guard: true -> true) (assignments: buffer.x := buffer.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: buffer.x != 0 and buffer.x != 5 -> buffer.x != 5 [forward reach with edge: (event: buffer.remove) (guard: true -> buffer.x != 0) (assignments: buffer.x := buffer.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: buffer.x != 5 -> true [forward reach with edge: (event: buffer.add) (guard: true -> true) (assignments: buffer.x := buffer.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability1_workset_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability1_workset_off.cif.out index a72e1df89bce1e54aa56653581fe8c763bda1dea..e9518b727dd4cbc424ee400c44246ca6cbd71506 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability1_workset_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability1_workset_off.cif.out @@ -101,41 +101,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.v = 14 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.v = 14 -> p.v = 14 or p.v = 13 [backward reach with edge: (event: p.m) (guard: p.v = 13) (assignments: p.v := 14), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.v = 14 or p.v = 13 -> p.v = 12 or (p.v = 14 or p.v = 13) [backward reach with edge: (event: p.k) (guard: p.v = 12) (assignments: p.v := 13), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.v = 12 or (p.v = 14 or p.v = 13) -> p.v = 12 or p.v = 14 or (p.v = 13 or p.v = 11) [backward reach with edge: (event: p.j) (guard: p.v = 11) (assignments: p.v := 12), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.v = 12 or p.v = 14 or (p.v = 13 or p.v = 11) -> p.v = 12 or p.v = 10 or (p.v = 14 or (p.v = 13 or p.v = 11)) [backward reach with edge: (event: p.i) (guard: p.v = 10) (assignments: p.v := 11), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: p.v = 12 or p.v = 10 or (p.v = 14 or (p.v = 13 or p.v = 11)) -> p.v = 12 or (p.v = 10 or p.v = 14) or (p.v = 9 or (p.v = 13 or p.v = 11)) [backward reach with edge: (event: p.h) (guard: p.v = 9) (assignments: p.v := 10), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.v = 12 or (p.v = 10 or p.v = 14) or (p.v = 9 or (p.v = 13 or p.v = 11)) -> p.v = 8 or (p.v = 10 or p.v = 12) or (p.v = 14 or p.v = 9 or (p.v = 13 or p.v = 11)) [backward reach with edge: (event: p.g) (guard: p.v = 8) (assignments: p.v := 9), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: p.v = 8 or (p.v = 10 or p.v = 12) or (p.v = 14 or p.v = 9 or (p.v = 13 or p.v = 11)) -> p.v = 8 or p.v = 10 or (p.v = 12 or p.v = 14) or (p.v = 9 or p.v = 13 or (p.v = 11 or p.v = 7)) [backward reach with edge: (event: p.f) (guard: p.v = 6 or p.v = 7) (assignments: p.v := 8 / p.v := 7), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - Backward controlled-behavior: p.v = 8 or p.v = 10 or (p.v = 12 or p.v = 14) or (p.v = 9 or p.v = 13 or (p.v = 11 or p.v = 7)) -> not(p.v = 0 or p.v = 4) and p.v != 2 and (not(p.v = 1 or p.v = 5) and p.v != 3) [backward reach with edge: (event: p.f) (guard: p.v = 6 or p.v = 7) (assignments: p.v := 8 / p.v := 7), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not(p.v = 0 or p.v = 4) and p.v != 2 and (not(p.v = 1 or p.v = 5) and p.v != 3) -> not(p.v = 0 or p.v = 4) and p.v != 2 and (p.v != 1 and p.v != 3) [backward reach with edge: (event: p.e) (guard: p.v = 5) (assignments: p.v := 6), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 7: - Backward controlled-behavior: not(p.v = 0 or p.v = 4) and p.v != 2 and (p.v != 1 and p.v != 3) -> (p.v = 1 or 3 <= p.v and p.v <= 14) and (p.v != 1 and p.v != 3) [backward reach with edge: (event: p.d) (guard: p.v = 4 or p.v = 3) (assignments: p.v := 4 / p.v := 5), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 8: - Backward controlled-behavior: (p.v = 1 or 3 <= p.v and p.v <= 14) and (p.v != 1 and p.v != 3) -> (p.v = 1 or 3 <= p.v and p.v <= 14) and p.v != 1 [backward reach with edge: (event: p.d) (guard: p.v = 4 or p.v = 3) (assignments: p.v := 4 / p.v := 5), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.v = 1 or 3 <= p.v and p.v <= 14) and p.v != 1 -> p.v != 0 and p.v != 1 [backward reach with edge: (event: p.c) (guard: p.v = 2) (assignments: p.v := 3), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.v != 0 and p.v != 1 -> p.v != 0 [backward reach with edge: (event: p.b) (guard: p.v = 1) (assignments: p.v := 2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 9: - Backward controlled-behavior: p.v != 0 -> true [backward reach with edge: (event: p.a) (guard: p.v = 0) (assignments: p.v := 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 10: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -143,45 +108,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.v = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.v = 0 -> p.v = 0 or p.v = 1 [forward reach with edge: (event: p.a) (guard: p.v = 0) (assignments: p.v := 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v = 0 or p.v = 1 -> p.v = 0 or (p.v = 2 or p.v = 1) [forward reach with edge: (event: p.b) (guard: p.v = 1) (assignments: p.v := 2), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: p.v = 0 or (p.v = 2 or p.v = 1) -> 0 <= p.v and p.v <= 3 [forward reach with edge: (event: p.c) (guard: p.v = 2) (assignments: p.v := 3), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: 0 <= p.v and p.v <= 3 -> p.v = 0 or p.v = 4 or (p.v = 2 or (p.v = 1 or p.v = 3)) [forward reach with edge: (event: p.d) (guard: p.v = 4 or p.v = 3) (assignments: p.v := 4 / p.v := 5), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: p.v = 0 or p.v = 4 or (p.v = 2 or (p.v = 1 or p.v = 3)) -> p.v = 0 or (p.v = 1 or p.v = 4) or (p.v = 5 or (p.v = 2 or p.v = 3)) [forward reach with edge: (event: p.d) (guard: p.v = 4 or p.v = 3) (assignments: p.v := 4 / p.v := 5), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v = 0 or (p.v = 1 or p.v = 4) or (p.v = 5 or (p.v = 2 or p.v = 3)) -> p.v = 0 or (p.v = 2 or p.v = 4) or (p.v = 6 or p.v = 1 or (p.v = 5 or p.v = 3)) [forward reach with edge: (event: p.e) (guard: p.v = 5) (assignments: p.v := 6), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: p.v = 0 or (p.v = 2 or p.v = 4) or (p.v = 6 or p.v = 1 or (p.v = 5 or p.v = 3)) -> 0 <= p.v and p.v <= 7 [forward reach with edge: (event: p.f) (guard: p.v = 6 or p.v = 7) (assignments: p.v := 8 / p.v := 7), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - Forward controlled-behavior: 0 <= p.v and p.v <= 7 -> p.v != 12 and (not(p.v = 10 or p.v = 14) and not(p.v = 9 or (p.v = 11 or p.v = 13))) [forward reach with edge: (event: p.f) (guard: p.v = 6 or p.v = 7) (assignments: p.v := 8 / p.v := 7), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v != 12 and (not(p.v = 10 or p.v = 14) and not(p.v = 9 or (p.v = 11 or p.v = 13))) -> (0 <= p.v and p.v <= 11 or p.v = 14) and (0 <= p.v and p.v <= 9 or (p.v = 12 or p.v = 13)) [forward reach with edge: (event: p.g) (guard: p.v = 8) (assignments: p.v := 9), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (0 <= p.v and p.v <= 11 or p.v = 14) and (0 <= p.v and p.v <= 9 or (p.v = 12 or p.v = 13)) -> (0 <= p.v and p.v <= 11 or p.v = 13) and (p.v != 13 and p.v != 11) [forward reach with edge: (event: p.h) (guard: p.v = 9) (assignments: p.v := 10), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (0 <= p.v and p.v <= 11 or p.v = 13) and (p.v != 13 and p.v != 11) -> 0 <= p.v and p.v <= 11 [forward reach with edge: (event: p.i) (guard: p.v = 10) (assignments: p.v := 11), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: 0 <= p.v and p.v <= 11 -> p.v != 14 and p.v != 13 [forward reach with edge: (event: p.j) (guard: p.v = 11) (assignments: p.v := 12), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v != 14 and p.v != 13 -> p.v != 14 [forward reach with edge: (event: p.l) (guard: p.v = 12) (assignments: p.v := 13), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 7: - Forward controlled-behavior: p.v != 14 -> true [forward reach with edge: (event: p.m) (guard: p.v = 13) (assignments: p.v := 14), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 8: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability2_workset_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability2_workset_off.cif.out index 76b142aad9e866712a5132b41a77dc3a31499ce2..3c7396388561ffabe4a22ae2860aa53535a88f9d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability2_workset_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/reachability2_workset_off.cif.out @@ -189,25 +189,6 @@ Synthesis round 1: Backward controlled-behavior: p.increase [marker predicate] Backward controlled-behavior: p.increase -> (p.x = 2 or (p.x = 3 or p.increase)) and (not(p.x = 2 or p.x = 3) or p.increase) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: (p.x = 2 or (p.x = 3 or p.increase)) and (not(p.x = 2 or p.x = 3) or p.increase) -> (p.x != 4 or p.increase) and (p.x != 2 or p.increase) and ((p.x = 0 or (2 <= p.x and p.x <= 4 or p.increase)) and (p.x != 3 or p.increase)) [backward reach with edge: (event: p.u_switch) (guard: p.x = 0 and p.decrease or p.x = 5 and p.increase) (assignments: p := p.decrease / p := p.increase), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p.x != 4 or p.increase) and (p.x != 2 or p.increase) and ((p.x = 0 or (2 <= p.x and p.x <= 4 or p.increase)) and (p.x != 3 or p.increase)) -> (0 <= p.x and p.x <= 3 or p.increase) and (not(p.x = 2 or p.x = 3) or p.increase) [backward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (0 <= p.x and p.x <= 3 or p.increase) and (not(p.x = 2 or p.x = 3) or p.increase) -> (p.x != 4 or p.increase) and ((p.x != 5 or p.increase) and (p.x != 3 or p.increase)) [backward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (p.x != 4 or p.increase) and ((p.x != 5 or p.increase) and (p.x != 3 or p.increase)) -> 0 <= p.x and p.x <= 3 or p.increase [backward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: 0 <= p.x and p.x <= 3 or p.increase -> p.x != 5 or p.increase [backward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: p.x != 5 or p.increase -> true [backward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -215,46 +196,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and p.increase [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and p.increase -> (p.x = 0 or p.x = 1) and p.increase [forward reach with edge: (event: p.u_inc) (guard: (p.x = 0 or p.x = 4) and p.increase or (p.x = 2 and p.increase or (p.x = 1 or p.x = 3) and p.increase)) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and p.increase -> (p.x = 0 or p.x = 2) and p.increase or p.x = 1 and p.increase [forward reach with edge: (event: p.u_inc) (guard: (p.x = 0 or p.x = 4) and p.increase or (p.x = 2 and p.increase or (p.x = 1 or p.x = 3) and p.increase)) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x = 0 or p.x = 2) and p.increase or p.x = 1 and p.increase -> 0 <= p.x and (p.x <= 3 and p.increase) [forward reach with edge: (event: p.u_inc) (guard: (p.x = 0 or p.x = 4) and p.increase or (p.x = 2 and p.increase or (p.x = 1 or p.x = 3) and p.increase)) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: 0 <= p.x and (p.x <= 3 and p.increase) -> (p.x = 0 or p.x = 4) and p.increase or (p.x = 2 and p.increase or (p.x = 1 or p.x = 3) and p.increase) [forward reach with edge: (event: p.u_inc) (guard: (p.x = 0 or p.x = 4) and p.increase or (p.x = 2 and p.increase or (p.x = 1 or p.x = 3) and p.increase)) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: (p.x = 0 or p.x = 4) and p.increase or (p.x = 2 and p.increase or (p.x = 1 or p.x = 3) and p.increase) -> (p.x = 2 or (p.x = 3 or p.increase)) and (not(p.x = 2 or p.x = 3) or p.increase) [forward reach with edge: (event: p.u_inc) (guard: (p.x = 0 or p.x = 4) and p.increase or (p.x = 2 and p.increase or (p.x = 1 or p.x = 3) and p.increase)) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (p.x = 2 or (p.x = 3 or p.increase)) and (not(p.x = 2 or p.x = 3) or p.increase) -> (1 <= p.x and p.x <= 3 or (p.x = 5 or p.increase)) and (p.x != 2 or p.increase) and ((p.x != 1 or p.increase) and (p.x != 3 or p.increase)) [forward reach with edge: (event: p.u_switch) (guard: p.x = 0 and p.decrease or p.x = 5 and p.increase) (assignments: p := p.decrease / p := p.increase), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (1 <= p.x and p.x <= 3 or (p.x = 5 or p.increase)) and (p.x != 2 or p.increase) and ((p.x != 1 or p.increase) and (p.x != 3 or p.increase)) -> (2 <= p.x and p.x <= 5 or p.increase) and (not(p.x = 2 or p.x = 3) or p.increase) [forward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - Forward controlled-behavior: (2 <= p.x and p.x <= 5 or p.increase) and (not(p.x = 2 or p.x = 3) or p.increase) -> (p.x != 0 or p.increase) and ((p.x != 2 or p.increase) and (p.x != 1 or p.increase)) [forward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 7: - Forward controlled-behavior: (p.x != 0 or p.increase) and ((p.x != 2 or p.increase) and (p.x != 1 or p.increase)) -> 2 <= p.x and p.x <= 5 or p.increase [forward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 8: - Forward controlled-behavior: 2 <= p.x and p.x <= 5 or p.increase -> p.x != 0 or p.increase [forward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 9: - Forward controlled-behavior: p.x != 0 or p.increase -> true [forward reach with edge: (event: p.u_dec) (guard: p.x = 4 and p.decrease or (p.x = 2 and p.decrease or (p.x = 1 or (p.x = 3 or p.x = 5)) and p.decrease)) (assignments: p.x := p.x - 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 10: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/remove_controller_properties.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/remove_controller_properties.cif.out index 3d9d4c8672fe01d1ed4a62a6ef1ef462ab0f3b84..4e9a4b833e02a744fb49fb12e60d5ac8c339b6a4 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/remove_controller_properties.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/remove_controller_properties.cif.out @@ -84,25 +84,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_aut_disc_var.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_aut_disc_var.cif.out index 6285f43ecbafc5b56c1ff56c5e164f6097f76e05..915c366c764545775be2f2e40e8e3a56a9e5f8f3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_aut_disc_var.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_aut_disc_var.cif.out @@ -98,9 +98,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -113,9 +110,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: r.x = 5 [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior: true -> r.x = 5. Need another round. @@ -125,9 +119,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> r.x = 5 [restricted to current/previous controlled-behavior predicate: r.x = 5] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: r.x = 5 [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out index 75885ddd8bd26a243aebd7b8a365f80642dd4513..cc04e906bb3dae0b3e768cdbb513b43221c5802c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out @@ -205,15 +205,6 @@ Synthesis round 1: Backward controlled-behavior: adder.l1 [marker predicate] Backward controlled-behavior: adder.l1 -> 0 <= count_max3.cnt and (count_max3.cnt <= 3 and adder.l1) [restricted to current/previous controlled-behavior predicate: (count_max3.cnt != 0 or not adder.l3) and (count_max3.cnt != 8 and count_max3.cnt != 4) and (count_max3.cnt != 10 and count_max3.cnt != 6 and (count_max3.cnt != 9 and not(count_max3.cnt = 5 or count_max3.cnt = 7)))] - Backward reachability iteration 1: - Backward controlled-behavior: 0 <= count_max3.cnt and (count_max3.cnt <= 3 and adder.l1) -> count_max3.cnt = 0 and adder.l1 or (count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 1 or count_max3.cnt = 3) and not adder.l2) [backward reach with edge: (event: adder.u_remove) (guard: adder.l3 -> count_max3.cnt = 8 and adder.l3 or count_max3.cnt = 4 and adder.l3 or ((count_max3.cnt = 2 or (count_max3.cnt = 6 or count_max3.cnt = 10)) and adder.l3 or (count_max3.cnt = 1 or count_max3.cnt = 3 or (count_max3.cnt = 5 or (count_max3.cnt = 7 or count_max3.cnt = 9))) and adder.l3)) (assignments: adder := adder.l1, count_max3.cnt := count_max3.cnt - 1), restricted to current/previous controlled-behavior predicate: (count_max3.cnt != 0 or not adder.l3) and (count_max3.cnt != 8 and count_max3.cnt != 4) and (count_max3.cnt != 10 and count_max3.cnt != 6 and (count_max3.cnt != 9 and not(count_max3.cnt = 5 or count_max3.cnt = 7)))] - - Backward reachability iteration 2: - Backward controlled-behavior: count_max3.cnt = 0 and adder.l1 or (count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 1 or count_max3.cnt = 3) and not adder.l2) -> count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2)) [backward reach with edge: (event: adder.c_add) (guard: adder.l2 -> (count_max3.cnt = 1 or (count_max3.cnt = 3 or count_max3.cnt = 5) or (count_max3.cnt = 7 or (count_max3.cnt = 9 or adder.l2))) and (not(count_max3.cnt = 1 or (count_max3.cnt = 5 or count_max3.cnt = 9)) or adder.l2) and ((count_max3.cnt != 3 or adder.l2) and (count_max3.cnt != 7 or adder.l2))) (assignments: adder := adder.l3, count_max3.cnt := count_max3.cnt + 1), restricted to current/previous controlled-behavior predicate: (count_max3.cnt != 0 or not adder.l3) and (count_max3.cnt != 8 and count_max3.cnt != 4) and (count_max3.cnt != 10 and count_max3.cnt != 6 and (count_max3.cnt != 9 and not(count_max3.cnt = 5 or count_max3.cnt = 7)))] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2)) [fixed point]. Controlled behavior: (count_max3.cnt != 0 or not adder.l3) and (count_max3.cnt != 8 and count_max3.cnt != 4) and (count_max3.cnt != 10 and count_max3.cnt != 6 and (count_max3.cnt != 9 and not(count_max3.cnt = 5 or count_max3.cnt = 7))) -> count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2)). @@ -221,27 +212,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (count_max3.cnt != 0 or adder.l3) and ((count_max3.cnt != 2 or adder.l2) and (count_max3.cnt != 2 or not adder.l2)) and ((count_max3.cnt != 1 or adder.l2) and ((count_max3.cnt != 1 or not adder.l2) and (count_max3.cnt != 3 or adder.l2))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 -> count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 1 and adder.l2 [forward reach with edge: (event: adder.c_add) (guard: adder.l1 -> (count_max3.cnt = 0 or (count_max3.cnt = 2 or count_max3.cnt = 4) or (count_max3.cnt = 6 or (count_max3.cnt = 8 or count_max3.cnt = 10))) and adder.l1 or (count_max3.cnt = 1 or (count_max3.cnt = 5 or count_max3.cnt = 9)) and adder.l1 or (count_max3.cnt = 3 and adder.l1 or count_max3.cnt = 7 and adder.l1)) (assignments: adder := adder.l2, count_max3.cnt := count_max3.cnt + 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2))] - Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 1 and adder.l2 -> count_max3.cnt = 0 and adder.l1 or (count_max3.cnt = 2 and adder.l3 or count_max3.cnt = 1 and adder.l2) [forward reach with edge: (event: adder.c_add) (guard: adder.l2 -> (count_max3.cnt = 1 or (count_max3.cnt = 3 or count_max3.cnt = 5) or (count_max3.cnt = 7 or (count_max3.cnt = 9 or adder.l2))) and (not(count_max3.cnt = 1 or (count_max3.cnt = 5 or count_max3.cnt = 9)) or adder.l2) and ((count_max3.cnt != 3 or adder.l2) and (count_max3.cnt != 7 or adder.l2))) (assignments: adder := adder.l3, count_max3.cnt := count_max3.cnt + 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2))] - Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 or (count_max3.cnt = 2 and adder.l3 or count_max3.cnt = 1 and adder.l2) -> count_max3.cnt = 0 and adder.l1 or (count_max3.cnt = 2 and adder.l3 or count_max3.cnt = 1 and not adder.l3) [forward reach with edge: (event: adder.u_remove) (guard: adder.l3 -> count_max3.cnt = 8 and adder.l3 or count_max3.cnt = 4 and adder.l3 or ((count_max3.cnt = 2 or (count_max3.cnt = 6 or count_max3.cnt = 10)) and adder.l3 or (count_max3.cnt = 1 or count_max3.cnt = 3 or (count_max3.cnt = 5 or (count_max3.cnt = 7 or count_max3.cnt = 9))) and adder.l3)) (assignments: adder := adder.l1, count_max3.cnt := count_max3.cnt - 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2))] - - Forward reachability iteration 2: - Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 or (count_max3.cnt = 2 and adder.l3 or count_max3.cnt = 1 and not adder.l3) -> count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and adder.l3 or (count_max3.cnt = 2 and adder.l2 or count_max3.cnt = 1 and not adder.l3) [forward reach with edge: (event: adder.c_add) (guard: adder.l1 -> (count_max3.cnt = 0 or (count_max3.cnt = 2 or count_max3.cnt = 4) or (count_max3.cnt = 6 or (count_max3.cnt = 8 or count_max3.cnt = 10))) and adder.l1 or (count_max3.cnt = 1 or (count_max3.cnt = 5 or count_max3.cnt = 9)) and adder.l1 or (count_max3.cnt = 3 and adder.l1 or count_max3.cnt = 7 and adder.l1)) (assignments: adder := adder.l2, count_max3.cnt := count_max3.cnt + 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2))] - Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and adder.l3 or (count_max3.cnt = 2 and adder.l2 or count_max3.cnt = 1 and not adder.l3) -> count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and adder.l3 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3)) [forward reach with edge: (event: adder.c_add) (guard: adder.l2 -> (count_max3.cnt = 1 or (count_max3.cnt = 3 or count_max3.cnt = 5) or (count_max3.cnt = 7 or (count_max3.cnt = 9 or adder.l2))) and (not(count_max3.cnt = 1 or (count_max3.cnt = 5 or count_max3.cnt = 9)) or adder.l2) and ((count_max3.cnt != 3 or adder.l2) and (count_max3.cnt != 7 or adder.l2))) (assignments: adder := adder.l3, count_max3.cnt := count_max3.cnt + 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2))] - Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and adder.l3 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3)) -> count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3)) [forward reach with edge: (event: adder.u_remove) (guard: adder.l3 -> count_max3.cnt = 8 and adder.l3 or count_max3.cnt = 4 and adder.l3 or ((count_max3.cnt = 2 or (count_max3.cnt = 6 or count_max3.cnt = 10)) and adder.l3 or (count_max3.cnt = 1 or count_max3.cnt = 3 or (count_max3.cnt = 5 or (count_max3.cnt = 7 or count_max3.cnt = 9))) and adder.l3)) (assignments: adder := adder.l1, count_max3.cnt := count_max3.cnt - 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2))] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3)) [fixed point]. Controlled behavior: count_max3.cnt = 0 and not adder.l3 or (count_max3.cnt = 2 and not adder.l2 or count_max3.cnt = 2 and adder.l2) or (count_max3.cnt = 1 and not adder.l2 or (count_max3.cnt = 1 and adder.l2 or count_max3.cnt = 3 and not adder.l2)) -> count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3)). @@ -253,15 +228,6 @@ Synthesis round 2: Backward controlled-behavior: adder.l1 [marker predicate] Backward controlled-behavior: adder.l1 -> (count_max3.cnt = 0 or count_max3.cnt = 2) and adder.l1 or count_max3.cnt = 1 and adder.l1 [restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3))] - Backward reachability iteration 1: - Backward controlled-behavior: (count_max3.cnt = 0 or count_max3.cnt = 2) and adder.l1 or count_max3.cnt = 1 and adder.l1 -> count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 1 and adder.l1 or count_max3.cnt = 3 and adder.l3) [backward reach with edge: (event: adder.u_remove) (guard: adder.l3 -> count_max3.cnt = 8 and adder.l3 or count_max3.cnt = 4 and adder.l3 or ((count_max3.cnt = 2 or (count_max3.cnt = 6 or count_max3.cnt = 10)) and adder.l3 or (count_max3.cnt = 1 or count_max3.cnt = 3 or (count_max3.cnt = 5 or (count_max3.cnt = 7 or count_max3.cnt = 9))) and adder.l3)) (assignments: adder := adder.l1, count_max3.cnt := count_max3.cnt - 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3))] - - Backward reachability iteration 2: - Backward controlled-behavior: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 1 and adder.l1 or count_max3.cnt = 3 and adder.l3) -> count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3)) [backward reach with edge: (event: adder.c_add) (guard: adder.l2 -> (count_max3.cnt = 1 or (count_max3.cnt = 3 or count_max3.cnt = 5) or (count_max3.cnt = 7 or (count_max3.cnt = 9 or adder.l2))) and (not(count_max3.cnt = 1 or (count_max3.cnt = 5 or count_max3.cnt = 9)) or adder.l2) and ((count_max3.cnt != 3 or adder.l2) and (count_max3.cnt != 7 or adder.l2))) (assignments: adder := adder.l3, count_max3.cnt := count_max3.cnt + 1), restricted to current/previous controlled-behavior predicate: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3))] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: count_max3.cnt = 0 and adder.l1 or count_max3.cnt = 2 and not adder.l2 or (count_max3.cnt = 2 and adder.l2 or (count_max3.cnt = 1 and not adder.l3 or count_max3.cnt = 3 and adder.l3)) [fixed point]. Controlled behavior not changed. @@ -269,9 +235,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (count_max3.cnt != 0 or not adder.l1) and (count_max3.cnt != 2 or adder.l2) and ((count_max3.cnt != 2 or not adder.l2) and ((count_max3.cnt != 1 or adder.l3) and (count_max3.cnt != 3 or not adder.l3))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out index bd1912efd0a7af5bf32089fa48222d78833a211f..6c356abc8e46d6c31c5f6c309a33cde1a2fad1b8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out @@ -201,12 +201,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: r.loc1 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: r.loc1 -> p.x = 2 or (p.x = 3 or r.loc1) [backward reach with edge: (event: r.trace) (guard: (p.x = 2 or p.x = 3) and r.loc2) (assignments: r := r.loc1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 2 or (p.x = 3 or r.loc1) [fixed point]. Controlled behavior: true -> p.x = 2 or (p.x = 3 or r.loc1). @@ -219,20 +213,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and r.loc1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and r.loc1 -> (p.x = 0 or p.x = 1) and r.loc1 [forward reach with edge: (event: p.inc) (guard: true -> (p.x = 0 or p.x = 2) and r.loc1 or p.x = 1 and r.loc1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 2 or (p.x = 3 or r.loc1)] - - Forward reachability iteration 2: - Forward controlled-behavior: (p.x = 0 or p.x = 1) and r.loc1 -> (p.x = 0 or p.x = 2) and r.loc1 or p.x = 1 and r.loc1 [forward reach with edge: (event: p.inc) (guard: true -> (p.x = 0 or p.x = 2) and r.loc1 or p.x = 1 and r.loc1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 2 or (p.x = 3 or r.loc1)] - Forward controlled-behavior: (p.x = 0 or p.x = 2) and r.loc1 or p.x = 1 and r.loc1 -> (p.x != 0 or r.loc1) and ((p.x != 1 or r.loc1) and p.x != 3) [forward reach with edge: (event: r.trace) (guard: r.loc1) (assignments: r := r.loc2), restricted to current/previous controlled-behavior predicate: p.x = 2 or (p.x = 3 or r.loc1)] - - Forward reachability iteration 3: - Forward controlled-behavior: (p.x != 0 or r.loc1) and ((p.x != 1 or r.loc1) and p.x != 3) -> (p.x != 0 or r.loc1) and (p.x = 0 or (p.x = 2 or r.loc1)) [forward reach with edge: (event: p.inc) (guard: true -> (p.x = 0 or p.x = 2) and r.loc1 or p.x = 1 and r.loc1) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 2 or (p.x = 3 or r.loc1)] - Forward controlled-behavior: (p.x != 0 or r.loc1) and (p.x = 0 or (p.x = 2 or r.loc1)) -> p.x = 2 or (p.x = 3 or r.loc1) [forward reach with edge: (event: r.trace) (guard: r.loc1) (assignments: r := r.loc2), restricted to current/previous controlled-behavior predicate: p.x = 2 or (p.x = 3 or r.loc1)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: p.x = 2 or (p.x = 3 or r.loc1) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out index fb9176b78eadc49ff70c5f251be27e7f726b8d68..7a920268e78eeab2c38568392e59864ed87a6462 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out @@ -201,12 +201,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: r.loc1 [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: r.loc1 -> p.x = 2 or (p.x = 3 or r.loc1) [backward reach with edge: (event: r.trace) (guard: (p.x = 2 or p.x = 3) and r.loc2) (assignments: r := r.loc1), restricted to current/previous controlled-behavior predicate: p.x = 2 or (p.x = 3 or r.loc1)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.x = 2 or (p.x = 3 or r.loc1) [fixed point]. Controlled behavior not changed. @@ -214,12 +208,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.x = 0 or p.x = 1) and r.loc2 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.x = 0 or p.x = 1) and r.loc2 -> p.x = 0 or p.x = 1 [backward reach with edge: (event: r.trace) (guard: r.loc1) (assignments: r := r.loc2)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: p.x = 0 or p.x = 1 [fixed point]. Controlled behavior: p.x = 2 or (p.x = 3 or r.loc1) -> p.x = 2 or p.x = 3. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out index beb5692706232b4e5bfca99f95ea128928db8085..0b77aa1f3a8977724efebfec3e7688a674ae3587 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out @@ -229,13 +229,6 @@ Synthesis round 1: Backward controlled-behavior: r2.l2 and r1.l2 [marker predicate] Backward controlled-behavior: r2.l2 and r1.l2 -> not(r1.x = 2 or r1.x = 3) and not(r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2) or not(r1.x = 2 or r1.x = 3) and (r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2) or ((r1.x = 2 or r1.x = 3) and not(r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2) or (r1.x = 2 or r1.x = 3) and (r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2)) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not(r1.x = 2 or r1.x = 3) and not(r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2) or not(r1.x = 2 or r1.x = 3) and (r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2) or ((r1.x = 2 or r1.x = 3) and not(r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2) or (r1.x = 2 or r1.x = 3) and (r2.x = 2 or r2.x = 3) and (r2.l2 and r1.l2)) -> <bdd 17n 33p> [backward reach with edge: (event: p.e2) (guard: (r1.x = 0 or r1.x = 2) and (r2.x = 0 or r2.x = 2) and (r2.l1 and r1.l1) or (r1.x = 0 or r1.x = 2) and r2.x = 1 and (r2.l1 and r1.l1) or (r1.x = 1 and (r2.x = 0 or r2.x = 2) and (r2.l1 and r1.l1) or r1.x = 1 and r2.x = 1 and (r2.l1 and r1.l1))) (assignments: r1 := r1.l2, r2 := r2.l2), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: <bdd 17n 33p> -> <bdd 19n 33p> [backward reach with edge: (event: p.e2) (guard: (r1.x = 0 or r1.x = 2) and (r2.x = 0 or r2.x = 2) and (r2.l2 and r1.l1) or (r1.x = 0 or r1.x = 2) and (r2.x = 4 and r1.l1) or ((r1.x = 0 or r1.x = 2) and r2.x = 1 and (r2.l2 and r1.l1) or ((r1.x = 0 or r1.x = 2) and (r2.x = 5 and r1.l1) or (r1.x = 0 or r1.x = 2) and (r2.x = 3 and r1.l1))) or (r1.x = 1 and (r2.x = 0 or r2.x = 2) and (r2.l2 and r1.l1) or r1.x = 1 and (r2.x = 4 and r1.l1) or (r1.x = 1 and r2.x = 1 and (r2.l2 and r1.l1) or (r1.x = 1 and (r2.x = 5 and r1.l1) or r1.x = 1 and (r2.x = 3 and r1.l1))))) (assignments: r1 := r1.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 19n 33p> [fixed point]. Controlled behavior: true -> <bdd 19n 33p>. @@ -248,12 +241,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) -> r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) or r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2) [forward reach with edge: (event: p.e2) (guard: (r1.x = 0 or r1.x = 2) and (r2.x = 0 or r2.x = 2) and (r2.l1 and r1.l1) or (r1.x = 0 or r1.x = 2) and r2.x = 1 and (r2.l1 and r1.l1) or (r1.x = 1 and (r2.x = 0 or r2.x = 2) and (r2.l1 and r1.l1) or r1.x = 1 and r2.x = 1 and (r2.l1 and r1.l1))) (assignments: r1 := r1.l2, r2 := r2.l2), restricted to current/previous controlled-behavior predicate: <bdd 19n 33p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) or r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2) [fixed point]. Controlled behavior: <bdd 19n 33p> -> r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) or r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2). @@ -265,12 +252,6 @@ Synthesis round 2: Backward controlled-behavior: r2.l2 and r1.l2 [marker predicate] Backward controlled-behavior: r2.l2 and r1.l2 -> r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2) [restricted to current/previous controlled-behavior predicate: r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) or r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2)] - Backward reachability iteration 1: - Backward controlled-behavior: r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2) -> r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) or r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2) [backward reach with edge: (event: p.e2) (guard: (r1.x = 0 or r1.x = 2) and (r2.x = 0 or r2.x = 2) and (r2.l1 and r1.l1) or (r1.x = 0 or r1.x = 2) and r2.x = 1 and (r2.l1 and r1.l1) or (r1.x = 1 and (r2.x = 0 or r2.x = 2) and (r2.l1 and r1.l1) or r1.x = 1 and r2.x = 1 and (r2.l1 and r1.l1))) (assignments: r1 := r1.l2, r2 := r2.l2), restricted to current/previous controlled-behavior predicate: r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) or r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2)] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: r1.x = 0 and r2.x = 0 and (r2.l1 and r1.l1) or r1.x = 0 and r2.x = 0 and (r2.l2 and r1.l2) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out index e6eb1cff9c557a153d450bff1ce5d1f97e60e5d4..9f43ce52db61f152c7cae76c4c9189d0880f5c06 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out @@ -191,9 +191,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -206,13 +203,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: g.p.x = 2 and p.x = 1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: g.p.x = 2 and p.x = 1 -> g.p.x != 4 and p.x = 1 [forward reach with edge: (event: c1) (guard: true -> true) (assignments: g.p.x := g.p.x + 1, p.x := 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: g.p.x != 4 and p.x = 1 -> g.p.x = 4 and p.x = 1 or (g.p.x = 2 and p.x = 1 or g.p.x = 3 and p.x = 1) [forward reach with edge: (event: g.c2) (guard: true -> true) (assignments: g.p.x := g.p.x + 1, p.x := 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: g.p.x = 4 and p.x = 1 or (g.p.x = 2 and p.x = 1 or g.p.x = 3 and p.x = 1) [fixed point]. Controlled behavior: true -> g.p.x = 4 and p.x = 1 or (g.p.x = 2 and p.x = 1 or g.p.x = 3 and p.x = 1). @@ -224,9 +214,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> g.p.x = 4 and p.x = 1 or (g.p.x = 2 and p.x = 1 or g.p.x = 3 and p.x = 1) [restricted to current/previous controlled-behavior predicate: g.p.x = 4 and p.x = 1 or (g.p.x = 2 and p.x = 1 or g.p.x = 3 and p.x = 1)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: g.p.x = 4 and p.x = 1 or (g.p.x = 2 and p.x = 1 or g.p.x = 3 and p.x = 1) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out index 98e337ea5581848e9f69f41dd904eff0004b0aea..371a760f2ed5a4fe0a40caf4c81f61f4b6166836 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out @@ -205,24 +205,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: 0 <= p.x and (p.x <= 7 and p.m5) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: 0 <= p.x and (p.x <= 7 and p.m5) -> (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and (p.m4 or p.m5) or (p.x = 1 or p.x = 5) and (p.m4 or p.m5) or (p.x = 3 and (p.m4 or p.m5) or p.x = 7 and p.m5) [backward reach with edge: (event: u1) (guard: p.m4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m4 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m4 or (p.x = 3 and p.m4 or p.x = 7 and p.m4)) (assignments: p.x := p.x + 1, p := p.m5), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: (p.x = 0 or p.x = 2 or (p.x = 4 or p.x = 6)) and (p.m4 or p.m5) or (p.x = 1 or p.x = 5) and (p.m4 or p.m5) or (p.x = 3 and (p.m4 or p.m5) or p.x = 7 and p.m5) -> (p.x = 0 or p.x = 4) and p.m4 or ((p.x = 0 or p.x = 4) and p.m5 or (p.x = 0 or p.x = 4) and p.m3) or (p.x = 2 and p.m4 or p.x = 2 and p.m5 or (p.x = 2 and p.m3 or p.x = 6 and (p.m4 or p.m5))) or ((p.x = 1 or p.x = 5) and p.m4 or ((p.x = 1 or p.x = 5) and p.m5 or (p.x = 1 or p.x = 5) and p.m3) or (p.x = 3 and p.m4 or p.x = 3 and p.m5 or (p.x = 3 and p.m3 or p.x = 7 and p.m5))) [backward reach with edge: (event: u1) (guard: p.m3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m3 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m3 or (p.x = 3 and p.m3 or p.x = 7 and p.m3)) (assignments: p.x := p.x + 1, p := p.m4), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: (p.x = 0 or p.x = 4) and p.m4 or ((p.x = 0 or p.x = 4) and p.m5 or (p.x = 0 or p.x = 4) and p.m3) or (p.x = 2 and p.m4 or p.x = 2 and p.m5 or (p.x = 2 and p.m3 or p.x = 6 and (p.m4 or p.m5))) or ((p.x = 1 or p.x = 5) and p.m4 or ((p.x = 1 or p.x = 5) and p.m5 or (p.x = 1 or p.x = 5) and p.m3) or (p.x = 3 and p.m4 or p.x = 3 and p.m5 or (p.x = 3 and p.m3 or p.x = 7 and p.m5))) -> (p.x = 0 or p.x = 4) and (p.m4 or p.m5) or ((p.x = 0 or p.x = 4) and (p.m2 or p.m3) or p.x = 2 and (p.m4 or p.m5)) or (p.x = 2 and (p.m2 or p.m3) or (p.x = 6 and (p.m4 or p.m5) or p.x = 1 and (p.m4 or p.m5))) or (p.x = 1 and (p.m2 or p.m3) or (p.x = 5 and p.m4 or p.x = 5 and p.m5) or (p.x = 5 and p.m3 or p.x = 3 and (p.m4 or p.m5) or (p.x = 3 and (p.m2 or p.m3) or p.x = 7 and p.m5))) [backward reach with edge: (event: u1) (guard: p.m2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m2 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m2 or (p.x = 3 and p.m2 or p.x = 7 and p.m2)) (assignments: p.x := p.x + 1, p := p.m3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: (p.x = 0 or p.x = 4) and (p.m4 or p.m5) or ((p.x = 0 or p.x = 4) and (p.m2 or p.m3) or p.x = 2 and (p.m4 or p.m5)) or (p.x = 2 and (p.m2 or p.m3) or (p.x = 6 and (p.m4 or p.m5) or p.x = 1 and (p.m4 or p.m5))) or (p.x = 1 and (p.m2 or p.m3) or (p.x = 5 and p.m4 or p.x = 5 and p.m5) or (p.x = 5 and p.m3 or p.x = 3 and (p.m4 or p.m5) or (p.x = 3 and (p.m2 or p.m3) or p.x = 7 and p.m5))) -> <bdd 20n 23p> [backward reach with edge: (event: u2) (guard: p.m1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m1 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m1 or (p.x = 3 and p.m1 or p.x = 7 and p.m1)) (assignments: p.x := p.x + 1, p := p.m2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 20n 23p> -> p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3)))) [backward reach with edge: (event: c1) (guard: p.m0) (assignments: p := p.m1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 6: - No change this iteration. - Backward controlled-behavior: p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3)))) [fixed point]. Controlled behavior: true -> p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3)))). @@ -230,24 +212,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 19n 23p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 3 and p.m0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 3 and p.m0 -> p.x = 3 and (p.m0 or p.m1) [forward reach with edge: (event: c1) (guard: p.m0) (assignments: p := p.m1), restricted to current/previous controlled-behavior predicate: p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3))))] - Forward controlled-behavior: p.x = 3 and (p.m0 or p.m1) -> p.x = 4 and p.m2 or p.x = 3 and (p.m0 or p.m1) [forward reach with edge: (event: u2) (guard: p.m1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m1 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m1 or (p.x = 3 and p.m1 or p.x = 7 and p.m1)) (assignments: p.x := p.x + 1, p := p.m2), restricted to current/previous controlled-behavior predicate: p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3))))] - Forward controlled-behavior: p.x = 4 and p.m2 or p.x = 3 and (p.m0 or p.m1) -> p.x = 4 and p.m2 or (p.x = 5 and p.m3 or p.x = 3 and (p.m0 or p.m1)) [forward reach with edge: (event: u1) (guard: p.m2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m2 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m2 or (p.x = 3 and p.m2 or p.x = 7 and p.m2)) (assignments: p.x := p.x + 1, p := p.m3), restricted to current/previous controlled-behavior predicate: p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3))))] - Forward controlled-behavior: p.x = 4 and p.m2 or (p.x = 5 and p.m3 or p.x = 3 and (p.m0 or p.m1)) -> p.x = 4 and p.m2 or p.x = 6 and p.m4 or (p.x = 5 and p.m3 or p.x = 3 and (p.m0 or p.m1)) [forward reach with edge: (event: u1) (guard: p.m3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m3 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m3 or (p.x = 3 and p.m3 or p.x = 7 and p.m3)) (assignments: p.x := p.x + 1, p := p.m4), restricted to current/previous controlled-behavior predicate: p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3))))] - Forward controlled-behavior: p.x = 4 and p.m2 or p.x = 6 and p.m4 or (p.x = 5 and p.m3 or p.x = 3 and (p.m0 or p.m1)) -> <bdd 21n 5p> [forward reach with edge: (event: u1) (guard: p.m4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m4 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m4 or (p.x = 3 and p.m4 or p.x = 7 and p.m4)) (assignments: p.x := p.x + 1, p := p.m5), restricted to current/previous controlled-behavior predicate: p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3))))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 21n 5p> [fixed point]. Controlled behavior: p.x != 8 and (p.x != 4 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m0 and not p.m1) and ((p.x != 6 or not p.m2 and not p.m3) and p.x != 9)) and ((p.x != 5 or not p.m0) and ((p.x != 5 or not p.m2) and (p.x != 5 or not p.m1)) and ((p.x != 7 or p.m1 or (p.m3 or p.m5)) and ((p.x != 7 or not p.m1) and (p.x != 7 or not p.m3)))) -> <bdd 21n 5p>. @@ -259,24 +228,6 @@ Synthesis round 2: Backward controlled-behavior: 0 <= p.x and (p.x <= 7 and p.m5) [marker predicate] Backward controlled-behavior: 0 <= p.x and (p.x <= 7 and p.m5) -> p.x = 7 and p.m5 [restricted to current/previous controlled-behavior predicate: <bdd 21n 5p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 7 and p.m5 -> p.x = 6 and p.m4 or p.x = 7 and p.m5 [backward reach with edge: (event: u1) (guard: p.m4 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m4 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m4 or (p.x = 3 and p.m4 or p.x = 7 and p.m4)) (assignments: p.x := p.x + 1, p := p.m5), restricted to current/previous controlled-behavior predicate: <bdd 21n 5p>] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 6 and p.m4 or p.x = 7 and p.m5 -> p.x = 6 and p.m4 or (p.x = 5 and p.m3 or p.x = 7 and p.m5) [backward reach with edge: (event: u1) (guard: p.m3 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m3 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m3 or (p.x = 3 and p.m3 or p.x = 7 and p.m3)) (assignments: p.x := p.x + 1, p := p.m4), restricted to current/previous controlled-behavior predicate: <bdd 21n 5p>] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 6 and p.m4 or (p.x = 5 and p.m3 or p.x = 7 and p.m5) -> p.x = 4 and p.m2 or p.x = 6 and p.m4 or (p.x = 5 and p.m3 or p.x = 7 and p.m5) [backward reach with edge: (event: u1) (guard: p.m2 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m2 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m2 or (p.x = 3 and p.m2 or p.x = 7 and p.m2)) (assignments: p.x := p.x + 1, p := p.m3), restricted to current/previous controlled-behavior predicate: <bdd 21n 5p>] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 4 and p.m2 or p.x = 6 and p.m4 or (p.x = 5 and p.m3 or p.x = 7 and p.m5) -> <bdd 22n 5p> [backward reach with edge: (event: u2) (guard: p.m1 -> (p.x = 0 or p.x = 2 or (p.x = 4 or (p.x = 6 or p.x = 8))) and p.m1 or (p.x = 1 or (p.x = 5 or p.x = 9)) and p.m1 or (p.x = 3 and p.m1 or p.x = 7 and p.m1)) (assignments: p.x := p.x + 1, p := p.m2), restricted to current/previous controlled-behavior predicate: <bdd 21n 5p>] - - Backward reachability iteration 5: - Backward controlled-behavior: <bdd 22n 5p> -> <bdd 21n 5p> [backward reach with edge: (event: c1) (guard: p.m0) (assignments: p := p.m1), restricted to current/previous controlled-behavior predicate: <bdd 21n 5p>] - - Backward reachability iteration 6: - No change this iteration. - Backward controlled-behavior: <bdd 21n 5p> [fixed point]. Controlled behavior not changed. @@ -284,9 +235,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 21n 22p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out index 03cf5baa9ba1b5ff57b03b93b68065b422a5c9aa..8d6bbdc0134c9825858dcba22d0ea9de1a920008 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out @@ -194,13 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p2.a and p1.a [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p2.a and p1.a -> (p2.b or p1.x = 0 or (p1.x = 1 or p1.a)) and p2.a [backward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p2.b or p1.x = 0 or (p1.x = 1 or p1.a)) and p2.a -> (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))) [backward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))) [fixed point]. Controlled behavior: true -> (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))). @@ -208,29 +201,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p2.x = 0 or p2.x = 1) and ((p1.x = 2 or p1.x = 3) and p1.b) or ((p2.x = 2 or p2.x = 3) and p2.a and ((p1.x = 2 or p1.x = 3) and p1.b) or (p2.x = 2 or p2.x = 3) and p2.b) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p2.x = 0 and p2.a and (p1.x = 0 and p1.a) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p2.x = 0 and p2.a and (p1.x = 0 and p1.a) -> p2.x = 0 and (p2.a and p1.x = 0) [forward reach with edge: (event: c1) (guard: p1.a) (assignments: p1 := p1.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and (p2.a and p1.x = 0) -> p2.x = 0 and (p2.a and p1.x = 0) or p2.x = 0 and p2.a and (p1.x = 1 and p1.a) [forward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and (p2.a and p1.x = 0) or p2.x = 0 and p2.a and (p1.x = 1 and p1.a) -> p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) [forward reach with edge: (event: c2) (guard: p2.a) (assignments: p2 := p2.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) -> p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) or (p2.x = 1 and (p2.a and p1.x = 0) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) [forward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - - Forward reachability iteration 2: - Forward controlled-behavior: p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) or (p2.x = 1 and (p2.a and p1.x = 0) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) -> p2.x = 0 and (p1.x = 0 or p1.x = 1) or p2.x = 1 and (p2.a and (p1.x = 0 or p1.x = 1)) [forward reach with edge: (event: c1) (guard: p1.a) (assignments: p1 := p1.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and (p1.x = 0 or p1.x = 1) or p2.x = 1 and (p2.a and (p1.x = 0 or p1.x = 1)) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and ((p2.x != 0 or p1.x != 3) and p2.x != 2) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) [forward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: (p2.x != 0 or (p1.x != 2 or p1.a)) and ((p2.x != 0 or p1.x != 3) and p2.x != 2) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) -> (p2.x = 2 or p2.x = 3 or (p1.x != 2 or p1.a)) and ((p2.x = 2 or (p2.x = 3 or p1.x != 3)) and (p2.x = 0 or p2.x = 1)) [forward reach with edge: (event: c2) (guard: p2.a) (assignments: p2 := p2.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: (p2.x = 2 or p2.x = 3 or (p1.x != 2 or p1.a)) and ((p2.x = 2 or (p2.x = 3 or p1.x != 3)) and (p2.x = 0 or p2.x = 1)) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [forward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [fixed point]. Controlled behavior: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)). @@ -242,13 +217,6 @@ Synthesis round 2: Backward controlled-behavior: p2.a and p1.a [marker predicate] Backward controlled-behavior: p2.a and p1.a -> (p2.x = 0 or p2.x = 2) and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or (p2.x = 0 or p2.x = 2) and p2.a and (p1.x = 1 and p1.a) or (p2.x = 1 and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) [restricted to current/previous controlled-behavior predicate: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3))] - Backward reachability iteration 1: - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or (p2.x = 0 or p2.x = 2) and p2.a and (p1.x = 1 and p1.a) or (p2.x = 1 and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) -> (p2.x = 1 or p2.x = 3 or (p2.b or (p1.x != 2 or p1.a))) and ((p2.x = 1 or p2.x = 3 or (p2.b or p1.x != 3)) and (p2.x = 1 or (p2.x = 3 or p2.a))) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) [backward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3))] - Backward controlled-behavior: (p2.x = 1 or p2.x = 3 or (p2.b or (p1.x != 2 or p1.a))) and ((p2.x = 1 or p2.x = 3 or (p2.b or p1.x != 3)) and (p2.x = 1 or (p2.x = 3 or p2.a))) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [backward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [fixed point]. Controlled behavior not changed. @@ -256,9 +224,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p2.x = 0 and (p1.x = 2 and p1.b) or p2.x = 0 and p1.x = 3 or (p2.x = 2 and p2.a and (p1.x = 2 and p1.b) or p2.x = 2 and (p2.a and p1.x = 3)) or (p2.x = 2 and p2.b or p2.x = 1 and (p1.x = 2 and p1.b) or (p2.x = 1 and p1.x = 3 or p2.x = 3)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out index 2e7cea838cfb8ff6cdbe456130580450584ee53b..23df4247e70bceca906fff21662f4510ff948c23 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out @@ -194,13 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p2.a and p1.a [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p2.a and p1.a -> (p2.b or p1.x = 0 or (p1.x = 1 or p1.a)) and p2.a [backward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: (p2.b or p1.x = 0 or (p1.x = 1 or p1.a)) and p2.a -> (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))) [backward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))) [fixed point]. Controlled behavior: true -> (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))). @@ -208,29 +201,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p2.x = 0 or p2.x = 1) and ((p1.x = 2 or p1.x = 3) and p1.b) or ((p2.x = 2 or p2.x = 3) and p2.a and ((p1.x = 2 or p1.x = 3) and p1.b) or (p2.x = 2 or p2.x = 3) and p2.b) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p2.x = 0 and p2.a and (p1.x = 0 and p1.a) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p2.x = 0 and p2.a and (p1.x = 0 and p1.a) -> p2.x = 0 and (p2.a and p1.x = 0) [forward reach with edge: (event: c1) (guard: p1.a) (assignments: p1 := p1.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and (p2.a and p1.x = 0) -> p2.x = 0 and (p2.a and p1.x = 0) or p2.x = 0 and p2.a and (p1.x = 1 and p1.a) [forward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and (p2.a and p1.x = 0) or p2.x = 0 and p2.a and (p1.x = 1 and p1.a) -> p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) [forward reach with edge: (event: c2) (guard: p2.a) (assignments: p2 := p2.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) -> p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) or (p2.x = 1 and (p2.a and p1.x = 0) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) [forward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - - Forward reachability iteration 2: - Forward controlled-behavior: p2.x = 0 and p1.x = 0 or p2.x = 0 and (p1.x = 1 and p1.a) or (p2.x = 1 and (p2.a and p1.x = 0) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) -> p2.x = 0 and (p1.x = 0 or p1.x = 1) or p2.x = 1 and (p2.a and (p1.x = 0 or p1.x = 1)) [forward reach with edge: (event: c1) (guard: p1.a) (assignments: p1 := p1.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: p2.x = 0 and (p1.x = 0 or p1.x = 1) or p2.x = 1 and (p2.a and (p1.x = 0 or p1.x = 1)) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and ((p2.x != 0 or p1.x != 3) and p2.x != 2) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) [forward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: (p2.x != 0 or (p1.x != 2 or p1.a)) and ((p2.x != 0 or p1.x != 3) and p2.x != 2) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) -> (p2.x = 2 or p2.x = 3 or (p1.x != 2 or p1.a)) and ((p2.x = 2 or (p2.x = 3 or p1.x != 3)) and (p2.x = 0 or p2.x = 1)) [forward reach with edge: (event: c2) (guard: p2.a) (assignments: p2 := p2.b), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - Forward controlled-behavior: (p2.x = 2 or p2.x = 3 or (p1.x != 2 or p1.a)) and ((p2.x = 2 or (p2.x = 3 or p1.x != 3)) and (p2.x = 0 or p2.x = 1)) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [forward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a)))] - - Forward reachability iteration 3: - No change this iteration. - Forward controlled-behavior: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [fixed point]. Controlled behavior: (p2.x = 2 or p2.x = 3 or (p1.x = 0 or (p1.x = 1 or p1.a))) and ((p2.x = 0 or (p2.x = 1 or p2.b) or (p1.x = 0 or (p1.x = 1 or p1.a))) and (p2.x = 0 or (p2.x = 1 or p2.a))) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)). @@ -242,13 +217,6 @@ Synthesis round 2: Backward controlled-behavior: p2.a and p1.a [marker predicate] Backward controlled-behavior: p2.a and p1.a -> (p2.x = 0 or p2.x = 2) and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or (p2.x = 0 or p2.x = 2) and p2.a and (p1.x = 1 and p1.a) or (p2.x = 1 and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) [restricted to current/previous controlled-behavior predicate: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3))] - Backward reachability iteration 1: - Backward controlled-behavior: (p2.x = 0 or p2.x = 2) and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or (p2.x = 0 or p2.x = 2) and p2.a and (p1.x = 1 and p1.a) or (p2.x = 1 and p2.a and ((p1.x = 0 or p1.x = 2) and p1.a) or p2.x = 1 and p2.a and (p1.x = 1 and p1.a)) -> (p2.x = 1 or p2.x = 3 or (p2.b or (p1.x != 2 or p1.a))) and ((p2.x = 1 or p2.x = 3 or (p2.b or p1.x != 3)) and (p2.x = 1 or (p2.x = 3 or p2.a))) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) [backward reach with edge: (event: u1) (guard: (p1.x = 0 or p1.x = 1) and p1.b) (assignments: p1.x := p1.x + 1, p1 := p1.a), restricted to current/previous controlled-behavior predicate: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3))] - Backward controlled-behavior: (p2.x = 1 or p2.x = 3 or (p2.b or (p1.x != 2 or p1.a))) and ((p2.x = 1 or p2.x = 3 or (p2.b or p1.x != 3)) and (p2.x = 1 or (p2.x = 3 or p2.a))) and ((p2.x != 1 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 1 or (p2.b or p1.x != 3)) and ((p2.x != 1 or p2.a) and p2.x != 3)) -> (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [backward reach with edge: (event: u2) (guard: (p2.x = 0 or p2.x = 1) and p2.b) (assignments: p2.x := p2.x + 1, p2 := p2.a), restricted to current/previous controlled-behavior predicate: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: (p2.x != 0 or (p1.x != 2 or p1.a)) and (p2.x != 0 or p1.x != 3) and ((p2.x != 2 or p2.b or (p1.x != 2 or p1.a)) and (p2.x != 2 or (p2.b or p1.x != 3))) and ((p2.x != 2 or p2.a) and (p2.x != 1 or (p1.x != 2 or p1.a)) and ((p2.x != 1 or p1.x != 3) and p2.x != 3)) [fixed point]. Controlled behavior not changed. @@ -256,9 +224,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p2.x = 0 and (p1.x = 2 and p1.b) or p2.x = 0 and p1.x = 3 or (p2.x = 2 and p2.a and (p1.x = 2 and p1.b) or p2.x = 2 and (p2.a and p1.x = 3)) or (p2.x = 2 and p2.b or p2.x = 1 and (p1.x = 2 and p1.b) or (p2.x = 1 and p1.x = 3 or p2.x = 3)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_off.cif.out index 47835ee36600a177903653d753f7a3b07c7d170c..694253e1b543e7535580eca7ff9d256677de911a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_off.cif.out @@ -94,9 +94,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [fixed point]. Controlled behavior not changed. @@ -104,18 +101,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 8 and p.x != 6 and (p.x != 9 and (p.x != 5 and p.x != 7)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) [initialization predicate] Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Forward reachability iteration 1: - No change this iteration. - Forward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) -> p.x = 9 or (p.x = 5 or p.x = 7). @@ -127,9 +118,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x = 9 or (p.x = 5 or p.x = 7)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior not changed. @@ -137,9 +125,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 9 and (p.x != 5 and p.x != 7) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_on.cif.out index d51cb755bd152f62447625b39f9a53815f7a8f69..a429811c3fdd584750030a8787020fc4399e9304 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_plant_inv_on.cif.out @@ -94,9 +94,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [fixed point]. Controlled behavior not changed. @@ -104,18 +101,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 8 and p.x != 6 and (p.x != 9 and (p.x != 5 and p.x != 7)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) [initialization predicate] Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Forward reachability iteration 1: - No change this iteration. - Forward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) -> p.x = 9 or (p.x = 5 or p.x = 7). @@ -127,9 +118,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x = 9 or (p.x = 5 or p.x = 7)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior not changed. @@ -137,9 +125,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 9 and (p.x != 5 and p.x != 7) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_off.cif.out index 7ed40e11cf280e3d53515cb9992d3c0a1dae48d3..3876f7054a800248928658cf7cb57808eee17491 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_off.cif.out @@ -94,9 +94,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [fixed point]. Controlled behavior not changed. @@ -104,18 +101,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 8 and p.x != 6 and (p.x != 9 and (p.x != 5 and p.x != 7)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) [initialization predicate] Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Forward reachability iteration 1: - No change this iteration. - Forward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) -> p.x = 9 or (p.x = 5 or p.x = 7). @@ -127,9 +118,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x = 9 or (p.x = 5 or p.x = 7)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior not changed. @@ -137,9 +125,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 9 and (p.x != 5 and p.x != 7) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_on.cif.out index 4579c5155bf34504421178f5ad97408109e31469..cf60b052890744a7098bcdb30f0da9494872c70e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_initial_unctrl_on.cif.out @@ -94,9 +94,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) [fixed point]. Controlled behavior not changed. @@ -104,18 +101,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 8 and p.x != 6 and (p.x != 9 and (p.x != 5 and p.x != 7)) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) [initialization predicate] Forward controlled-behavior: p.x = 1 or p.x = 3 or (p.x = 5 or (p.x = 7 or p.x = 9)) -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3))] - Forward reachability iteration 1: - No change this iteration. - Forward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior: p.x != 0 and p.x != 4 and (p.x != 2 and (p.x != 1 and p.x != 3)) -> p.x = 9 or (p.x = 5 or p.x = 7). @@ -127,9 +118,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> p.x = 9 or (p.x = 5 or p.x = 7) [restricted to current/previous controlled-behavior predicate: p.x = 9 or (p.x = 5 or p.x = 7)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: p.x = 9 or (p.x = 5 or p.x = 7) [fixed point]. Controlled behavior not changed. @@ -137,9 +125,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: p.x != 9 and (p.x != 5 and p.x != 7) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_off.cif.out index a817d9520d4c2b08938bd9a3bef25c6dc622ca6b..78815c8b46441ad6d6d282cd9a3d7f8ac446ad4f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_off.cif.out @@ -104,9 +104,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -119,9 +116,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_on.cif.out index 4f225c80db58fd65e153d52a0de92cf51ecfd1c3..488c3ef84184e36b3d4882026ce4a1dbbdbf0d0d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_plants_on.cif.out @@ -104,9 +104,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -119,9 +116,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out index 396927b7c553b45e4e0d4b3fc823aa4d5da83552..3dbd166ad5efed94b3fabf27275f52ba0e09636c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out @@ -191,16 +191,6 @@ Synthesis round 1: Backward controlled-behavior: not p.loc3 and q.loc1 [marker predicate] Backward controlled-behavior: not p.loc3 and q.loc1 -> not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) -> not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_a) (guard: q.loc4) (assignments: q := q.loc1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) -> not p.loc3 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_b) (guard: q.loc3) (assignments: q := q.loc4), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: not p.loc3 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) -> not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [backward reach with edge: (event: q_a) (guard: q.loc2) (assignments: q := q.loc3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [fixed point]. Controlled behavior: true -> not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)). @@ -208,12 +198,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.loc3 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (p.loc3 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.loc3 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (p.loc3 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) -> (not p.loc1 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (not p.loc1 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) [backward reach with edge: (event: p_b) (guard: p.loc2) (assignments: p := p.loc3)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (not p.loc1 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (not p.loc1 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) [fixed point]. Controlled behavior: not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) -> p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)). @@ -221,14 +205,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) -> p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) or p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) [forward reach with edge: (event: q_a) (guard: q.loc1) (assignments: q := q.loc2), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) or p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) -> p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc2) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc2)) [forward reach with edge: (event: q_a) (guard: q.loc2) (assignments: q := q.loc3), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc2) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc2)) -> p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [forward reach with edge: (event: q_b) (guard: q.loc3) (assignments: q := q.loc4), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [fixed point]. Controlled behavior not changed. @@ -240,16 +216,6 @@ Synthesis round 2: Backward controlled-behavior: not p.loc3 and q.loc1 [marker predicate] Backward controlled-behavior: not p.loc3 and q.loc1 -> p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) [restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) -> p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_a) (guard: q.loc4) (assignments: q := q.loc1), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Backward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) -> p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_b) (guard: q.loc3) (assignments: q := q.loc4), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - - Backward reachability iteration 2: - Backward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) -> p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [backward reach with edge: (event: q_a) (guard: q.loc2) (assignments: q := q.loc3), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out index 740e64d3333a91a5ef2730bf1b4bfa6668cd54dc..3a0b861fee25add35e830bf7ae172bc050d37b8c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out @@ -191,16 +191,6 @@ Synthesis round 1: Backward controlled-behavior: not p.loc3 and q.loc1 [marker predicate] Backward controlled-behavior: not p.loc3 and q.loc1 -> not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) -> not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_a) (guard: q.loc4) (assignments: q := q.loc1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc1) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) -> not p.loc3 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_b) (guard: q.loc3) (assignments: q := q.loc4), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: not p.loc3 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and (not(p.x = 2 or p.x = 3) and q.loc4) or (not p.loc3 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or not p.loc3 and ((p.x = 2 or p.x = 3) and q.loc4)) -> not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [backward reach with edge: (event: q_a) (guard: q.loc2) (assignments: q := q.loc3), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [fixed point]. Controlled behavior: true -> not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)). @@ -208,12 +198,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (p.loc3 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (p.loc3 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: (p.loc3 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (p.loc3 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) -> (not p.loc1 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (not p.loc1 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) [backward reach with edge: (event: p_b) (guard: p.loc2) (assignments: p := p.loc3)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: (not p.loc1 or (p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) and (not p.loc1 or not(p.x = 2 or p.x = 3) or (q.loc5 or (q.loc6 or q.loc7))) [fixed point]. Controlled behavior: not p.loc3 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or not p.loc3 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) -> p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)). @@ -221,14 +205,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) -> p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) or p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) [forward reach with edge: (event: q_a) (guard: q.loc1) (assignments: q := q.loc2), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) or p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc2)) -> p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc2) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc2)) [forward reach with edge: (event: q_a) (guard: q.loc2) (assignments: q := q.loc3), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Forward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc2) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc2)) -> p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [forward reach with edge: (event: q_b) (guard: q.loc3) (assignments: q := q.loc4), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [fixed point]. Controlled behavior not changed. @@ -240,16 +216,6 @@ Synthesis round 2: Backward controlled-behavior: not p.loc3 and q.loc1 [marker predicate] Backward controlled-behavior: not p.loc3 and q.loc1 -> p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) [restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) -> p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_a) (guard: q.loc4) (assignments: q := q.loc1), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - Backward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and q.loc1) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) -> p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) [backward reach with edge: (event: q_b) (guard: q.loc3) (assignments: q := q.loc4), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - - Backward reachability iteration 2: - Backward controlled-behavior: p.loc1 and (not(p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and (not(p.x = 2 or p.x = 3) and q.loc4) or (p.loc1 and ((p.x = 2 or p.x = 3) and (q.loc1 or q.loc3)) or p.loc1 and ((p.x = 2 or p.x = 3) and q.loc4)) -> p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [backward reach with edge: (event: q_a) (guard: q.loc2) (assignments: q := q.loc3), restricted to current/previous controlled-behavior predicate: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7))] - - Backward reachability iteration 3: - No change this iteration. - Backward controlled-behavior: p.loc1 and not(p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) or p.loc1 and (p.x = 2 or p.x = 3) and (not q.loc5 and (not q.loc6 and not q.loc7)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_off.cif.out index 52d83aecd4778ad7e2165de960485ea507ba902a..7a2015716269a0b670efb3839c7f7d80bc42262c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_off.cif.out @@ -213,9 +213,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -228,24 +225,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: aut.v01 = 0 and aut.v02 = 0 and (aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: aut.v01 = 0 and aut.v02 = 0 and (aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2)) -> aut.v02 = 0 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v01_inc) (guard: true -> aut.v01 = 0) (assignments: aut.v01 := aut.v01 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 = 0 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) -> aut.v02 != 2 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v02_inc) (guard: true -> true) (assignments: aut.v02 := aut.v02 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 != 2 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) -> aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v03_inc) (guard: true -> aut.v03 != 3) (assignments: aut.v03 := aut.v03 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) -> aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 2 and aut.v23 = 2) or aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v13_inc) (guard: true -> aut.v13 != 3) (assignments: aut.v13 := aut.v13 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 2 and aut.v23 = 2) or aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) -> (aut.v02 = 2 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 2 or (aut.v03 = 0 or aut.v03 = 1)) and aut.v02 != 2) [forward reach with edge: (event: v23_inc) (guard: true -> aut.v23 = 2) (assignments: aut.v23 := aut.v23 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: (aut.v02 = 2 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 2 or (aut.v03 = 0 or aut.v03 = 1)) and aut.v02 != 2) -> (aut.v02 = 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 = 1 or (aut.v03 = 0 or aut.v03 = 1)) and ((aut.v02 != 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 != 1 or (aut.v03 = 0 or aut.v03 = 1))) [forward reach with edge: (event: v02_inc) (guard: true -> true) (assignments: aut.v02 := aut.v02 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (aut.v02 = 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 = 1 or (aut.v03 = 0 or aut.v03 = 1)) and ((aut.v02 != 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 != 1 or (aut.v03 = 0 or aut.v03 = 1))) -> (aut.v02 = 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 = 1 or aut.v03 != 3)) and ((aut.v02 != 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 != 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 != 1 or aut.v03 != 3))) [forward reach with edge: (event: v03_inc) (guard: true -> aut.v03 != 3) (assignments: aut.v03 := aut.v03 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (aut.v02 = 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 = 1 or aut.v03 != 3)) and ((aut.v02 != 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 != 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 != 1 or aut.v03 != 3))) -> (aut.v02 = 1 or aut.v03 != 3) and (aut.v02 != 1 or aut.v03 != 3) [forward reach with edge: (event: v13_inc) (guard: true -> aut.v13 != 3) (assignments: aut.v13 := aut.v13 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: (aut.v02 = 1 or aut.v03 != 3) and (aut.v02 != 1 or aut.v03 != 3) -> true [forward reach with edge: (event: v03_inc) (guard: true -> aut.v03 != 3) (assignments: aut.v03 := aut.v03 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_on.cif.out index bdef8db923cb553758285324fb44b473d76016bd..765fcd572ae67c0bc4003062db22f585c6c636bb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_range_invs_on.cif.out @@ -213,9 +213,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -228,24 +225,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: aut.v01 = 0 and aut.v02 = 0 and (aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: aut.v01 = 0 and aut.v02 = 0 and (aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2)) -> aut.v02 = 0 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v01_inc) (guard: true -> aut.v01 = 0) (assignments: aut.v01 := aut.v01 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 = 0 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) -> aut.v02 != 2 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v02_inc) (guard: true -> true) (assignments: aut.v02 := aut.v02 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 != 2 and aut.v03 = 0 and (aut.v13 = 1 and aut.v23 = 2) -> aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v03_inc) (guard: true -> aut.v03 != 3) (assignments: aut.v03 := aut.v03 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) -> aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 2 and aut.v23 = 2) or aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) [forward reach with edge: (event: v13_inc) (guard: true -> aut.v13 != 3) (assignments: aut.v13 := aut.v13 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 2 and aut.v23 = 2) or aut.v02 != 2 and (aut.v03 = 0 or aut.v03 = 1) and (aut.v13 = 1 and aut.v23 = 2) -> (aut.v02 = 2 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 2 or (aut.v03 = 0 or aut.v03 = 1)) and aut.v02 != 2) [forward reach with edge: (event: v23_inc) (guard: true -> aut.v23 = 2) (assignments: aut.v23 := aut.v23 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: (aut.v02 = 2 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 2 or (aut.v03 = 0 or aut.v03 = 1)) and aut.v02 != 2) -> (aut.v02 = 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 = 1 or (aut.v03 = 0 or aut.v03 = 1)) and ((aut.v02 != 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 != 1 or (aut.v03 = 0 or aut.v03 = 1))) [forward reach with edge: (event: v02_inc) (guard: true -> true) (assignments: aut.v02 := aut.v02 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (aut.v02 = 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 = 1 or (aut.v03 = 0 or aut.v03 = 1)) and ((aut.v02 != 1 or aut.v03 = 2 or (aut.v03 = 3 or aut.v13 != 3)) and (aut.v02 != 1 or (aut.v03 = 0 or aut.v03 = 1))) -> (aut.v02 = 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 = 1 or aut.v03 != 3)) and ((aut.v02 != 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 != 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 != 1 or aut.v03 != 3))) [forward reach with edge: (event: v03_inc) (guard: true -> aut.v03 != 3) (assignments: aut.v03 := aut.v03 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (aut.v02 = 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 = 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 = 1 or aut.v03 != 3)) and ((aut.v02 != 1 or aut.v03 = 1 or (aut.v03 = 3 or aut.v13 != 3)) and ((aut.v02 != 1 or (aut.v03 != 1 or aut.v13 != 3)) and (aut.v02 != 1 or aut.v03 != 3))) -> (aut.v02 = 1 or aut.v03 != 3) and (aut.v02 != 1 or aut.v03 != 3) [forward reach with edge: (event: v13_inc) (guard: true -> aut.v13 != 3) (assignments: aut.v13 := aut.v13 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: (aut.v02 = 1 or aut.v03 != 3) and (aut.v02 != 1 or aut.v03 != 3) -> true [forward reach with edge: (event: v03_inc) (guard: true -> aut.v03 != 3) (assignments: aut.v03 := aut.v03 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_off.cif.out index c32a8750c16d9f2995ce36eb22a5abb6b8dbfcd3..3240848044e1d978078d1c08c5dabbf10e16cde8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_off.cif.out @@ -104,9 +104,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -119,9 +116,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_on.cif.out index 8893f8711860a70629eadda7be5a6dcf91e6d32b..a96bf0559847f8b6ebe6f8a7aa4a8f821a34471a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_req_auts_on.cif.out @@ -104,9 +104,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -119,9 +116,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_off.cif.out index e36299110e7863de6bbfca376ad9c3c5a53fbe4c..25f2deb4bfde97c0a0aaae852496f65b2f5374ac 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_off.cif.out @@ -111,9 +111,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -126,9 +123,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_on.cif.out index 944da778ba01969ca896ca307f53d39b8a1504ce..d273655144c7fa531f446c4aa42deb5d03207f08 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_plant_invs_on.cif.out @@ -111,9 +111,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -126,9 +123,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_off.cif.out index 838118fbf1113613b9e17d25dcf62bf7e448f3ff..b5cf00a0f67e9db5c7bbd317547cdf194c80bf37 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_off.cif.out @@ -111,9 +111,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -126,9 +123,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_on.cif.out index 904eaaa6e613a06109e5f1012cf2723fcfa99fb2..190d563c702f6a1588a5763f910f7df9dd1904ec 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_se_excl_req_invs_on.cif.out @@ -111,9 +111,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -126,9 +123,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out index 1cb2042379cb9b05f5453be4aa65edce9a2340ad..187afcb0f6252de1dc74c8f9ebdc920903d5d05f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out @@ -185,12 +185,6 @@ Synthesis round 1: Backward controlled-behavior: p.loc1 [marker predicate] Backward controlled-behavior: p.loc1 -> p.loc1 [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 -> true [backward reach with edge: (event: e) (guard: p.loc2) (assignments: p := p.loc1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -203,12 +197,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [forward reach with edge: (event: e) (guard: p.loc1 -> p.loc1 and (p.x = 4 or p.x = 5)) (assignments: p := p.loc2), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior: true -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)). @@ -220,12 +208,6 @@ Synthesis round 2: Backward controlled-behavior: p.loc1 [marker predicate] Backward controlled-behavior: p.loc1 -> p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [backward reach with edge: (event: e) (guard: p.loc2) (assignments: p := p.loc1), restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out index 79972bb067c07325da06a325542b66cc669f9b4a..4f8288813cda37e68eb0fc838c431c555fcf92b3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out @@ -185,12 +185,6 @@ Synthesis round 1: Backward controlled-behavior: p.loc1 [marker predicate] Backward controlled-behavior: p.loc1 -> p.loc1 [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 -> true [backward reach with edge: (event: e) (guard: p.loc2) (assignments: p := p.loc1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -203,12 +197,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [forward reach with edge: (event: e) (guard: p.loc1 -> p.loc1 and (p.x = 4 or p.x = 5)) (assignments: p := p.loc2), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior: true -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)). @@ -220,12 +208,6 @@ Synthesis round 2: Backward controlled-behavior: p.loc1 [marker predicate] Backward controlled-behavior: p.loc1 -> p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [backward reach with edge: (event: e) (guard: p.loc2) (assignments: p := p.loc1), restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out index 0974540a6e6d5d47bd326bbd6df2994638378120..42e69326ff21ec8d2bbe1fbab258b0cdad0a5431 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out @@ -180,12 +180,6 @@ Synthesis round 1: Backward controlled-behavior: p.loc1 [marker predicate] Backward controlled-behavior: p.loc1 -> p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [backward reach with edge: (event: e) (guard: p.loc2) (assignments: p := p.loc1), restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior not changed. @@ -199,12 +193,6 @@ Synthesis round 1: Forward controlled-behavior: p.loc1 [initialization predicate] Forward controlled-behavior: p.loc1 -> p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - Forward reachability iteration 1: - Forward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [forward reach with edge: (event: e) (guard: p.loc1) (assignments: p := p.loc2), restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out index f15f1e85a7e69c10e6694f527e58cf8cf3f87c2e..658ed42cadfb01d47da40eee92ef977bc9bda54b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out @@ -180,12 +180,6 @@ Synthesis round 1: Backward controlled-behavior: p.loc1 [marker predicate] Backward controlled-behavior: p.loc1 -> p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - Backward reachability iteration 1: - Backward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [backward reach with edge: (event: e) (guard: p.loc2) (assignments: p := p.loc1), restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior not changed. @@ -199,12 +193,6 @@ Synthesis round 1: Forward controlled-behavior: p.loc1 [initialization predicate] Forward controlled-behavior: p.loc1 -> p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) [restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - Forward reachability iteration 1: - Forward controlled-behavior: p.loc1 and p.x = 4 or (p.loc1 and p.x = 5 or p.loc1 and p.x = 3) -> p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [forward reach with edge: (event: e) (guard: p.loc1) (assignments: p := p.loc2), restricted to current/previous controlled-behavior predicate: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: p.loc1 and p.x = 4 or p.loc1 and p.x = 5 or (p.loc1 and p.x = 3 or p.loc2 and (p.x = 4 or p.x = 5)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_plant_not_alphabet.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_plant_not_alphabet.cif.out index 09a03d764f7dc5ba3947e788b3e0cb6bef8c2935..a963489b32e5ef3d1491ac1bb29d35601a26aac2 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_plant_not_alphabet.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_plant_not_alphabet.cif.out @@ -92,9 +92,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -105,18 +102,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 -> p.x = 0 or p.x = 1 [forward reach with edge: (event: p.inc) (guard: true -> p.x != 3) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 0 or p.x = 1 -> p.x != 3 [forward reach with edge: (event: p.inc) (guard: true -> p.x != 3) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: p.x != 3 -> true [forward reach with edge: (event: p.inc) (guard: true -> p.x != 3) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_req_not_alphabet.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_req_not_alphabet.cif.out index a039a83db823cc6a30938afe68d621335e298234..a7e11bfc6ac8d9c7966a3b6a1f7973a4c9b5acef 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_req_not_alphabet.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_evt_excl_req_not_alphabet.cif.out @@ -92,9 +92,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -105,18 +102,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 -> p.x = 0 or p.x = 1 [forward reach with edge: (event: p.inc) (guard: true -> p.x != 3) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 0 or p.x = 1 -> p.x != 3 [forward reach with edge: (event: p.inc) (guard: true -> p.x != 3) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: p.x != 3 -> true [forward reach with edge: (event: p.inc) (guard: true -> p.x != 3) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: true [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_ctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_ctrl.cif.out index bbb12721f35a7e0b890ed8fdc3850df341c1ca09..eb776077b505e86a838213cfbf221750ece4d7e0 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_ctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_ctrl.cif.out @@ -207,9 +207,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -222,33 +219,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: A.Vc1 = 0 and A.Vc2 = 0 and (A.Vc3 = 0 and A.Vc4 = 0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: A.Vc1 = 0 and A.Vc2 = 0 and (A.Vc3 = 0 and A.Vc4 = 0) -> (A.Vc1 = 0 or A.Vc1 = 1) and A.Vc2 = 0 and (A.Vc3 = 0 and A.Vc4 = 0) [forward reach with edge: (event: c1) (guard: A.Vc1 != 4 -> A.Vc1 != 4) (assignments: A.Vc1 := A.Vc1 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 1) and A.Vc2 = 0 and (A.Vc3 = 0 and A.Vc4 = 0) -> (A.Vc1 = 0 or A.Vc1 = 1) and (A.Vc2 = 0 or A.Vc2 = 1) and (A.Vc3 = 0 and A.Vc4 = 0) [forward reach with edge: (event: c2) (guard: true -> (1 <= A.Vc2 and A.Vc2 <= 3 or (A.Vc2 = 5 or A.Vc3 != 4)) and A.Vc2 != 2 and ((A.Vc2 = 0 or (2 <= A.Vc2 and A.Vc2 <= 4 or A.Vc3 != 4)) and (A.Vc2 != 3 or A.Vc3 != 4))) (assignments: A.Vc2 := A.Vc2 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 1) and (A.Vc2 = 0 or A.Vc2 = 1) and (A.Vc3 = 0 and A.Vc4 = 0) -> (A.Vc1 = 0 or A.Vc1 = 1) and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and A.Vc4 = 0) [forward reach with edge: (event: c3) (guard: true -> (A.Vc2 = 1 or A.Vc2 = 3 or (A.Vc2 = 5 or A.Vc3 != 3)) and ((A.Vc2 = 0 or (2 <= A.Vc2 and A.Vc2 <= 4 or A.Vc3 != 3)) and A.Vc2 != 3)) (assignments: A.Vc3 := A.Vc3 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 1) and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and A.Vc4 = 0) -> (A.Vc1 = 0 or A.Vc1 = 1) and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) [forward reach with edge: (event: c4) (guard: true -> true) (assignments: A.Vc4 := A.Vc4 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 1) and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) -> (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) [forward reach with edge: (event: c1) (guard: A.Vc1 != 4 -> A.Vc1 != 4) (assignments: A.Vc1 := A.Vc1 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 1) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) -> (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1))) [forward reach with edge: (event: c2) (guard: true -> (1 <= A.Vc2 and A.Vc2 <= 3 or (A.Vc2 = 5 or A.Vc3 != 4)) and A.Vc2 != 2 and ((A.Vc2 = 0 or (2 <= A.Vc2 and A.Vc2 <= 4 or A.Vc3 != 4)) and (A.Vc2 != 3 or A.Vc3 != 4))) (assignments: A.Vc2 := A.Vc2 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 1) and (A.Vc4 = 0 or A.Vc4 = 1))) -> (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1)) or ((A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1))) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1)))) [forward reach with edge: (event: c3) (guard: true -> (A.Vc2 = 1 or A.Vc2 = 3 or (A.Vc2 = 5 or A.Vc3 != 3)) and ((A.Vc2 = 0 or (2 <= A.Vc2 and A.Vc2 <= 4 or A.Vc3 != 3)) and A.Vc2 != 3)) (assignments: A.Vc3 := A.Vc3 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1)) or ((A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1))) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1)) or (A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 1)) or A.Vc1 = 1 and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 1)))) -> (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or ((A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and A.Vc4 = 1)) or ((A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or ((A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and (A.Vc3 = 1 and A.Vc4 = 1))) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and A.Vc4 = 1)) or (A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or (A.Vc1 = 1 and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and A.Vc2 = 1 and (A.Vc3 = 1 and A.Vc4 = 1)))) [forward reach with edge: (event: c4) (guard: true -> true) (assignments: A.Vc4 := A.Vc4 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or ((A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and A.Vc4 = 1)) or ((A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or ((A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or (A.Vc1 = 0 or A.Vc1 = 2) and A.Vc2 = 1 and (A.Vc3 = 1 and A.Vc4 = 1))) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or (A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and (A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and A.Vc4 = 1)) or (A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1) or (A.Vc1 = 1 and A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2)) or A.Vc1 = 1 and A.Vc2 = 1 and (A.Vc3 = 1 and A.Vc4 = 1)))) -> 0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1)) or (0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and A.Vc4 = 1))) or (0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1)) or (0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and (A.Vc3 = 1 and A.Vc4 = 1)))) [forward reach with edge: (event: c1) (guard: A.Vc1 != 4 -> A.Vc1 != 4) (assignments: A.Vc1 := A.Vc1 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: 0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1)) or (0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and ((A.Vc2 = 0 or A.Vc2 = 2) and (A.Vc3 = 1 and A.Vc4 = 1))) or (0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and ((A.Vc3 = 0 or A.Vc3 = 2) and A.Vc4 = 1)) or (0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and (A.Vc3 = 1 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and A.Vc1 <= 3 and (A.Vc2 = 1 and (A.Vc3 = 1 and A.Vc4 = 1)))) -> 0 <= A.Vc1 and (A.Vc1 <= 3 and (A.Vc2 = 0 or A.Vc2 = 2)) and (0 <= A.Vc3 and (A.Vc3 <= 3 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and (A.Vc1 <= 3 and (A.Vc2 = 0 or A.Vc2 = 2)) and (0 <= A.Vc3 and (A.Vc3 <= 3 and A.Vc4 = 1)) or (0 <= A.Vc1 and (A.Vc1 <= 3 and A.Vc2 = 1) and (0 <= A.Vc3 and (A.Vc3 <= 3 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and (A.Vc1 <= 3 and A.Vc2 = 1) and (0 <= A.Vc3 and (A.Vc3 <= 3 and A.Vc4 = 1))) [forward reach with edge: (event: c3) (guard: true -> (A.Vc2 = 1 or A.Vc2 = 3 or (A.Vc2 = 5 or A.Vc3 != 3)) and ((A.Vc2 = 0 or (2 <= A.Vc2 and A.Vc2 <= 4 or A.Vc3 != 3)) and A.Vc2 != 3)) (assignments: A.Vc3 := A.Vc3 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: 0 <= A.Vc1 and (A.Vc1 <= 3 and (A.Vc2 = 0 or A.Vc2 = 2)) and (0 <= A.Vc3 and (A.Vc3 <= 3 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and (A.Vc1 <= 3 and (A.Vc2 = 0 or A.Vc2 = 2)) and (0 <= A.Vc3 and (A.Vc3 <= 3 and A.Vc4 = 1)) or (0 <= A.Vc1 and (A.Vc1 <= 3 and A.Vc2 = 1) and (0 <= A.Vc3 and (A.Vc3 <= 3 and (A.Vc4 = 0 or A.Vc4 = 2))) or 0 <= A.Vc1 and (A.Vc1 <= 3 and A.Vc2 = 1) and (0 <= A.Vc3 and (A.Vc3 <= 3 and A.Vc4 = 1))) -> 0 <= A.Vc1 and (A.Vc1 <= 3 and (A.Vc2 = 0 or A.Vc2 = 2)) and (0 <= A.Vc3 and A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or 0 <= A.Vc1 and (A.Vc1 <= 3 and A.Vc2 = 1) and (0 <= A.Vc3 and A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) [forward reach with edge: (event: c4) (guard: true -> true) (assignments: A.Vc4 := A.Vc4 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: 0 <= A.Vc1 and (A.Vc1 <= 3 and (A.Vc2 = 0 or A.Vc2 = 2)) and (0 <= A.Vc3 and A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or 0 <= A.Vc1 and (A.Vc1 <= 3 and A.Vc2 = 1) and (0 <= A.Vc3 and A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) -> (A.Vc1 = 0 or A.Vc1 = 4) and ((A.Vc2 = 0 or A.Vc2 = 2) and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or ((A.Vc1 = 0 or A.Vc1 = 4) and (A.Vc2 = 1 and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or A.Vc1 = 2 and ((A.Vc2 = 0 or A.Vc2 = 2) and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3))) or (A.Vc1 = 2 and (A.Vc2 = 1 and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or ((A.Vc1 = 1 or A.Vc1 = 3) and ((A.Vc2 = 0 or A.Vc2 = 2) and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or (A.Vc1 = 1 or A.Vc1 = 3) and (A.Vc2 = 1 and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)))) [forward reach with edge: (event: c1) (guard: A.Vc1 != 4 -> A.Vc1 != 4) (assignments: A.Vc1 := A.Vc1 + 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: (A.Vc1 = 0 or A.Vc1 = 4) and ((A.Vc2 = 0 or A.Vc2 = 2) and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or ((A.Vc1 = 0 or A.Vc1 = 4) and (A.Vc2 = 1 and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or A.Vc1 = 2 and ((A.Vc2 = 0 or A.Vc2 = 2) and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3))) or (A.Vc1 = 2 and (A.Vc2 = 1 and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or ((A.Vc1 = 1 or A.Vc1 = 3) and ((A.Vc2 = 0 or A.Vc2 = 2) and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)) or (A.Vc1 = 1 or A.Vc1 = 3) and (A.Vc2 = 1 and 0 <= A.Vc3) and (A.Vc3 <= 3 and (0 <= A.Vc4 and A.Vc4 <= 3)))) -> (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 = 1) or (3 <= A.Vc2 and A.Vc2 <= 5 or A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 1) or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or (A.Vc2 = 1 or 3 <= A.Vc2 and A.Vc2 <= 5) or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5)))) and ((A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or A.Vc2 != 1 or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5)))))) and ((A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (A.Vc1 != 2 or A.Vc2 != 5) and ((A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 = 1 or 3 <= A.Vc2 and A.Vc2 <= 5) or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 1 or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3))) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5)))) [forward reach with edge: (event: c4) (guard: true -> true) (assignments: A.Vc4 := A.Vc4 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 = 1) or (3 <= A.Vc2 and A.Vc2 <= 5 or A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 1) or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or (A.Vc2 = 1 or 3 <= A.Vc2 and A.Vc2 <= 5) or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5)))) and ((A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or A.Vc2 != 1 or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5)))))) and ((A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (A.Vc1 != 2 or A.Vc2 != 5) and ((A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 = 1 or 3 <= A.Vc2 and A.Vc2 <= 5) or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 1 or (A.Vc3 = 4 or (A.Vc3 = 5 or A.Vc4 != 5))) and (not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3))) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5)))) -> (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((A.Vc1 != 2 or A.Vc2 != 5) and (A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4)) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5))) [forward reach with edge: (event: c4) (guard: true -> true) (assignments: A.Vc4 := A.Vc4 + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - No change this iteration. - Forward controlled-behavior: (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((A.Vc1 != 2 or A.Vc2 != 5) and (A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4)) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5))) [fixed point]. Controlled behavior: true -> (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((A.Vc1 != 2 or A.Vc2 != 5) and (A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4)) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5))). @@ -260,9 +230,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((A.Vc1 != 2 or A.Vc2 != 5) and (A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4)) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5))) [restricted to current/previous controlled-behavior predicate: (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((A.Vc1 != 2 or A.Vc2 != 5) and (A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4)) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5)))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: (1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3))) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 4)) and ((1 <= A.Vc1 and A.Vc1 <= 3 or A.Vc1 = 5 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 5))) and ((1 <= A.Vc1 and A.Vc1 <= 3 or (A.Vc1 = 5 or A.Vc2 != 3)) and (A.Vc1 != 2 or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and ((A.Vc1 != 2 or A.Vc2 != 4) and (A.Vc1 != 2 or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)))) and ((A.Vc1 != 2 or A.Vc2 != 5) and (A.Vc1 != 2 or A.Vc2 != 3) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 = 1 or (3 <= A.Vc2 and A.Vc2 <= 5 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 4)) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or (A.Vc2 != 1 or 0 <= A.Vc3 and A.Vc3 <= 3)) and (not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 5) and ((not(A.Vc1 = 1 or A.Vc1 = 3) or A.Vc2 != 3) and A.Vc1 != 5))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_req_aut.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_req_aut.cif.out index 6e8afcd78f0678ee35ce18001cac3d58a9e3fa85..fa448966ac1aa6f00080cecdf83b1ac2a9653b2a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_req_aut.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_req_aut.cif.out @@ -113,28 +113,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: A.l1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: A.l1 -> not A.l3 [forward reach with edge: (event: A.c) (guard: A.l1) (assignments: A := A.l2), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: not A.l3 [fixed point]. Controlled behavior: true -> not A.l3. @@ -146,9 +134,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> not A.l3 [restricted to current/previous controlled-behavior predicate: not A.l3] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: not A.l3 [fixed point]. Controlled behavior not changed. @@ -156,9 +141,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: A.l3 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_simple.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_simple.cif.out index 4d47ae5b9455948b88a2d30e1a5bc182c5e51afb..dd62a1ba24b0fe9233e5198c5a0910cd66849cc8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_simple.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_simple.cif.out @@ -102,28 +102,16 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: A.l1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: A.l1 -> A.l1 or A.l2 [forward reach with edge: (event: c) (guard: A.l1) (assignments: A := A.l2), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: A.l1 or A.l2 [fixed point]. Controlled behavior: true -> A.l1 or A.l2. @@ -135,9 +123,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> A.l1 or A.l2 [restricted to current/previous controlled-behavior predicate: A.l1 or A.l2] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: A.l1 or A.l2 [fixed point]. Controlled behavior not changed. @@ -145,9 +130,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: not A.l1 and not A.l2 [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_unctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_unctrl.cif.out index 389bd339ce1cd9917db670fe8ca54bcd6d2fa267..408e2e42c6f0aff37b899106ceb1db7c28248119 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_unctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_plant_invs_unctrl.cif.out @@ -200,9 +200,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -210,21 +207,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: false [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: false -> A.Vu1 = 5 [backward reach with edge: (event: u1) (guard: A.Vu1 != 4 -> A.Vu1 != 4) (assignments: A.Vu1 := A.Vu1 + 1)] - Backward uncontrolled bad-state: A.Vu1 = 5 -> <bdd 13n 29p> [backward reach with edge: (event: u2) (guard: true -> (1 <= A.Vu2 and A.Vu2 <= 3 or (A.Vu2 = 5 or A.Vu3 != 4)) and A.Vu2 != 2 and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 4)) and (A.Vu2 != 3 or A.Vu3 != 4))) (assignments: A.Vu2 := A.Vu2 + 1)] - Backward uncontrolled bad-state: <bdd 13n 29p> -> <bdd 11n 32p> [backward reach with edge: (event: u3) (guard: true -> (A.Vu2 = 1 or A.Vu2 = 3 or (A.Vu2 = 5 or A.Vu3 != 3)) and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 3)) and A.Vu2 != 3)) (assignments: A.Vu3 := A.Vu3 + 1)] - - Backward reachability iteration 2: - Backward uncontrolled bad-state: <bdd 11n 32p> -> <bdd 13n 35p> [backward reach with edge: (event: u2) (guard: true -> (1 <= A.Vu2 and A.Vu2 <= 3 or (A.Vu2 = 5 or A.Vu3 != 4)) and A.Vu2 != 2 and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 4)) and (A.Vu2 != 3 or A.Vu3 != 4))) (assignments: A.Vu2 := A.Vu2 + 1)] - Backward uncontrolled bad-state: <bdd 13n 35p> -> <bdd 10n 23p> [backward reach with edge: (event: u3) (guard: true -> (A.Vu2 = 1 or A.Vu2 = 3 or (A.Vu2 = 5 or A.Vu3 != 3)) and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 3)) and A.Vu2 != 3)) (assignments: A.Vu3 := A.Vu3 + 1)] - - Backward reachability iteration 3: - Backward uncontrolled bad-state: <bdd 10n 23p> -> <bdd 11n 26p> [backward reach with edge: (event: u2) (guard: true -> (1 <= A.Vu2 and A.Vu2 <= 3 or (A.Vu2 = 5 or A.Vu3 != 4)) and A.Vu2 != 2 and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 4)) and (A.Vu2 != 3 or A.Vu3 != 4))) (assignments: A.Vu2 := A.Vu2 + 1)] - - Backward reachability iteration 4: - No change this iteration. - Backward uncontrolled bad-state: <bdd 11n 26p> [fixed point]. Controlled behavior: true -> (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4)))). @@ -232,26 +214,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: A.Vu1 = 0 and (A.Vu2 = 0 and A.Vu3 = 0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: A.Vu1 = 0 and (A.Vu2 = 0 and A.Vu3 = 0) -> (A.Vu1 = 0 or A.Vu1 = 1) and (A.Vu2 = 0 and A.Vu3 = 0) [forward reach with edge: (event: u1) (guard: A.Vu1 != 4 -> A.Vu1 != 4) (assignments: A.Vu1 := A.Vu1 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - Forward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 1) and (A.Vu2 = 0 and A.Vu3 = 0) -> (A.Vu1 = 0 or A.Vu1 = 1) and ((A.Vu2 = 0 or A.Vu2 = 1) and A.Vu3 = 0) [forward reach with edge: (event: u2) (guard: true -> (1 <= A.Vu2 and A.Vu2 <= 3 or (A.Vu2 = 5 or A.Vu3 != 4)) and A.Vu2 != 2 and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 4)) and (A.Vu2 != 3 or A.Vu3 != 4))) (assignments: A.Vu2 := A.Vu2 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - Forward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 1) and ((A.Vu2 = 0 or A.Vu2 = 1) and A.Vu3 = 0) -> (A.Vu1 = 0 or A.Vu1 = 1) and ((A.Vu2 = 0 or A.Vu2 = 1) and (A.Vu3 = 0 or A.Vu3 = 1)) [forward reach with edge: (event: u3) (guard: true -> (A.Vu2 = 1 or A.Vu2 = 3 or (A.Vu2 = 5 or A.Vu3 != 3)) and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 3)) and A.Vu2 != 3)) (assignments: A.Vu3 := A.Vu3 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - - Forward reachability iteration 2: - Forward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 1) and ((A.Vu2 = 0 or A.Vu2 = 1) and (A.Vu3 = 0 or A.Vu3 = 1)) -> (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 1) and (A.Vu3 = 0 or A.Vu3 = 1)) or A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 1) and (A.Vu3 = 0 or A.Vu3 = 1)) [forward reach with edge: (event: u1) (guard: A.Vu1 != 4 -> A.Vu1 != 4) (assignments: A.Vu1 := A.Vu1 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - Forward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 1) and (A.Vu3 = 0 or A.Vu3 = 1)) or A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 1) and (A.Vu3 = 0 or A.Vu3 = 1)) -> (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 1)) or (A.Vu1 = 0 or A.Vu1 = 2) and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 1)) or (A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 1)) or A.Vu1 = 1 and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 1))) [forward reach with edge: (event: u2) (guard: true -> (1 <= A.Vu2 and A.Vu2 <= 3 or (A.Vu2 = 5 or A.Vu3 != 4)) and A.Vu2 != 2 and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 4)) and (A.Vu2 != 3 or A.Vu3 != 4))) (assignments: A.Vu2 := A.Vu2 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - Forward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 1)) or (A.Vu1 = 0 or A.Vu1 = 2) and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 1)) or (A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 1)) or A.Vu1 = 1 and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 1))) -> (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 2)) or (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 2) and A.Vu3 = 1) or ((A.Vu1 = 0 or A.Vu1 = 2) and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 2)) or (A.Vu1 = 0 or A.Vu1 = 2) and (A.Vu2 = 1 and A.Vu3 = 1)) or (A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 2)) or A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 2) and A.Vu3 = 1) or (A.Vu1 = 1 and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 2)) or A.Vu1 = 1 and (A.Vu2 = 1 and A.Vu3 = 1))) [forward reach with edge: (event: u3) (guard: true -> (A.Vu2 = 1 or A.Vu2 = 3 or (A.Vu2 = 5 or A.Vu3 != 3)) and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 3)) and A.Vu2 != 3)) (assignments: A.Vu3 := A.Vu3 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - - Forward reachability iteration 3: - Forward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 2)) or (A.Vu1 = 0 or A.Vu1 = 2) and ((A.Vu2 = 0 or A.Vu2 = 2) and A.Vu3 = 1) or ((A.Vu1 = 0 or A.Vu1 = 2) and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 2)) or (A.Vu1 = 0 or A.Vu1 = 2) and (A.Vu2 = 1 and A.Vu3 = 1)) or (A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 2)) or A.Vu1 = 1 and ((A.Vu2 = 0 or A.Vu2 = 2) and A.Vu3 = 1) or (A.Vu1 = 1 and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 2)) or A.Vu1 = 1 and (A.Vu2 = 1 and A.Vu3 = 1))) -> 0 <= A.Vu1 and A.Vu1 <= 3 and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 2)) or 0 <= A.Vu1 and A.Vu1 <= 3 and ((A.Vu2 = 0 or A.Vu2 = 2) and A.Vu3 = 1) or (0 <= A.Vu1 and A.Vu1 <= 3 and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 2)) or 0 <= A.Vu1 and A.Vu1 <= 3 and (A.Vu2 = 1 and A.Vu3 = 1)) [forward reach with edge: (event: u1) (guard: A.Vu1 != 4 -> A.Vu1 != 4) (assignments: A.Vu1 := A.Vu1 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - Forward controlled-behavior: 0 <= A.Vu1 and A.Vu1 <= 3 and ((A.Vu2 = 0 or A.Vu2 = 2) and (A.Vu3 = 0 or A.Vu3 = 2)) or 0 <= A.Vu1 and A.Vu1 <= 3 and ((A.Vu2 = 0 or A.Vu2 = 2) and A.Vu3 = 1) or (0 <= A.Vu1 and A.Vu1 <= 3 and (A.Vu2 = 1 and (A.Vu3 = 0 or A.Vu3 = 2)) or 0 <= A.Vu1 and A.Vu1 <= 3 and (A.Vu2 = 1 and A.Vu3 = 1)) -> 0 <= A.Vu1 and A.Vu1 <= 3 and ((A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or 0 <= A.Vu1 and A.Vu1 <= 3 and (A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3)) [forward reach with edge: (event: u3) (guard: true -> (A.Vu2 = 1 or A.Vu2 = 3 or (A.Vu2 = 5 or A.Vu3 != 3)) and ((A.Vu2 = 0 or (2 <= A.Vu2 and A.Vu2 <= 4 or A.Vu3 != 3)) and A.Vu2 != 3)) (assignments: A.Vu3 := A.Vu3 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - - Forward reachability iteration 4: - Forward controlled-behavior: 0 <= A.Vu1 and A.Vu1 <= 3 and ((A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or 0 <= A.Vu1 and A.Vu1 <= 3 and (A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3)) -> (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3))) [forward reach with edge: (event: u1) (guard: A.Vu1 != 4 -> A.Vu1 != 4) (assignments: A.Vu1 := A.Vu1 + 1), restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4))))] - - Forward reachability iteration 5: - No change this iteration. - Forward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3))) [fixed point]. Controlled behavior: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 3 and A.Vu3 = 4) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 3 and A.Vu3 = 4) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 3 and A.Vu3 = 4)))) -> (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3))). @@ -263,9 +225,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3))) [restricted to current/previous controlled-behavior predicate: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3)))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: (A.Vu1 = 0 or A.Vu1 = 4) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 0 or A.Vu1 = 4) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or A.Vu1 = 2 and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3)) or (A.Vu1 = 2 and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3) or ((A.Vu1 = 1 or A.Vu1 = 3) and (A.Vu2 = 0 or A.Vu2 = 2) and (0 <= A.Vu3 and A.Vu3 <= 3) or (A.Vu1 = 1 or A.Vu1 = 3) and A.Vu2 = 1 and (0 <= A.Vu3 and A.Vu3 <= 3))) [fixed point]. Controlled behavior not changed. @@ -273,9 +232,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (1 <= A.Vu1 and A.Vu1 <= 3 or (A.Vu1 = 5 or A.Vu2 = 1) or (3 <= A.Vu2 and A.Vu2 <= 5 or (A.Vu3 = 4 or A.Vu3 = 5))) and ((1 <= A.Vu1 and A.Vu1 <= 3 or A.Vu1 = 5 or (A.Vu2 != 1 or (A.Vu3 = 4 or A.Vu3 = 5))) and (A.Vu1 != 2 or A.Vu2 = 1 or (3 <= A.Vu2 and A.Vu2 <= 5 or (A.Vu3 = 4 or A.Vu3 = 5)))) and ((A.Vu1 != 2 or A.Vu2 != 1 or (A.Vu3 = 4 or A.Vu3 = 5)) and ((not(A.Vu1 = 1 or A.Vu1 = 3) or A.Vu2 = 1 or (3 <= A.Vu2 and A.Vu2 <= 5 or (A.Vu3 = 4 or A.Vu3 = 5))) and (not(A.Vu1 = 1 or A.Vu1 = 3) or A.Vu2 != 1 or (A.Vu3 = 4 or A.Vu3 = 5)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_all_ctrl_beh.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_all_ctrl_beh.cif.out index a27c7464c1d8698ebe48cfca498371aba96b5301..d1b5731946d082aa137374a615686cad6259b244 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_all_ctrl_beh.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_all_ctrl_beh.cif.out @@ -190,9 +190,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 12n 27p> [restricted to current/previous controlled-behavior predicate: <bdd 12n 27p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 12n 27p> [fixed point]. Controlled behavior not changed. @@ -200,12 +197,6 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 12n 52p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - Backward uncontrolled bad-state: <bdd 12n 52p> -> <bdd 14n 105p> [backward reach with edge: (event: u_e) (guard: not p.b -> not p.b) (assignments: p.x := p.x + 2, p.b := true)] - - Backward reachability iteration 2: - No change this iteration. - Backward uncontrolled bad-state: <bdd 14n 105p> [fixed point]. Controlled behavior: <bdd 12n 27p> -> <bdd 14n 54p>. @@ -214,12 +205,6 @@ Synthesis round 1: Forward controlled-behavior: <bdd 13n 125p> [initialization predicate] Forward controlled-behavior: <bdd 13n 125p> -> <bdd 13n 27p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 54p>] - Forward reachability iteration 1: - Forward controlled-behavior: <bdd 13n 27p> -> <bdd 17n 63p> [forward reach with edge: (event: u_e) (guard: not p.b -> not p.b) (assignments: p.x := p.x + 2, p.b := true), restricted to current/previous controlled-behavior predicate: <bdd 14n 54p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 17n 63p> [fixed point]. Controlled behavior: <bdd 14n 54p> -> <bdd 17n 63p>. @@ -231,9 +216,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 17n 63p> [restricted to current/previous controlled-behavior predicate: <bdd 17n 63p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 17n 63p> [fixed point]. Controlled behavior not changed. @@ -241,9 +223,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 17n 124p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_per_edge.cif.out index a520a1cae27d8f536c9cd1881c135c9891082abc..06f47db34dc75bb505b5cf72a29d5cde58079e8f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/state_req_inv_per_edge.cif.out @@ -201,9 +201,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 200p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 200p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 200p> [fixed point]. Controlled behavior not changed. @@ -211,21 +208,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 152p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: <bdd 13n 27p> [initialization predicate] Forward controlled-behavior: <bdd 13n 27p> -> <bdd 13n 27p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 200p>] - Forward reachability iteration 1: - Forward controlled-behavior: <bdd 13n 27p> -> <bdd 17n 63p> [forward reach with edge: (event: u_e) (guard: not p.b -> not p.b) (assignments: p.x := p.x + 2, p.b := true), restricted to current/previous controlled-behavior predicate: <bdd 16n 200p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 17n 63p> [fixed point]. Controlled behavior: <bdd 16n 200p> -> <bdd 17n 63p>. @@ -237,9 +225,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 17n 63p> [restricted to current/previous controlled-behavior predicate: <bdd 17n 63p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 17n 63p> [fixed point]. Controlled behavior not changed. @@ -247,9 +232,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 17n 124p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.out index bd12fc505c19e74018a3e5a8cc43a8c3557fb9b3..6606c215138c3b4a85364ac8482d6cde57e57f2e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.out @@ -97,9 +97,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -112,66 +109,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: a.x = 1 [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: a.x = 1 -> a.x = 2 or a.x = 1 [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - Forward controlled-behavior: a.x = 2 or a.x = 1 -> a.x = 2 or (a.x = 1 or a.x = 3) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 3: - Forward controlled-behavior: a.x = 2 or (a.x = 1 or a.x = 3) -> a.x = 4 or a.x = 2 or (a.x = 1 or a.x = 3) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 4: - Forward controlled-behavior: a.x = 4 or a.x = 2 or (a.x = 1 or a.x = 3) -> a.x = 4 or a.x = 2 or (a.x = 1 or (a.x = 5 or a.x = 3)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 5: - Forward controlled-behavior: a.x = 4 or a.x = 2 or (a.x = 1 or (a.x = 5 or a.x = 3)) -> a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or (a.x = 5 or a.x = 3)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 6: - Forward controlled-behavior: a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or (a.x = 5 or a.x = 3)) -> a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 7: - Forward controlled-behavior: a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) -> a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 8: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 3 or (a.x = 5 or a.x = 7)) -> a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 9: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or a.x = 6) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) -> a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 10: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or a.x = 9 or (a.x = 5 or (a.x = 3 or a.x = 7))) -> a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 11: - Forward controlled-behavior: a.x = 8 or a.x = 4 or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) -> a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 12: - Forward controlled-behavior: a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 3 or a.x = 9) or (a.x = 11 or (a.x = 5 or a.x = 7))) -> a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 5 or a.x = 9) or (a.x = 13 or a.x = 3 or (a.x = 11 or a.x = 7))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 13: - Forward controlled-behavior: a.x = 8 or (a.x = 4 or a.x = 12) or (a.x = 2 or (a.x = 10 or a.x = 6)) or (a.x = 1 or (a.x = 5 or a.x = 9) or (a.x = 13 or a.x = 3 or (a.x = 11 or a.x = 7))) -> not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and not(a.x = 18 or a.x = 22)) and (not(a.x = 17 or (a.x = 21 or a.x = 25)) and a.x != 19 and (a.x != 23 and a.x != 15)) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 14: - Forward controlled-behavior: not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and not(a.x = 18 or a.x = 22)) and (not(a.x = 17 or (a.x = 21 or a.x = 25)) and a.x != 19 and (a.x != 23 and a.x != 15)) -> not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 15: - Forward controlled-behavior: not(a.x = 0 or a.x = 16) and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) -> a.x != 0 and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 16: - Forward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 20 and (not(a.x = 18 or a.x = 22) and (0 <= a.x and a.x <= 16 or a.x = 18 or (a.x = 20 or (a.x = 22 or a.x = 24))))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (not(a.x = 18 or a.x = 22) and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 17: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (not(a.x = 18 or a.x = 22) and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 18: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and a.x != 25 and (a.x != 21 and not(a.x = 19 or a.x = 23))) -> a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 19: - Forward controlled-behavior: a.x != 0 and (a.x != 24 and a.x != 20) and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [forward reach with edge: (event: e) (guard: 0 <= a.x and (a.x <= 23 and not(20 <= a.x and a.x <= 23))) (assignments: a.x := a.x + 1), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 20: - No change this iteration. - Forward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [fixed point]. Controlled behavior: true -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))). @@ -183,9 +120,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [restricted to current/previous controlled-behavior predicate: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23)))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: a.x != 0 and a.x != 24 and (a.x != 22 and (a.x != 25 and not(a.x = 21 or a.x = 23))) [fixed point]. Controlled behavior not changed. @@ -234,13 +168,13 @@ Simplifying supervisor guards for output model: Constructing output CIF specification. BDD cache statistics: - Node creation requests: 732 + Node creation requests: 726 Node creation chain accesses: 2 - Node creation cache hits: 285 - Node creation cache misses: 313 - Operation count: 2318 - Operation cache hits: 419 - Operation cache misses: 688 + Node creation cache hits: 294 + Node creation cache misses: 311 + Operation count: 2362 + Operation cache hits: 407 + Operation cache misses: 708 Writing continuous BDD performance statistics file "datasynth/stats.cif.stats.txt.real". diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.stats.txt b/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.stats.txt index 42e7465a0496c5a4006bf0932907a3d4631b121c..bc874db5a720baf8256b0635e2817e0d62c57de7 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.stats.txt +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/stats.cif.stats.txt @@ -332,117 +332,26 @@ Operations,Used BBD nodes 356,72 356,73 356,74 -373,74 -377,74 -381,74 -384,74 -387,75 -388,75 -388,74 -391,74 -396,76 -397,77 -397,76 -403,76 -405,76 -406,77 -408,76 -411,79 -414,80 -414,79 -417,77 -422,77 -424,79 -427,78 -430,80 -435,81 -435,80 -437,78 -439,78 -441,79 -443,77 -447,80 -451,81 -451,80 -454,77 -458,77 -461,80 -464,79 -469,81 -476,82 -476,81 -481,82 -484,82 -484,79 -486,79 -488,80 -490,80 -492,80 -492,78 -495,81 -499,82 -499,81 -502,82 -505,82 -505,78 -509,78 -512,80 -515,81 -518,81 -518,79 -521,81 -526,82 -526,81 -528,82 -530,82 -530,79 -532,79 -534,80 -536,77 -538,77 -543,81 -548,82 -548,81 -551,78 -554,78 -559,78 -563,80 -566,79 -569,79 -574,81 -581,82 -581,81 -585,79 -588,79 -590,79 -592,80 -594,78 -596,78 -599,81 -603,82 -603,81 -606,78 -609,78 -614,81 -615,81 -615,78 -615,76 -627,79 -630,79 -630,76 -637,76 -642,81 -647,81 -647,76 -655,76 -655,52 -655,43 -664,43 -668,43 -676,47 -676,43 -676,39 -680,42 -688,39 -688,35 -688,33 +386,74 +389,75 +390,75 +390,74 +393,74 +632,78 +632,76 +657,76 +662,81 +667,81 +667,76 +675,76 +675,52 +675,43 +684,43 +688,43 +696,47 +696,43 +696,39 +700,42 +708,39 +708,35 +708,33 diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/sup.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/sup.cif.out index e7fca9f07b4293c5a616c831b0309ca2a5a45788..cbbe0563846fec90da4de5826f2a21e0e3ea3076 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/sup.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/sup.cif.out @@ -78,9 +78,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -91,9 +88,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/supname_custom.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/supname_custom.cif.out index f900eba6108b388125dc66d53cb900ca5a387470..346cee3346a32fa2f1dfe7e59c47b31f704bc4a5 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/supname_custom.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/supname_custom.cif.out @@ -78,9 +78,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -91,9 +88,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/svg_input_decl_removed.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/svg_input_decl_removed.cif.out index 25c7dfaf26c007f1e6674c983feebff377a79675..c28be72979219a3286ab3f5743b88ab16a485a99 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/svg_input_decl_removed.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/svg_input_decl_removed.cif.out @@ -78,9 +78,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: true [marker predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing backward uncontrolled bad-state predicate: @@ -91,9 +88,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: true [initialization predicate] - Forward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out index 168106b9c7391e33282d3911c11ef774e156145a..3f12bb6daf5b163da7d869e1ae80031251ad1f5a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out @@ -194,24 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) -> p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) [backward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) -> p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - No change this iteration. - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior: true -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))). @@ -224,24 +206,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and p.y = 0) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 3: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) -> p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out index 081408c4b99e135c1fa3775429bdb7c45654f218..c2e0a661df2ea40333203b440bc821ed92d41ebd 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out @@ -194,24 +194,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and (p.b and p.y = 3)) -> p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) [backward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - Backward controlled-behavior: p.x = 0 and p.y = 1 or p.x = 2 and p.y = 2 or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3) -> p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and p.y = 2) or (p.x = 0 and (p.a and p.y = 1) or p.x = 0 and (p.b and p.y = 1)) or (p.x = 2 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and p.y = 2 or p.x = 3 and p.y = 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 3: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and p.y = 1)) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and p.y = 2) or p.x = 2 and (p.a and (p.y = 1 or p.y = 3)))) or (p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and p.y = 2) or p.x = 1 and (p.a and (p.y = 1 or p.y = 3))) or (p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and (p.y = 2 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 4: - Backward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2))) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) [backward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and (p.a and p.y = 2) or (p.x = 3 and (p.a and (p.y = 1 or p.y = 3)) or p.x = 3 and (p.b and p.y = 3)))) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [backward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 5: - No change this iteration. - Backward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior: true -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))). @@ -224,24 +206,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: p.x = 0 and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and p.y = 0) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and p.y = 0) -> (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x = 0 or p.x = 1) and (p.a and (p.y = 0 or p.y = 1)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 2: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or (p.x = 0 and (p.b and p.y = 1) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and (p.a and (p.y = 0 or p.y = 1)) or p.x = 1 and (p.a and (p.y = 0 or p.y = 1))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and (p.x != 2 or (p.b or p.y != 3))) and ((p.x != 2 or p.a) and (p.x != 1 or (p.b or p.y != 3)) and ((p.x != 1 or p.a) and p.x != 3)) -> p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 3: - Forward controlled-behavior: p.x = 0 and (p.a and (p.y = 0 or p.y = 2)) or p.x = 0 and (p.a and p.y = 1) or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and (p.a and (p.y = 0 or p.y = 2))) or (p.x = 2 and (p.a and p.y = 1) or p.x = 2 and (p.b and p.y = 2) or (p.x = 1 and (p.a and (p.y = 0 or p.y = 2)) or (p.x = 1 and (p.a and p.y = 1) or p.x = 1 and (p.b and p.y = 2)))) -> (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) [forward reach with edge: (event: inc_x) (guard: p.a -> (p.x = 0 or p.x = 2) and p.a or p.x = 1 and p.a) (assignments: p.x := p.x + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: (p.x != 0 or (p.b or p.y != 3)) and (p.x != 0 or p.a or (p.y = 1 or p.y = 3)) and ((p.x != 0 or (p.a or p.y != 3)) and ((p.x != 2 or (p.b or p.y != 3)) and (p.x != 2 or (p.a or p.y != 0)))) and ((p.x != 2 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 1 or (p.b or p.y != 3)) and (p.x != 1 or (p.a or p.y != 0))) and ((p.x != 1 or p.a or (p.y = 0 or p.y = 2)) and ((p.x != 3 or (p.b or p.y != 3)) and (p.x != 3 or p.a)))) -> p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) [forward reach with edge: (event: inc_y) (guard: p.a -> (p.b or p.y != 3) and p.a) (assignments: p.y := p.y + 1), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - Forward controlled-behavior: p.x = 0 and p.a or (p.x = 0 and (p.b and p.y = 1) or p.x = 2 and p.a) or (p.x = 2 and (p.b and p.y = 2) or p.x = 1 and p.a or (p.x = 1 and (p.b and p.y = 2) or p.x = 3 and p.a)) -> p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [forward reach with edge: (event: done) (guard: p.a) (assignments: p := p.b), restricted to current/previous controlled-behavior predicate: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3)))] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: p.x = 0 and p.a or p.x = 0 and (p.b and p.y = 1) or (p.x = 2 and p.a or p.x = 2 and (p.b and p.y = 2)) or (p.x = 1 and p.a or p.x = 1 and (p.b and p.y = 2) or (p.x = 3 and p.a or p.x = 3 and (p.b and p.y = 3))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_aut.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_aut.cif.out index 9ee831522441684c3b53c7d4024da655b941df29..7db39795d5efc90af5ee822cacc8c1fdb96f0c31 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_aut.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_aut.cif.out @@ -217,13 +217,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: LightA.Red and (R.RR and LightB.Red) [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: LightA.Red and (R.RR and LightB.Red) -> LightA.Red and (R.RR and LightB.Red) or LightA.Green and (R.GR and LightB.Red) [backward reach with edge: (event: red_A) (guard: LightA.Green and R.GR) (assignments: LightA := LightA.Red, R := R.RR), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: LightA.Red and (R.RR and LightB.Red) or LightA.Green and (R.GR and LightB.Red) -> LightA.Red and (R.RR and LightB.Red) or (LightA.Red and (R.RG and LightB.Green) or LightA.Green and (R.GR and LightB.Red)) [backward reach with edge: (event: red_B) (guard: R.RG and LightB.Green) (assignments: LightB := LightB.Red, R := R.RR), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: LightA.Red and (R.RR and LightB.Red) or (LightA.Red and (R.RG and LightB.Green) or LightA.Green and (R.GR and LightB.Red)) [fixed point]. Controlled behavior: true -> LightA.Red and (R.RR and LightB.Red) or (LightA.Red and (R.RG and LightB.Green) or LightA.Green and (R.GR and LightB.Red)). @@ -236,13 +229,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: LightA.Red and (R.RR and LightB.Red) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: LightA.Red and (R.RR and LightB.Red) -> LightA.Red and (R.RR and LightB.Red) or LightA.Green and (R.GR and LightB.Red) [forward reach with edge: (event: green_A) (guard: LightA.Red and R.RR) (assignments: LightA := LightA.Green, R := R.GR), restricted to current/previous controlled-behavior predicate: LightA.Red and (R.RR and LightB.Red) or (LightA.Red and (R.RG and LightB.Green) or LightA.Green and (R.GR and LightB.Red))] - Forward controlled-behavior: LightA.Red and (R.RR and LightB.Red) or LightA.Green and (R.GR and LightB.Red) -> LightA.Red and (R.RR and LightB.Red) or (LightA.Red and (R.RG and LightB.Green) or LightA.Green and (R.GR and LightB.Red)) [forward reach with edge: (event: green_B) (guard: R.RR and LightB.Red) (assignments: LightB := LightB.Green, R := R.RG), restricted to current/previous controlled-behavior predicate: LightA.Red and (R.RR and LightB.Red) or (LightA.Red and (R.RG and LightB.Green) or LightA.Green and (R.GR and LightB.Red))] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: LightA.Red and (R.RR and LightB.Red) or (LightA.Red and (R.RG and LightB.Green) or LightA.Green and (R.GR and LightB.Red)) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_evt_excl_invs.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_evt_excl_invs.cif.out index 89686e3c31e27263652d4e872642b86caf01bf68..d3cc9fb394599f7397f501fbefd56b04a0cb05bb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_evt_excl_invs.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_evt_excl_invs.cif.out @@ -185,13 +185,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: LightA.Red and LightB.Red [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [backward reach with edge: (event: red_A) (guard: LightA.Green) (assignments: LightA := LightA.Red), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: LightB.Red -> true [backward reach with edge: (event: red_B) (guard: LightB.Green) (assignments: LightB := LightB.Red), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -204,13 +197,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: LightA.Red and LightB.Red [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [forward reach with edge: (event: green_A) (guard: LightA.Red -> LightA.Red and LightB.Red) (assignments: LightA := LightA.Green), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: LightB.Red -> LightA.Red or LightB.Red [forward reach with edge: (event: green_B) (guard: LightB.Red -> LightA.Red and LightB.Red) (assignments: LightB := LightB.Green), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: LightA.Red or LightB.Red [fixed point]. Controlled behavior: true -> LightA.Red or LightB.Red. @@ -221,13 +207,6 @@ Synthesis round 2: Computing backward controlled-behavior predicate: Backward controlled-behavior: LightA.Red and LightB.Red [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [backward reach with edge: (event: red_A) (guard: LightA.Green) (assignments: LightA := LightA.Red), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - Backward controlled-behavior: LightB.Red -> LightA.Red or LightB.Red [backward reach with edge: (event: red_B) (guard: LightB.Green) (assignments: LightB := LightB.Red), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: LightA.Red or LightB.Red [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_all_ctrl_beh.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_all_ctrl_beh.cif.out index f6ac8bf8829f9a80c001576c1ac0b284336e4300..497c5d71b3a63431bac0d43004928a34d743cfe2 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_all_ctrl_beh.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_all_ctrl_beh.cif.out @@ -179,13 +179,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: LightA.Red and LightB.Red [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [backward reach with edge: (event: red_A) (guard: LightA.Green) (assignments: LightA := LightA.Red), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - Backward controlled-behavior: LightB.Red -> LightA.Red or LightB.Red [backward reach with edge: (event: red_B) (guard: LightB.Green) (assignments: LightB := LightB.Red), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: LightA.Red or LightB.Red [fixed point]. Controlled behavior not changed. @@ -198,13 +191,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: LightA.Red and LightB.Red [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [forward reach with edge: (event: green_A) (guard: LightA.Red) (assignments: LightA := LightA.Green), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - Forward controlled-behavior: LightB.Red -> LightA.Red or LightB.Red [forward reach with edge: (event: green_B) (guard: LightB.Red) (assignments: LightB := LightB.Green), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: LightA.Red or LightB.Red [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_per_edge.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_per_edge.cif.out index 4e5e3fc2dfb279bade714e5aaa2a3c545139ae2a..ccd7d573e657a64086a0e8f737fd460ad20a9779 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_per_edge.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/traffic_lights_req_state_inv_per_edge.cif.out @@ -188,13 +188,6 @@ Synthesis round 1: Computing backward controlled-behavior predicate: Backward controlled-behavior: LightA.Red and LightB.Red [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [backward reach with edge: (event: red_A) (guard: LightA.Green) (assignments: LightA := LightA.Red), restricted to current/previous controlled-behavior predicate: true] - Backward controlled-behavior: LightB.Red -> true [backward reach with edge: (event: red_B) (guard: LightB.Green) (assignments: LightB := LightB.Red), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -207,13 +200,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: LightA.Red and LightB.Red [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [forward reach with edge: (event: green_A) (guard: LightA.Red -> LightA.Red and LightB.Red) (assignments: LightA := LightA.Green), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: LightB.Red -> LightA.Red or LightB.Red [forward reach with edge: (event: green_B) (guard: LightB.Red -> LightA.Red and LightB.Red) (assignments: LightB := LightB.Green), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: LightA.Red or LightB.Red [fixed point]. Controlled behavior: true -> LightA.Red or LightB.Red. @@ -224,13 +210,6 @@ Synthesis round 2: Computing backward controlled-behavior predicate: Backward controlled-behavior: LightA.Red and LightB.Red [marker predicate] - Backward reachability iteration 1: - Backward controlled-behavior: LightA.Red and LightB.Red -> LightB.Red [backward reach with edge: (event: red_A) (guard: LightA.Green) (assignments: LightA := LightA.Red), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - Backward controlled-behavior: LightB.Red -> LightA.Red or LightB.Red [backward reach with edge: (event: red_B) (guard: LightB.Green) (assignments: LightB := LightB.Red), restricted to current/previous controlled-behavior predicate: LightA.Red or LightB.Red] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: LightA.Red or LightB.Red [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out index cace77995828594cc8a15cf9db0926925ad4eda6..49e03efdb8267a8223cb0ee48ca888d3a5439828 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out @@ -198,12 +198,6 @@ Synthesis round 1: Backward controlled-behavior: p.sum = 7 and p.l2 [marker predicate] Backward controlled-behavior: p.sum = 7 and p.l2 -> p.sum = 7 and (p.y = 2 and p.l2) or p.sum = 7 and (p.y = 1 and p.l2) [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - Backward controlled-behavior: p.sum = 7 and (p.y = 2 and p.l2) or p.sum = 7 and (p.y = 1 and p.l2) -> <bdd 34n 25p> [backward reach with edge: (event: error) (guard: p.l1) (assignments: p.sum := p.x + p.y + p.z, p := p.l2), restricted to current/previous controlled-behavior predicate: true] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 34n 25p> [fixed point]. Controlled behavior: true -> <bdd 34n 25p>. @@ -211,21 +205,12 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 34n 96p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: p.sum = 3 and (p.y = 2 and p.l1) or p.sum = 3 and (p.y = 1 and p.l1) [initialization predicate] Forward controlled-behavior: p.sum = 3 and (p.y = 2 and p.l1) or p.sum = 3 and (p.y = 1 and p.l1) -> p.sum = 3 and p.z = 2 and (p.y = 2 and (p.x = 3 and p.l1)) or (p.sum = 3 and p.z = 3 and (p.y = 2 and (p.x = 2 and p.l1)) or p.sum = 3 and p.z = 3 and (p.y = 1 and (p.x = 3 and p.l1))) [restricted to current/previous controlled-behavior predicate: <bdd 34n 25p>] - Forward reachability iteration 1: - Forward controlled-behavior: p.sum = 3 and p.z = 2 and (p.y = 2 and (p.x = 3 and p.l1)) or (p.sum = 3 and p.z = 3 and (p.y = 2 and (p.x = 2 and p.l1)) or p.sum = 3 and p.z = 3 and (p.y = 1 and (p.x = 3 and p.l1))) -> <bdd 29n 6p> [forward reach with edge: (event: error) (guard: p.l1) (assignments: p.sum := p.x + p.y + p.z, p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 34n 25p>] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: <bdd 29n 6p> [fixed point]. Controlled behavior: <bdd 34n 25p> -> <bdd 29n 6p>. @@ -237,12 +222,6 @@ Synthesis round 2: Backward controlled-behavior: p.sum = 7 and p.l2 [marker predicate] Backward controlled-behavior: p.sum = 7 and p.l2 -> p.sum = 7 and p.z = 2 and (p.y = 2 and (p.x = 3 and p.l2)) or (p.sum = 7 and p.z = 3 and (p.y = 2 and (p.x = 2 and p.l2)) or p.sum = 7 and p.z = 3 and (p.y = 1 and (p.x = 3 and p.l2))) [restricted to current/previous controlled-behavior predicate: <bdd 29n 6p>] - Backward reachability iteration 1: - Backward controlled-behavior: p.sum = 7 and p.z = 2 and (p.y = 2 and (p.x = 3 and p.l2)) or (p.sum = 7 and p.z = 3 and (p.y = 2 and (p.x = 2 and p.l2)) or p.sum = 7 and p.z = 3 and (p.y = 1 and (p.x = 3 and p.l2))) -> <bdd 29n 6p> [backward reach with edge: (event: error) (guard: p.l1) (assignments: p.sum := p.x + p.y + p.z, p := p.l2), restricted to current/previous controlled-behavior predicate: <bdd 29n 6p>] - - Backward reachability iteration 2: - No change this iteration. - Backward controlled-behavior: <bdd 29n 6p> [fixed point]. Controlled behavior not changed. @@ -250,9 +229,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 29n 34p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out index af6eab3049516a03b22373d445dc21394faf4265..56e11c52cbdb86ce2b87f7cb5b2147bdab6c0292 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out @@ -226,9 +226,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> true [restricted to current/previous controlled-behavior predicate: true] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: true [fixed point]. Controlled behavior not changed. @@ -241,16 +238,6 @@ Synthesis round 1: Computing forward controlled-behavior predicate: Forward controlled-behavior: (p.v = 1 or (p.v = 3 or p.v = 5)) and (p.v = 0 or 2 <= p.v and p.v <= 4) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: (p.v = 1 or (p.v = 3 or p.v = 5)) and (p.v = 0 or 2 <= p.v and p.v <= 4) -> p.v = 2 or p.v = 3 [forward reach with edge: (event: f) (guard: p.v = 3) (assignments: p.v := p.v - 1), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v = 2 or p.v = 3 -> p.v != 4 and (p.v = 0 or 2 <= p.v and p.v <= 4) [forward reach with edge: (event: g) (guard: p.v = 2) (assignments: p.v := p.v - 2), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v != 4 and (p.v = 0 or 2 <= p.v and p.v <= 4) -> 0 <= p.v and p.v <= 3 [forward reach with edge: (event: g) (guard: p.v = 3) (assignments: p.v := p.v - 2), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: 0 <= p.v and p.v <= 3 -> p.v != 4 [forward reach with edge: (event: i) (guard: p.v = 3) (assignments: p.v := 5), restricted to current/previous controlled-behavior predicate: true] - Forward controlled-behavior: p.v != 4 -> (p.v != 4 or p.w != 0) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4))) [forward reach with edge: (event: j) (guard: p.v = 2) (assignments: p.v := p.w), restricted to current/previous controlled-behavior predicate: true] - - Forward reachability iteration 2: - No change this iteration. - Forward controlled-behavior: (p.v != 4 or p.w != 0) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4))) [fixed point]. Controlled behavior: true -> (p.v != 4 or p.w != 0) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4))). @@ -262,9 +249,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> (p.v != 4 or p.w != 0) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4))) [restricted to current/previous controlled-behavior predicate: (p.v != 4 or p.w != 0) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4)))] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: (p.v != 4 or p.w != 0) and ((p.v != 4 or p.w != 2) and (p.v != 4 or p.w = 0 or (p.w = 2 or p.w = 4))) [fixed point]. Controlled behavior not changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_adv_dcsh_from_paper.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_adv_dcsh_from_paper.cif.out index d28956f639f6299bd4a444ff24265bacea218c01..adcfa7666418f1a47428ac08bc0904150b2bd6e4 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_adv_dcsh_from_paper.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_adv_dcsh_from_paper.cif.out @@ -232,9 +232,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [fixed point]. Controlled behavior not changed. @@ -242,41 +239,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer2.count = 3 and buffer1.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 0 and buffer1.add)) -> buffer3.add and buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) -> buffer3.add and buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and (buffer3.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and (buffer3.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) -> buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1))) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1))) or buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1))) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1))) or buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))))) -> (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.add and buffer3.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and (buffer3.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))))) or (buffer3.add and buffer3.count = 1 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and (buffer3.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and buffer3.count = 1 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0))) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.add and buffer3.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and (buffer3.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))))) or (buffer3.add and buffer3.count = 1 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.add and (buffer3.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and buffer3.count = 1 and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0))) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)))))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.remove or (buffer3.count != 1 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.remove or buffer3.count != 1 or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)))) and ((buffer3.remove or (buffer3.count != 1 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.remove or (buffer3.count != 1 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.remove or buffer3.count != 1 or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)))) and ((buffer3.remove or (buffer3.count != 1 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.add) or (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer3.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.add) or (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer3.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer3.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.remove or buffer2.count != 3) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or buffer3.count != 1 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or (buffer3.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.remove or buffer2.count != 3) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or buffer3.count != 1 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or (buffer3.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 3)))) -> <bdd 16n 50p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 50p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) -> <bdd 16n 50p>. @@ -288,9 +255,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 50p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 50p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 50p> [fixed point]. Controlled behavior not changed. @@ -298,9 +262,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 23p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_off.cif.out index 1a806aa838975e98f8e77c3e392819b56cb00f16..1f2141fa4ea6f64dd06285410f9188e0e2c064c8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_off.cif.out @@ -147,9 +147,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) [restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) [fixed point]. Controlled behavior not changed. @@ -157,41 +154,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer1.count = 3 and (buffer2.count = 3 and buffer3.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.add and buffer2.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.add and buffer2.add)) -> buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer2.add)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer2.add)) -> buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer2.add)) or buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.add and buffer2.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer2.add)) or buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.add and buffer2.add)) -> buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 0 and buffer2.add) or buffer1.count = 1 and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.add and buffer2.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 0 and buffer2.add) or buffer1.count = 1 and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.add and buffer2.add)) -> <bdd 21n 4p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 21n 4p> -> buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 1 and buffer3.add) or (buffer1.count = 1 and buffer2.count = 0 and (buffer3.count = 0 and buffer1.add) or buffer1.count = 1 and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.count = 0 and buffer2.count = 0 and (buffer3.count = 1 and buffer3.add) or (buffer1.count = 1 and buffer2.count = 0 and (buffer3.count = 0 and buffer1.add) or buffer1.count = 1 and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.add))) -> <bdd 38n 8p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: <bdd 38n 8p> -> (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0 and (buffer3.count = 1 and buffer3.add) or ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer3.count = 0 and buffer2.add) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer3.count = 1 and (buffer3.add and buffer2.add))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0 and (buffer3.count = 1 and buffer3.add) or ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer3.count = 0 and buffer2.add) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer3.count = 1 and (buffer3.add and buffer2.add))) -> <bdd 38n 12p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 38n 12p> -> buffer1.count = 0 and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer1.count = 2 and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.add) or buffer1.count = 0 and buffer2.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add)) or (buffer1.count = 2 and buffer2.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.add and buffer2.add)) or (buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or buffer1.count = 1 and buffer2.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer1.count = 2 and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.add) or buffer1.count = 0 and buffer2.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add)) or (buffer1.count = 2 and buffer2.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.add and buffer2.add)) or (buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or buffer1.count = 1 and buffer2.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add))) -> <bdd 38n 18p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 38n 18p> -> buffer1.count = 0 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add) or (buffer1.count = 2 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.add) or buffer1.count = 2 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and (buffer3.add and buffer1.add))) or (buffer1.count = 0 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) or buffer1.count = 2 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and buffer1.add) or (buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add) or buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add) or (buffer1.count = 2 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.add) or buffer1.count = 2 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and (buffer3.add and buffer1.add))) or (buffer1.count = 0 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) or buffer1.count = 2 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and buffer1.add) or (buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add) or buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1)))) -> <bdd 38n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 38n 27p> -> <bdd 22n 18p> [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 22n 18p> -> <bdd 34n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 34n 27p> -> <bdd 26n 18p> [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 26n 18p> -> <bdd 30n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 30n 27p> -> (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 3 or (buffer3.count = 1 or buffer3.count = 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 3 or (buffer3.count = 0 or buffer3.count = 2)))) and ((buffer1.count != 3 or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count = 1 or (buffer3.count = 3 or buffer1.add))) and (buffer1.count != 1 or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.count != 3 or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.add))) and ((buffer1.count != 3 or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count != 3 or (buffer3.remove or buffer1.add))) and (buffer1.count != 3 or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add)))))) and ((buffer1.count != 1 or buffer2.count != 3 or (buffer3.count = 1 or buffer3.count = 3)) and (buffer1.count != 3 or buffer2.count != 1 or (buffer3.count = 1 or (buffer3.count = 3 or buffer1.add))) and ((buffer1.count != 3 or buffer2.count != 3 or (buffer3.count = 1 or buffer3.count = 3)) and (buffer1.count != 1 or buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.count != 1 or buffer2.count != 3 or (buffer3.count = 0 or buffer3.count = 2)) and (buffer1.count != 3 or buffer2.count != 1 or (buffer3.count != 1 or buffer1.add)) and ((buffer1.count != 3 or buffer2.count != 1 or (buffer3.count != 3 or (buffer3.remove or buffer1.add))) and ((buffer1.count != 3 or buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and (buffer1.count != 3 or buffer2.count != 3 or (buffer3.count = 0 or buffer3.count = 2)))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 3 or (buffer3.count = 1 or buffer3.count = 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 3 or (buffer3.count = 0 or buffer3.count = 2)))) and ((buffer1.count != 3 or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count = 1 or (buffer3.count = 3 or buffer1.add))) and (buffer1.count != 1 or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.count != 3 or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.add))) and ((buffer1.count != 3 or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count != 3 or (buffer3.remove or buffer1.add))) and (buffer1.count != 3 or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add)))))) and ((buffer1.count != 1 or buffer2.count != 3 or (buffer3.count = 1 or buffer3.count = 3)) and (buffer1.count != 3 or buffer2.count != 1 or (buffer3.count = 1 or (buffer3.count = 3 or buffer1.add))) and ((buffer1.count != 3 or buffer2.count != 3 or (buffer3.count = 1 or buffer3.count = 3)) and (buffer1.count != 1 or buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.count != 1 or buffer2.count != 3 or (buffer3.count = 0 or buffer3.count = 2)) and (buffer1.count != 3 or buffer2.count != 1 or (buffer3.count != 1 or buffer1.add)) and ((buffer1.count != 3 or buffer2.count != 1 or (buffer3.count != 3 or (buffer3.remove or buffer1.add))) and ((buffer1.count != 3 or buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and (buffer1.count != 3 or buffer2.count != 3 or (buffer3.count = 0 or buffer3.count = 2)))))) -> <bdd 25n 26p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 25n 26p> [fixed point]. Controlled behavior: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) -> <bdd 25n 26p>. @@ -203,9 +170,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 25n 26p> [restricted to current/previous controlled-behavior predicate: <bdd 25n 26p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 25n 26p> [fixed point]. Controlled behavior not changed. @@ -213,9 +177,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 25n 25p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_on.cif.out index 0161aa00817d445bafb853a38c38d93b76345788..168feed939cfbcd9af9ce9b094c58b3dc193cbaf 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_algos_on.cif.out @@ -234,9 +234,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) [restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) [fixed point]. Controlled behavior not changed. @@ -244,41 +241,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer1.count = 3 and (buffer2.count = 3 and buffer3.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer3.count = 0 and buffer3.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer3.count = 0 and buffer3.add)) -> buffer1.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer3.count = 0 and buffer3.add)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer3.count = 0 and buffer3.add)) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer3.count = 0 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer3.count = 0 and buffer3.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer3.count = 0 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer3.count = 0 and buffer3.add)) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer3.count = 1 and buffer3.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer3.count = 1 and buffer3.add))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add))) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add))) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add)))) -> (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0 and (buffer3.count = 1 and buffer3.add) or ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer2.add and buffer3.count = 0) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer3.count = 1 and buffer3.add))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0 and (buffer3.count = 1 and buffer3.add) or ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer2.add and buffer3.count = 0) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer3.count = 1 and buffer3.add))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add)) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)))) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add)) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)))) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 1 and buffer3.add))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and (buffer3.count = 0 or buffer3.count = 1))))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and (buffer3.count = 0 or buffer3.count = 1))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and (buffer3.count = 2 and buffer3.add)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and buffer3.count = 1) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 2 and buffer3.add)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 1)) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 2 and buffer3.add)) or buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer3.count = 2 and buffer3.add)) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 1)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 2 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 1) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 2 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 1)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and (buffer3.count = 2 and buffer3.add)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 0 and buffer3.count = 1) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 2 and buffer3.add)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 1)) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 0) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and (buffer3.count = 2 and buffer3.add)) or buffer1.add and buffer1.count = 1 and (buffer2.count = 0 and buffer3.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer3.count = 2 and buffer3.add)) or (buffer1.add and buffer1.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer3.count = 1)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.count = 2 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and buffer3.count = 1) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer3.count = 2 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer3.count = 1)))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) or buffer1.add and buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0)) or (buffer1.add and buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add)) or buffer1.add and buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add)) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) or buffer1.add and buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0)) or (buffer1.add and buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add)) or buffer1.add and buffer1.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 0) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 2 and buffer3.add)) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 0 or buffer3.count != 3)) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer3.count != 2 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 1 or buffer3.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer1.count != 1 or buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)) and (buffer1.count != 1 or (buffer2.count != 0 or buffer3.count != 3)) and ((buffer1.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer3.count != 2 or buffer3.add))) and (buffer1.count != 1 or buffer2.count != 2 or (buffer2.remove or buffer3.count != 3))) and ((buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer1.count != 1 or buffer2.count != 1 or (buffer3.count != 2 or buffer3.add)) and ((buffer1.count != 1 or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer1.count != 1 or buffer2.count != 3) and buffer1.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 0 or buffer3.count != 3)) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer3.count != 2 or buffer3.add))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 1 or buffer3.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer1.count != 1 or buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)) and (buffer1.count != 1 or (buffer2.count != 0 or buffer3.count != 3)) and ((buffer1.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer3.count != 2 or buffer3.add))) and (buffer1.count != 1 or buffer2.count != 2 or (buffer2.remove or buffer3.count != 3))) and ((buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer1.count != 1 or buffer2.count != 1 or (buffer3.count != 2 or buffer3.add)) and ((buffer1.count != 1 or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer1.count != 1 or buffer2.count != 3) and buffer1.count != 3)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 11n 27p> -> (buffer1.remove or (buffer2.count != 0 or buffer3.count != 3)) and (buffer1.remove or buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)) and ((buffer1.remove or (buffer2.count != 2 or buffer2.add)) and (buffer1.remove or (buffer2.count != 1 or buffer3.count != 3))) and ((buffer1.remove or buffer2.count != 3) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 0 or buffer3.count != 3))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 1 or buffer3.count != 3))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 0 or buffer3.count != 3)) and (buffer1.add or buffer1.count != 1 or (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)))) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer1.add or buffer1.count != 1 or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer1.add or (buffer1.count != 1 or buffer2.count != 3)) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.remove or (buffer2.count != 0 or buffer3.count != 3)) and (buffer1.remove or buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)) and ((buffer1.remove or (buffer2.count != 2 or buffer2.add)) and (buffer1.remove or (buffer2.count != 1 or buffer3.count != 3))) and ((buffer1.remove or buffer2.count != 3) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 0 or buffer3.count != 3))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 1 or buffer3.count != 3))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 0 or buffer3.count != 3)) and (buffer1.add or buffer1.count != 1 or (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)))) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer1.add or buffer1.count != 1 or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer1.add or (buffer1.count != 1 or buffer2.count != 3)) and (buffer1.add or buffer1.count != 3)))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer1.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer1.remove or buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and ((buffer1.remove or buffer2.count != 3) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and (buffer1.add or (buffer1.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.add or (buffer1.count != 1 or buffer2.count != 3)) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer1.remove or buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and ((buffer1.remove or buffer2.count != 3) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and (buffer1.add or (buffer1.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 1 or (buffer3.count != 3 or buffer3.add))) and ((buffer1.add or (buffer1.count != 1 or buffer2.count != 3)) and (buffer1.add or buffer1.count != 3)))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) -> <bdd 16n 44p>. @@ -290,9 +257,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -300,9 +264,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_legacy.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_legacy.cif.out index 25bac00fe1075b2f1d4dc983b8f1078631f3ee73..34b2c94bdfd45f1f5093b2d67ed47f9e2c742344 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_legacy.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_legacy.cif.out @@ -233,9 +233,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [fixed point]. Controlled behavior not changed. @@ -243,41 +240,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer2.count = 3 and buffer1.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 0 and buffer1.add)) -> buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) -> buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) -> buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) -> (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 1) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 1) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer2.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer2.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 0 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)))) and ((buffer3.count != 1 or buffer2.count != 0 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 0 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)))) and ((buffer3.count != 1 or buffer2.count != 0 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.remove or buffer2.count != 3) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or buffer3.count != 1 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or (buffer3.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.remove or buffer2.count != 3) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or buffer3.count != 1 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or (buffer3.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 3)))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) -> <bdd 16n 44p>. @@ -289,9 +256,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -299,9 +263,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_linearized.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_linearized.cif.out index 1e8a05a6e9c1772d97bfd3f44a0ffeb28890650a..25cde7f5a5aa0066e8c812d51df5b6f4da9a0341 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_linearized.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_hyper_edge_linearized.cif.out @@ -217,9 +217,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3) [restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3) [fixed point]. Controlled behavior not changed. @@ -227,41 +224,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer1.count = 3 and (buffer3.count = 3 and buffer2.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.count = 0 and buffer3.add and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and buffer3.add and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0)) or (buffer1.remove and buffer1.count = 0 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0)) or (buffer1.remove and buffer1.count = 0 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)))) -> (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1)))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1)))))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.add) or (buffer3.count = 2 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or (buffer3.count = 0 or buffer3.count = 1))))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.remove or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1)) and buffer1.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.add) or (buffer3.count = 2 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or (buffer3.count = 0 or buffer3.count = 1))))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.remove or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1)) and buffer1.count != 3)))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.remove or buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.remove or buffer3.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.remove or buffer3.count != 3) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3)) and ((buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.add or buffer1.count != 1 or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.add or (buffer1.count != 1 or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.remove or buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.remove or buffer3.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.remove or buffer3.count != 3) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3)) and ((buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.add or buffer1.count != 1 or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.add or (buffer1.count != 1 or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.remove or (buffer3.remove or buffer2.count != 3)) and ((buffer1.remove or buffer3.add or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.remove or buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.remove or (buffer3.add or buffer3.count != 3)) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.remove or buffer2.count != 3))) and ((buffer1.add or (buffer1.count != 1 or buffer3.add) or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer3.add or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.remove or (buffer3.remove or buffer2.count != 3)) and ((buffer1.remove or buffer3.add or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.remove or buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.remove or (buffer3.add or buffer3.count != 3)) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.remove or buffer2.count != 3))) and ((buffer1.add or (buffer1.count != 1 or buffer3.add) or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer3.add or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) -> <bdd 14n 50p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 14n 50p> [fixed point]. Controlled behavior: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3) -> <bdd 14n 50p>. @@ -273,9 +240,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 14n 50p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 50p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 50p> [fixed point]. Controlled behavior not changed. @@ -283,9 +247,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 14n 23p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_off.cif.out index 7a75a97eb3c3eb41d80d4531b59b5550516c23b7..dcdb9d01abb4d9cf74592c2fc9a815be165b49d8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_off.cif.out @@ -134,9 +134,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3) [restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3) [fixed point]. Controlled behavior not changed. @@ -144,41 +141,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer1.count = 3 and (buffer3.count = 3 and buffer2.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.count = 0 and buffer3.add and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and buffer3.add and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and buffer2.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and buffer2.count = 0))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0)) or (buffer1.remove and buffer1.count = 0 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0)) or (buffer1.remove and buffer1.count = 0 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer3.remove and (buffer3.count = 0 and buffer2.count = 0))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) or (buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)))) -> (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer3.remove and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and (buffer3.count = 0 and (buffer2.remove and buffer2.count = 0))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))))) or (buffer1.add and (buffer1.count = 1 and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.add) and (buffer3.count = 1 and (buffer2.remove and buffer2.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.remove) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.remove and buffer2.count = 0)))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1)))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.add and (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 or buffer2.count = 1)))))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.add) or (buffer3.count = 2 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or (buffer3.count = 0 or buffer3.count = 1))))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.remove or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1)) and buffer1.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.remove) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer3.add) or (buffer3.count = 2 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer3.add or (buffer3.count = 0 or buffer3.count = 1))))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.remove or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.count != 1 or (buffer3.remove or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.count != 1 or (buffer3.remove or buffer3.count != 3)) and (buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.count != 1 or (buffer3.add or buffer3.count = 2) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.count != 1 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1)) and buffer1.count != 3)))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.remove or buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.remove or buffer3.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.remove or buffer3.count != 3) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3)) and ((buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.add or buffer1.count != 1 or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.add or (buffer1.count != 1 or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.remove or buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.remove or buffer3.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.remove or buffer3.count != 3) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3)) and ((buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer1.add or buffer1.count != 1 or (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count != 1 or buffer3.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.add or (buffer1.count != 1 or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.remove or (buffer3.remove or buffer2.count != 3)) and ((buffer1.remove or buffer3.add or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.remove or buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.remove or (buffer3.add or buffer3.count != 3)) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.remove or buffer2.count != 3))) and ((buffer1.add or (buffer1.count != 1 or buffer3.add) or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer3.add or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer1.remove or (buffer3.remove or buffer2.count != 3)) and ((buffer1.remove or buffer3.add or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.remove or buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.remove or (buffer3.add or buffer3.count != 3)) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.remove or buffer2.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.remove or buffer2.count != 3))) and ((buffer1.add or (buffer1.count != 1 or buffer3.add) or (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer3.add or (buffer3.count != 1 or buffer2.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer3.add or buffer3.count != 3)) and (buffer1.add or buffer1.count != 3)))) -> <bdd 14n 50p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 14n 50p> [fixed point]. Controlled behavior: buffer1.count != 3 or (buffer3.count != 3 or buffer2.count != 3) -> <bdd 14n 50p>. @@ -190,9 +157,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 14n 50p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 50p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 50p> [fixed point]. Controlled behavior not changed. @@ -200,9 +164,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 14n 23p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_on.cif.out index bf40bd69d5c5a7d9ed8441556ed45ff3252b0bf0..75cf9676b187c60fbe7645d9e38ce5a9548f0685 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_algos_on.cif.out @@ -233,9 +233,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [fixed point]. Controlled behavior not changed. @@ -243,41 +240,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer2.count = 3 and buffer1.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 0 and buffer1.add)) -> buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) -> buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) -> buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and buffer3.count = 0 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) -> (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 1) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 and buffer1.count = 1) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.add and (buffer3.count = 1 and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and buffer3.count = 1 and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)))))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.add and buffer3.count = 1 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer2.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.remove or buffer3.count != 1 or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer2.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 0 or buffer1.count != 3)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 0 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)))) and ((buffer3.count != 1 or buffer2.count != 0 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 0 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)))) and ((buffer3.count != 1 or buffer2.count != 0 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.remove or buffer2.count != 3) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or buffer3.count != 1 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or (buffer3.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.remove or buffer2.count != 3) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and (buffer3.add or (buffer3.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or buffer3.count != 1 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.add or (buffer3.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 3)))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) -> <bdd 16n 44p>. @@ -289,9 +256,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -299,9 +263,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_dcsh_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_dcsh_on.cif.out index e7d34fb2a8c003c6390f81bdc5cdd1b1b3edf211..ebdd04395e3784f3ef753c520e99416a665ae4be 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_dcsh_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_dcsh_on.cif.out @@ -212,9 +212,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [fixed point]. Controlled behavior not changed. @@ -222,41 +219,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer1.count = 3 and buffer2.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.count = 0 and buffer2.add) or buffer3.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.count = 0 and buffer2.add) or buffer3.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.remove and (buffer3.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.remove and (buffer3.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))))) -> (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.count = 1 and buffer2.add) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.count = 1 and buffer2.add) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))))) or (buffer3.add and (buffer3.count = 1 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))))) or (buffer3.add and (buffer3.count = 1 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer3.count != 3))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.remove or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.remove or (buffer1.count != 3 or buffer1.add)) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))))) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and (buffer3.add or buffer3.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.remove or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.remove or (buffer1.count != 3 or buffer1.add)) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))))) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and (buffer3.add or buffer3.count != 3)))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) -> <bdd 16n 44p>. @@ -268,9 +235,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -278,9 +242,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_force_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_force_on.cif.out index 843037823972daca610c6597715b0418950aeb45..46fab1c8865fc509c4e05b5ad93030e085da57c1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_force_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_force_on.cif.out @@ -160,9 +160,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [fixed point]. Controlled behavior not changed. @@ -170,41 +167,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer1.count = 3 and buffer2.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.count = 0 and (buffer3.add and buffer1.count = 0) and (buffer2.add and (buffer2.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.count = 0 and (buffer3.add and buffer1.count = 0) and (buffer2.add and (buffer2.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer3.add and (buffer1.count = 0 and (buffer2.add and buffer2.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer3.add and (buffer1.count = 0 and (buffer2.add and buffer2.count = 0)) -> buffer3.count = 0 and buffer3.add and (buffer1.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer3.count = 0 and (buffer3.add and buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer3.add and (buffer1.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer3.count = 0 and (buffer3.add and buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.add and buffer2.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer1.add))) -> buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.count = 0 and buffer1.add) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and buffer2.count = 0) or buffer3.count = 1 and buffer3.add and (buffer1.count = 1 and (buffer2.count = 0 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.count = 0 and buffer1.add) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and buffer2.count = 0) or buffer3.count = 1 and buffer3.add and (buffer1.count = 1 and (buffer2.count = 0 and buffer1.add))) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.remove and (buffer2.count = 0 and buffer1.add))) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.remove and buffer2.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer1.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 1 and (buffer3.add and buffer1.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.remove and (buffer2.count = 0 and buffer1.add))) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.remove and buffer2.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer1.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 1 and (buffer3.add and buffer1.count = 1) and (buffer2.remove and (buffer2.count = 0 and buffer1.add)))) -> buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 1 and buffer3.add and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and buffer3.add and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and buffer2.count = 0))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 1 and buffer3.add and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and buffer3.add and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and buffer2.count = 0))) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 0 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or (buffer3.count = 0 and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer1.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or (buffer3.count = 1 and (buffer3.add and buffer1.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and buffer3.add and (buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 0 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or (buffer3.count = 0 and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer1.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or (buffer3.count = 1 and (buffer3.add and buffer1.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and buffer3.add and (buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))))) -> (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 0 and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add))) or (buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer3.count = 2 and (buffer3.add and buffer1.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))))) or (buffer3.count = 2 and (buffer3.add and buffer1.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 1 and (buffer2.remove and buffer2.count = 0)) or buffer3.count = 1 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 1 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or buffer3.count = 1 and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or (buffer3.count = 1 and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 1 and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 0 and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add))) or (buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 0 and (buffer2.remove and buffer2.count = 0)) or buffer3.count = 2 and (buffer3.add and buffer1.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))))) or (buffer3.count = 2 and (buffer3.add and buffer1.count = 2) and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 1 and (buffer2.remove and buffer2.count = 0)) or buffer3.count = 1 and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 1 and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or buffer3.count = 1 and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or (buffer3.count = 1 and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 1 and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))))) -> buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or (buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 2 and buffer3.add and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or (buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 2 and buffer3.add and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer3.add and (buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) -> <bdd 14n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 14n 27p> -> (buffer3.count != 0 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 0 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 0 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer3.count != 0 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer3.count != 0 or buffer1.count != 3) and (buffer3.count != 2 or (buffer3.remove or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count != 2 or (buffer3.remove or buffer1.count = 1) or (buffer1.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 2 or buffer3.remove or (buffer1.count != 1 or (buffer2.remove or buffer2.count != 3))))) and ((buffer3.count != 2 or (buffer3.remove or buffer1.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3)))) and ((buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 3) and buffer3.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count != 0 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 0 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 0 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer3.count != 0 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer3.count != 0 or buffer1.count != 3) and (buffer3.count != 2 or (buffer3.remove or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count != 2 or (buffer3.remove or buffer1.count = 1) or (buffer1.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 2 or buffer3.remove or (buffer1.count != 1 or (buffer2.remove or buffer2.count != 3))))) and ((buffer3.count != 2 or (buffer3.remove or buffer1.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3)))) and ((buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 3) and buffer3.count != 3)))) -> <bdd 13n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 13n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or (buffer1.count != 3 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and buffer3.count != 3)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or (buffer1.count != 3 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and buffer3.count != 3)))) -> <bdd 12n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 12n 27p> -> (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.count != 1 or buffer1.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.count != 1 or buffer1.add)) and (buffer3.count != 1 or (buffer1.count != 3 or buffer2.count != 3)) and ((buffer3.count != 3 or buffer3.remove or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count != 3 or buffer3.remove or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 3 or (buffer3.remove or buffer1.count != 3) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count != 3 or buffer3.remove or (buffer1.count != 3 or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count != 3 or buffer3.remove or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 3 or buffer3.add)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.count != 1 or buffer1.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.count != 1 or buffer1.add)) and (buffer3.count != 1 or (buffer1.count != 3 or buffer2.count != 3)) and ((buffer3.count != 3 or buffer3.remove or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count != 3 or buffer3.remove or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 3 or (buffer3.remove or buffer1.count != 3) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count != 3 or buffer3.remove or (buffer1.count != 3 or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count != 3 or buffer3.remove or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 3 or buffer3.add)))) -> <bdd 14n 26p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 14n 26p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) -> <bdd 14n 26p>. @@ -216,9 +183,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 14n 26p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 26p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 26p> [fixed point]. Controlled behavior not changed. @@ -226,9 +190,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.remove and buffer2.count = 3) or (buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 1 and (buffer2.remove and buffer2.count = 3) or ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 3 and (buffer2.add and buffer1.remove) or (buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 3 and (buffer2.remove and ((buffer2.count = 0 or buffer2.count = 2) and buffer1.remove))) or ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 3 and (buffer2.remove and (buffer2.count = 1 and buffer1.remove)) or (buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 3 and (buffer2.remove and buffer2.count = 3) or (buffer3.count = 1 and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.remove and buffer2.count = 3) or (buffer3.count = 1 and buffer1.count = 1 and (buffer2.remove and buffer2.count = 3) or buffer3.count = 1 and buffer1.count = 3 and (buffer2.add and buffer1.remove)))) or (buffer3.count = 1 and buffer1.count = 3 and (buffer2.remove and ((buffer2.count = 0 or buffer2.count = 2) and buffer1.remove)) or buffer3.count = 1 and buffer1.count = 3 and (buffer2.remove and (buffer2.count = 1 and buffer1.remove)) or (buffer3.count = 1 and buffer1.count = 3 and (buffer2.remove and buffer2.count = 3) or buffer3.count = 3 and buffer3.add and ((buffer1.count = 0 or buffer1.count = 2) and (buffer2.remove and buffer2.count = 3))) or (buffer3.count = 3 and buffer3.add and (buffer1.count = 1 and (buffer2.remove and buffer2.count = 3)) or buffer3.count = 3 and buffer3.add and (buffer1.count = 3 and ((buffer2.count = 0 or buffer2.count = 2) and buffer1.remove)) or (buffer3.count = 3 and buffer3.add and (buffer1.count = 3 and (buffer2.count = 1 and buffer1.remove)) or (buffer3.count = 3 and buffer3.add and (buffer1.count = 3 and buffer2.count = 3) or buffer3.count = 3 and buffer3.remove)))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_slidwin_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_slidwin_on.cif.out index 035619a4fd9c5bb8aaa777d971bd45f34c5ff276..f68bc0d6b7bac69e815a0e7c756a96d742b87853 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_slidwin_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algo_slidwin_on.cif.out @@ -161,9 +161,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [fixed point]. Controlled behavior not changed. @@ -171,41 +168,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer2.count = 3 and buffer1.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.count = 0 and (buffer3.add and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.count = 0 and (buffer3.add and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer3.add and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer3.add and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) -> buffer3.count = 0 and buffer3.add and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 0 and (buffer3.add and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer3.add and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 0 and (buffer3.add and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) -> buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) -> buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.add and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.add) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) -> buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) -> buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) or (buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) or (buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)))) -> buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or (buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1))) or buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or (buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 or buffer1.count = 1))) or buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)))) -> buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or (buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))))) -> (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))) -> buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.count = 2 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.count = 2 and (buffer3.add and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))))) or (buffer3.count = 2 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 2 and (buffer3.add and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 2 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)) or buffer3.count = 1 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.count = 1 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.count = 1 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 1 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0) or buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.count = 2 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.count = 2 and (buffer3.add and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1))))) or (buffer3.count = 2 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 0)) or buffer3.count = 2 and (buffer3.add and buffer2.remove) and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 2 and buffer3.add and (buffer2.remove and (buffer2.count = 0 and buffer1.count = 1)) or buffer3.count = 1 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 0)) or (buffer3.count = 1 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) or (buffer3.count = 1 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 1 and buffer2.remove and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer2.remove and (buffer2.count = 0 and buffer1.count = 1))))) -> (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or (buffer3.remove or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 2 or buffer3.remove or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 1 or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or (buffer3.remove or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 2 or buffer3.remove or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 1 or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer3.count != 0 or buffer2.remove or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.count != 0 or buffer2.remove or (buffer2.count != 1 or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.remove or buffer2.count != 3)) and (buffer3.count != 0 or buffer2.add or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.count != 0 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and (buffer3.count != 2 or (buffer3.remove or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and (buffer3.count != 2 or buffer3.remove or (buffer2.remove or buffer2.count != 3)))) and ((buffer3.count != 2 or (buffer3.remove or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.count != 2 or buffer3.remove or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer2.remove or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.count != 1 or buffer2.remove or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count != 0 or buffer2.remove or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.count != 0 or buffer2.remove or (buffer2.count != 1 or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.remove or buffer2.count != 3)) and (buffer3.count != 0 or buffer2.add or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.count != 0 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and (buffer3.count != 2 or (buffer3.remove or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3))) and (buffer3.count != 2 or buffer3.remove or (buffer2.remove or buffer2.count != 3)))) and ((buffer3.count != 2 or (buffer3.remove or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and (buffer3.count != 2 or buffer3.remove or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer2.remove or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3)))) and ((buffer3.count != 1 or buffer2.remove or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3)))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.add) or (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer3.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.remove) or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.add) or (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer3.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count != 3) and (buffer3.count != 3 or (buffer3.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or buffer3.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or (buffer3.remove or buffer2.count != 3)) and (buffer3.count != 3 or buffer3.add)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count != 3) and (buffer3.count != 3 or (buffer3.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or buffer3.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or (buffer3.remove or buffer2.count != 3)) and (buffer3.count != 3 or buffer3.add)))) -> <bdd 14n 32p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 14n 32p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) -> <bdd 14n 32p>. @@ -217,9 +184,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 14n 32p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 32p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 32p> [fixed point]. Controlled behavior not changed. @@ -227,9 +191,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (buffer3.count = 0 or buffer3.count = 2) and buffer2.add and (buffer1.count = 3 and buffer1.remove) or ((buffer3.count = 0 or buffer3.count = 2) and buffer2.remove and ((buffer2.count = 0 or buffer2.count = 2) and (buffer1.count = 3 and buffer1.remove)) or (buffer3.count = 0 or buffer3.count = 2) and buffer2.remove and (buffer2.count = 1 and (buffer1.count = 3 and buffer1.remove))) or ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.remove and buffer2.count = 3) or buffer3.count = 1 and buffer2.add and (buffer1.count = 3 and buffer1.remove) or (buffer3.count = 1 and buffer2.remove and ((buffer2.count = 0 or buffer2.count = 2) and (buffer1.count = 3 and buffer1.remove)) or buffer3.count = 1 and buffer2.remove and (buffer2.count = 1 and (buffer1.count = 3 and buffer1.remove)))) or (buffer3.count = 1 and (buffer2.remove and buffer2.count = 3) or buffer3.count = 3 and (buffer3.add and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 2) and (buffer1.count = 3 and buffer1.remove)) or (buffer3.count = 3 and (buffer3.add and buffer2.add) and (buffer2.count = 1 and (buffer1.count = 3 and buffer1.remove)) or buffer3.count = 3 and buffer3.add and (buffer2.add and (buffer2.count = 3 and buffer1.count = 3))) or (buffer3.count = 3 and (buffer3.add and buffer2.remove) and ((buffer2.count = 0 or buffer2.count = 2) and (buffer1.count = 3 and buffer1.remove)) or buffer3.count = 3 and (buffer3.add and buffer2.remove) and (buffer2.count = 1 and (buffer1.count = 3 and buffer1.remove)) or (buffer3.count = 3 and buffer3.add and (buffer2.remove and buffer2.count = 3) or buffer3.count = 3 and buffer3.remove))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_off.cif.out index a876ca3f2129a02d38e6cc606a828793ea4d89b0..cbf63466b963fba45e6430b78ad87bc09c623f2e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_off.cif.out @@ -147,9 +147,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [fixed point]. Controlled behavior not changed. @@ -157,41 +154,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer1.count = 3 and buffer2.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 and buffer2.add) and (buffer3.add and (buffer2.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 and buffer2.add) and (buffer3.add and (buffer2.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer3.add and buffer2.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer3.add and buffer2.count = 0)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer3.add and buffer2.count = 0)) or buffer3.count = 0 and (buffer1.count = 1 and buffer2.add) and (buffer3.add and (buffer2.count = 0 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and (buffer3.add and buffer2.count = 0)) or buffer3.count = 0 and (buffer1.count = 1 and buffer2.add) and (buffer3.add and (buffer2.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer1.count = 0 and (buffer2.add and (buffer3.add and buffer2.count = 0)) or buffer3.count = 1 and (buffer1.count = 1 and buffer2.add) and (buffer3.add and (buffer2.count = 0 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.add and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 and buffer1.add)) or (buffer3.count = 1 and buffer1.count = 0 and (buffer2.add and (buffer3.add and buffer2.count = 0)) or buffer3.count = 1 and (buffer1.count = 1 and buffer2.add) and (buffer3.add and (buffer2.count = 0 and buffer1.add))) -> buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.count = 0 and buffer1.add) or (buffer3.count = 1 and buffer1.count = 0 and (buffer3.add and buffer2.count = 0) or buffer3.count = 1 and buffer1.count = 1 and (buffer3.add and (buffer2.count = 0 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.count = 0 and buffer1.count = 1 and (buffer2.count = 0 and buffer1.add) or (buffer3.count = 1 and buffer1.count = 0 and (buffer3.add and buffer2.count = 0) or buffer3.count = 1 and buffer1.count = 1 and (buffer3.add and (buffer2.count = 0 and buffer1.add))) -> <bdd 22n 8p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: <bdd 22n 8p> -> buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 1 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer3.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and (buffer3.add and buffer2.count = 0))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 1 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer3.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.count = 1 and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and (buffer3.add and buffer2.count = 0))) -> <bdd 22n 12p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 22n 12p> -> (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.remove and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add))) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer2.remove and (buffer2.count = 0 and buffer1.add)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.remove and buffer2.count = 0))) -> <bdd 22n 18p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 22n 18p> -> buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or (buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 2 and buffer1.count = 0 and (buffer3.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer1.count = 2 and (buffer3.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 2 and buffer1.count = 1 and (buffer3.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 0 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or (buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.count = 2 and buffer1.count = 0 and (buffer3.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.count = 2 and buffer1.count = 2 and (buffer3.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add)) or buffer3.count = 2 and buffer1.count = 1 and (buffer3.add and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.count = 1 and buffer1.count = 2 and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.add) or buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) -> <bdd 22n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 22n 27p> -> (buffer3.count != 0 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 0 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 0 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 0 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 0 or buffer1.count != 3))) and ((buffer3.count != 2 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.remove or (buffer3.remove or buffer2.count != 3))) and (buffer3.count != 2 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer3.add))) and ((buffer3.count != 2 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or buffer3.remove or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 2 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.add or buffer3.add))) and (buffer3.count != 2 or buffer1.count != 1 or (buffer2.remove or (buffer3.remove or buffer2.count != 3)))))) and ((buffer3.count != 2 or buffer1.count != 1 or (buffer2.remove or buffer3.add)) and (buffer3.count != 2 or (buffer1.count != 1 or buffer2.add) or (buffer3.remove or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 2 or buffer1.count != 1 or (buffer2.add or buffer3.add)) and ((buffer3.count != 2 or buffer1.count != 3) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))))) and ((buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 3) and buffer3.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count != 0 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 0 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 0 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 0 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 0 or buffer1.count != 3))) and ((buffer3.count != 2 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.remove or (buffer3.remove or buffer2.count != 3))) and (buffer3.count != 2 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer3.add))) and ((buffer3.count != 2 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or buffer3.remove or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 2 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.add or buffer3.add))) and (buffer3.count != 2 or buffer1.count != 1 or (buffer2.remove or (buffer3.remove or buffer2.count != 3)))))) and ((buffer3.count != 2 or buffer1.count != 1 or (buffer2.remove or buffer3.add)) and (buffer3.count != 2 or (buffer1.count != 1 or buffer2.add) or (buffer3.remove or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 2 or buffer1.count != 1 or (buffer2.add or buffer3.add)) and ((buffer3.count != 2 or buffer1.count != 3) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))))) and ((buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 3) and buffer3.count != 3)))) -> <bdd 20n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 20n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or (buffer1.count != 3 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and buffer3.count != 3)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 1) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.remove or buffer2.count != 3))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))) and (buffer3.count != 1 or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer3.count != 1 or (buffer1.count != 3 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or (buffer2.count != 1 or buffer1.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.add))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and buffer3.count != 3)))) -> <bdd 19n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 19n 27p> -> (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.count != 1 or buffer1.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.count != 1 or buffer1.add))))) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 3 or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.remove or buffer2.count != 3))) and ((buffer3.count != 3 or buffer1.count = 1 or (buffer1.count = 3 or buffer3.add)) and (buffer3.count != 3 or buffer1.count != 1 or (buffer3.remove or buffer2.count != 3))) and ((buffer3.count != 3 or (buffer1.count != 1 or buffer3.add)) and (buffer3.count != 3 or (buffer1.count != 3 or buffer3.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and ((buffer3.count != 3 or buffer1.count != 3 or (buffer3.remove or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count != 3 or buffer1.count != 3 or (buffer3.remove or buffer2.count != 3)) and (buffer3.count != 3 or (buffer1.count != 3 or buffer3.add)))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer2.count != 1 or buffer1.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer2.count != 1 or buffer1.add))))) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer2.count != 3)) and (buffer3.count != 3 or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.remove or buffer2.count != 3))) and ((buffer3.count != 3 or buffer1.count = 1 or (buffer1.count = 3 or buffer3.add)) and (buffer3.count != 3 or buffer1.count != 1 or (buffer3.remove or buffer2.count != 3))) and ((buffer3.count != 3 or (buffer1.count != 1 or buffer3.add)) and (buffer3.count != 3 or (buffer1.count != 3 or buffer3.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer1.add))) and ((buffer3.count != 3 or buffer1.count != 3 or (buffer3.remove or (buffer2.count != 1 or buffer1.add))) and ((buffer3.count != 3 or buffer1.count != 3 or (buffer3.remove or buffer2.count != 3)) and (buffer3.count != 3 or (buffer1.count != 3 or buffer3.add)))))) -> <bdd 17n 26p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 17n 26p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) -> <bdd 17n 26p>. @@ -203,9 +170,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 17n 26p> [restricted to current/previous controlled-behavior predicate: <bdd 17n 26p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 17n 26p> [fixed point]. Controlled behavior not changed. @@ -213,9 +177,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 17n 22p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_on.cif.out index 8d782dc769f27c3b1e47c649c9ea513947d18cf9..779d691e053b5abb4e10d149feeeaa5e4a93fc6e 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_algos_on.cif.out @@ -234,9 +234,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [fixed point]. Controlled behavior not changed. @@ -244,41 +241,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer1.count = 3 and buffer2.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.count = 0 and buffer2.add) or buffer3.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.count = 0 and buffer2.add) or buffer3.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.remove and (buffer3.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.remove and (buffer3.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))))) -> (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.count = 1 and buffer2.add) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.count = 1 and buffer2.add) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))))) or (buffer3.add and (buffer3.count = 1 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))))) or (buffer3.add and (buffer3.count = 1 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer3.count != 3))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.remove or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.remove or (buffer1.count != 3 or buffer1.add)) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))))) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and (buffer3.add or buffer3.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.remove or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.remove or (buffer1.count != 3 or buffer1.add)) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))))) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and (buffer3.add or buffer3.count != 3)))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) -> <bdd 16n 44p>. @@ -290,9 +257,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -300,9 +264,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_off.cif.out index bc42bd43961d67727a3edd7568e81e763938a6d9..c7f54a62ae0e1cb2e754810d1b8d05606867b5e1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_off.cif.out @@ -155,9 +155,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3) [restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3) [fixed point]. Controlled behavior not changed. @@ -165,41 +162,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer2.count = 3 and (buffer3.count = 3 and buffer1.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer2.count = 0 and (buffer2.add and buffer3.count = 0) and (buffer3.add and (buffer1.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer2.count = 0 and (buffer2.add and buffer3.count = 0) and (buffer3.add and (buffer1.count = 0 and buffer1.add)) -> buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) -> buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) or buffer2.count = 0 and (buffer2.add and buffer3.count = 0) and (buffer3.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) or buffer2.count = 0 and (buffer2.add and buffer3.count = 0) and (buffer3.add and (buffer1.count = 1 and buffer1.add)) -> buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) -> buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.count = 0 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.count = 0 and (buffer2.add and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.count = 0 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.count = 0 and (buffer2.add and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add))) -> buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 1 and buffer1.add))) -> buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 1 and buffer1.add))) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.count = 1 and (buffer2.add and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 1 and buffer1.add))) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.count = 1 and (buffer2.add and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add)))) -> buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1)) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1)) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1)))) -> buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 2 and buffer1.add) or buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 1))) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or (buffer2.count = 1 and (buffer2.add and buffer3.count = 1) and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 1))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 2 and buffer1.add) or buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 1))) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 1 and buffer2.add and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or (buffer2.count = 1 and (buffer2.add and buffer3.count = 1) and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 1 and buffer2.add and (buffer3.count = 1 and (buffer3.add and buffer1.count = 1))))) -> buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add) or buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1)) or (buffer2.count = 1 and buffer2.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.count = 1 and buffer2.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 1 and buffer2.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add) or buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1)) or (buffer2.count = 1 and buffer2.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.count = 1 and buffer2.add and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer2.count = 1 and buffer2.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1))) -> (buffer2.count != 0 or buffer3.count != 0 or (buffer1.count != 2 or buffer1.add)) and (buffer2.count != 0 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count != 0 or buffer3.count != 2 or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.count != 0 or buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and ((buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count != 0 or buffer3.count != 1 or (buffer1.count != 2 or buffer1.add)) and ((buffer2.count != 0 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count != 0 or buffer3.count != 3) and buffer2.count != 2))) and ((buffer2.count != 1 or buffer2.remove or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count != 1 or buffer2.remove or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count != 1 or (buffer2.remove or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and ((buffer2.count != 1 or buffer2.remove or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.count != 1 or buffer2.remove or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.count != 1 or buffer2.remove or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count != 1 or buffer2.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count != 1 or (buffer2.remove or buffer3.count != 3)) and ((buffer2.count != 1 or buffer2.add) and buffer2.count != 3)))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.count != 0 or buffer3.count != 0 or (buffer1.count != 2 or buffer1.add)) and (buffer2.count != 0 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count != 0 or buffer3.count != 2 or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.count != 0 or buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and ((buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count != 0 or buffer3.count != 1 or (buffer1.count != 2 or buffer1.add)) and ((buffer2.count != 0 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count != 0 or buffer3.count != 3) and buffer2.count != 2))) and ((buffer2.count != 1 or buffer2.remove or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count != 1 or buffer2.remove or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count != 1 or (buffer2.remove or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and ((buffer2.count != 1 or buffer2.remove or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.count != 1 or buffer2.remove or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.count != 1 or buffer2.remove or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count != 1 or buffer2.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count != 1 or (buffer2.remove or buffer3.count != 3)) and ((buffer2.count != 1 or buffer2.add) and buffer2.count != 3)))) -> (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.count = 0 or buffer2.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.count = 0 or buffer2.count = 1)))) -> <bdd 12n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 12n 27p> -> (buffer2.count != 0 or (buffer3.count != 0 or buffer1.count != 3)) and (buffer2.count != 0 or buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)) and ((buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count != 0 or (buffer3.count != 1 or buffer1.count != 3))) and ((buffer2.count != 0 or buffer3.count != 3) and (buffer2.count != 2 or buffer2.remove or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count != 2 or buffer2.remove or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.count != 2 or buffer2.remove or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.count != 2 or buffer2.remove or (buffer3.count != 1 or buffer1.count != 3)) and (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)) and ((buffer2.count != 2 or buffer2.add) and (buffer2.count != 1 or (buffer3.count != 0 or buffer1.count != 3))) and ((buffer2.count != 1 or buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)) and (buffer2.count != 1 or (buffer3.count != 2 or buffer3.add)) and ((buffer2.count != 1 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count != 1 or buffer3.count != 3) and buffer2.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.count != 0 or (buffer3.count != 0 or buffer1.count != 3)) and (buffer2.count != 0 or buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)) and ((buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count != 0 or (buffer3.count != 1 or buffer1.count != 3))) and ((buffer2.count != 0 or buffer3.count != 3) and (buffer2.count != 2 or buffer2.remove or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count != 2 or buffer2.remove or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.count != 2 or buffer2.remove or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.count != 2 or buffer2.remove or (buffer3.count != 1 or buffer1.count != 3)) and (buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)) and ((buffer2.count != 2 or buffer2.add) and (buffer2.count != 1 or (buffer3.count != 0 or buffer1.count != 3))) and ((buffer2.count != 1 or buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)) and (buffer2.count != 1 or (buffer3.count != 2 or buffer3.add)) and ((buffer2.count != 1 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count != 1 or buffer3.count != 3) and buffer2.count != 3)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 11n 27p> -> (buffer2.count != 0 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 0 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 0 or buffer3.count != 3) and ((buffer2.count != 2 or (buffer2.remove or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 2 or buffer2.remove or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)) and ((buffer2.count != 2 or buffer2.add) and (buffer2.count != 1 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer2.count != 1 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 1 or buffer3.count != 3) and buffer2.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.count != 0 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 0 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 0 or buffer3.count != 3) and ((buffer2.count != 2 or (buffer2.remove or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 2 or buffer2.remove or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer2.count != 2 or (buffer2.remove or buffer3.count != 3)) and ((buffer2.count != 2 or buffer2.add) and (buffer2.count != 1 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer2.count != 1 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 1 or buffer3.count != 3) and buffer2.count != 3))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3) or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count != 1 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 1 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 1 or buffer3.count != 3 or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and buffer2.count != 3))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3) or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count != 1 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 1 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 1 or buffer3.count != 3 or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and buffer2.count != 3))) -> <bdd 14n 26p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 14n 26p> [fixed point]. Controlled behavior: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3) -> <bdd 14n 26p>. @@ -211,9 +178,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 14n 26p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 26p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 26p> [fixed point]. Controlled behavior not changed. @@ -221,9 +185,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (buffer2.count = 0 or buffer2.count = 2) and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 3 and buffer1.remove) or ((buffer2.count = 0 or buffer2.count = 2) and buffer3.count = 1 and (buffer1.count = 3 and buffer1.remove) or (buffer2.count = 0 or buffer2.count = 2) and buffer3.count = 3 and (buffer3.add and (buffer1.count = 3 and buffer1.remove))) or ((buffer2.count = 0 or buffer2.count = 2) and (buffer3.count = 3 and buffer3.remove) or (buffer2.count = 1 and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 3 and buffer1.remove) or buffer2.count = 1 and buffer3.count = 1 and (buffer1.count = 3 and buffer1.remove))) or (buffer2.count = 1 and buffer3.count = 3 and (buffer3.add and (buffer1.count = 3 and buffer1.remove)) or (buffer2.count = 1 and (buffer3.count = 3 and buffer3.remove) or buffer2.count = 3 and buffer2.add and ((buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 3 and buffer1.remove))) or (buffer2.count = 3 and buffer2.add and (buffer3.count = 1 and (buffer1.count = 3 and buffer1.remove)) or buffer2.count = 3 and buffer2.add and (buffer3.count = 3 and (buffer3.add and buffer1.count = 3)) or (buffer2.count = 3 and buffer2.add and (buffer3.count = 3 and buffer3.remove) or buffer2.count = 3 and buffer2.remove))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_on.cif.out index e2db3ce477ca3bdb33549adf8baa81a735ec56b3..4cb715cc6fcb1c3b526255b2b0558a18dc442611 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_algos_on.cif.out @@ -242,9 +242,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) [fixed point]. Controlled behavior not changed. @@ -252,41 +249,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer1.count = 3 and buffer2.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.count = 0 and buffer1.count = 0 and (buffer2.count = 0 and buffer2.add) or buffer3.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer2.count = 0 and buffer2.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer1.count = 0 and (buffer2.count = 0 and buffer2.add) or buffer3.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer2.count = 0 and buffer2.add)) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 0 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 0 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer2.count = 0)) or buffer3.remove and (buffer3.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer2.count = 1 and buffer2.add)))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 1 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.remove and (buffer3.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.add and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))) or (buffer3.remove and (buffer3.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and buffer3.count = 0 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))))) -> (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.count = 1 and buffer2.add) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0 and (buffer2.count = 1 and buffer2.add) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2 and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1 and (buffer2.count = 1 and buffer2.add))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))))) or (buffer3.add and (buffer3.count = 1 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or buffer3.add and ((buffer3.count = 0 or buffer3.count = 2) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0))))) or (buffer3.add and (buffer3.count = 1 and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and buffer2.count = 0) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and buffer2.count = 0)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 1 and buffer2.add)) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer2.count = 0)) or (buffer3.remove and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer2.count = 1 and buffer2.add)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and buffer2.count = 0) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 1 and buffer2.add)))))) -> buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and (buffer3.count = 0 or buffer3.count = 2) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or buffer3.add and buffer3.count = 1 and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1))) or (buffer3.add and buffer3.count = 1 and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.add and buffer3.count = 1 and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 0 and (buffer2.count = 0 or buffer2.count = 1)) or (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer2.count = 0 or buffer2.count = 1))) or buffer3.remove and (buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 1 and (buffer2.count = 0 or buffer2.count = 1))))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and ((buffer3.remove or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and (buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)))) and ((buffer3.remove or buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))))) and ((buffer3.remove or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer3.remove or buffer3.count != 3) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or (buffer3.count = 2 or buffer3.count = 3) or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 2 or (buffer3.count = 3 or buffer1.count != 3)) and (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.count = 1 or (buffer3.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer1.count != 1 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3))) and ((buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer2.count != 2 or buffer2.add))) and (buffer3.count != 1 or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3)) and ((buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer3.count != 3))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.remove or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.remove or (buffer1.count != 3 or buffer1.add)) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))))) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and (buffer3.add or buffer3.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - Forward controlled-behavior: (buffer3.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and ((buffer3.remove or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.remove or buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.remove or (buffer1.count != 3 or buffer1.add)) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3))) and (buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 1 or buffer2.count != 3))))) and ((buffer3.add or (buffer3.count = 1 or buffer3.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.add or buffer3.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 1 or buffer2.count != 3)) and (buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer2.count != 3))) and ((buffer3.add or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and (buffer3.add or buffer3.count != 3)))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer1.count != 3 or buffer2.count != 3) -> <bdd 16n 44p>. @@ -298,9 +265,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -308,9 +272,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_off.cif.out index f71b268dfe1c120e76ea9c93346bbf030031bbb2..3680b6f116e1376b0caa01236bd748d551fd6283 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_off.cif.out @@ -155,9 +155,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) [fixed point]. Controlled behavior not changed. @@ -165,41 +162,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer3.count = 3 and (buffer2.count = 3 and buffer1.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer3.count = 0 and (buffer3.add and buffer2.count = 0) and (buffer2.add and (buffer1.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer3.count = 0 and (buffer3.add and buffer2.count = 0) and (buffer2.add and (buffer1.count = 0 and buffer1.add)) -> buffer3.count = 0 and buffer3.add and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer3.add and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) -> buffer3.count = 0 and buffer3.add and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 0 and (buffer3.add and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer3.add and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 0 and (buffer3.add and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add)) -> buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) -> buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer2.add and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.count = 0) and (buffer2.add and (buffer1.count = 1 and buffer1.add))) -> buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add))) -> buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 1 and buffer1.add))) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 1 and buffer1.add))) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 1 and (buffer3.add and buffer2.count = 1) and (buffer2.add and (buffer1.count = 1 and buffer1.add)))) -> buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and (buffer1.count = 0 or buffer1.count = 1)))) -> buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.count = 0 and buffer1.count = 1)) or (buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.count = 1 and (buffer3.add and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) -> (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 or buffer3.count = 1) and (buffer2.count = 0 and buffer1.count = 1)) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or ((buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 0 or buffer3.count = 1) and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))) -> buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 1) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 2 and (buffer3.add and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.count = 1 and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.count = 1 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or (buffer3.count = 1 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 0) or buffer3.count = 0 and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or (buffer3.count = 0 and (buffer2.count = 0 and buffer1.count = 1) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or (buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 0 and buffer2.count = 1 and (buffer2.add and buffer1.count = 1) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 0 and buffer1.count = 0) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 2 and buffer3.add and (buffer2.count = 0 and buffer1.count = 1)))) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 0)) or buffer3.count = 2 and (buffer3.add and buffer2.count = 1) and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or (buffer3.count = 2 and buffer3.add and (buffer2.count = 1 and (buffer2.add and buffer1.count = 1)) or buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 0)) or (buffer3.count = 1 and buffer2.count = 0 and (buffer1.count = 2 and buffer1.add) or buffer3.count = 1 and (buffer2.count = 0 and buffer1.count = 1) or (buffer3.count = 1 and buffer2.count = 1 and (buffer2.add and buffer1.count = 0) or (buffer3.count = 1 and buffer2.count = 1 and (buffer2.add and (buffer1.count = 2 and buffer1.add)) or buffer3.count = 1 and buffer2.count = 1 and (buffer2.add and buffer1.count = 1))))) -> (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or (buffer3.remove or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 2 or buffer3.remove or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 1 or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 0 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or (buffer3.remove or buffer2.count = 2) or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer3.count != 2 or buffer3.remove or (buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3))))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and ((buffer3.count != 1 or (buffer2.count = 0 or buffer2.count = 1)) and buffer3.count != 3))) -> <bdd 12n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 12n 27p> -> (buffer3.count != 0 or (buffer2.count != 0 or buffer1.count != 3)) and (buffer3.count != 0 or buffer2.count != 2 or (buffer2.remove or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 0 or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.count != 0 or buffer2.count != 3) and (buffer3.count != 2 or buffer3.remove or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.count != 2 or buffer3.remove or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.count != 2 or (buffer3.remove or buffer2.count != 3)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or (buffer2.count != 0 or buffer1.count != 3))) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or buffer1.count != 3)) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count != 1 or (buffer2.count != 1 or buffer1.count != 3)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count != 0 or (buffer2.count != 0 or buffer1.count != 3)) and (buffer3.count != 0 or buffer2.count != 2 or (buffer2.remove or buffer1.count != 3)) and ((buffer3.count != 0 or (buffer2.count != 2 or buffer2.add)) and (buffer3.count != 0 or (buffer2.count != 1 or buffer1.count != 3))) and ((buffer3.count != 0 or buffer2.count != 3) and (buffer3.count != 2 or buffer3.remove or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count != 2 or (buffer2.remove or buffer1.count != 3))) and (buffer3.count != 2 or buffer3.remove or (buffer2.count != 2 or buffer2.add)))) and ((buffer3.count != 2 or buffer3.remove or (buffer2.count != 1 or buffer1.count != 3)) and (buffer3.count != 2 or (buffer3.remove or buffer2.count != 3)) and ((buffer3.count != 2 or buffer3.add) and (buffer3.count != 1 or (buffer2.count != 0 or buffer1.count != 3))) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or buffer1.count != 3)) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count != 1 or (buffer2.count != 1 or buffer1.count != 3)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 11n 27p> -> (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 0 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)))) and ((buffer3.count != 1 or buffer2.count != 0 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 0 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 2) or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 2 or buffer2.add)) and ((buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)))) and ((buffer3.count != 1 or buffer2.count != 0 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 2 or (buffer2.remove or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or (buffer2.count != 2 or buffer2.add))) and ((buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer3.count != 1 or buffer2.count != 3) and buffer3.count != 3))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count != 3) and (buffer3.count != 3 or (buffer3.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or buffer3.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or (buffer3.remove or buffer2.count != 3)) and (buffer3.count != 3 or buffer3.add)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer3.count = 1 or (buffer3.count = 3 or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count = 1 or buffer3.count = 3 or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count = 1 or (buffer3.count = 3 or buffer2.count != 3)) and ((buffer3.count != 1 or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer3.count != 1 or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)))) and ((buffer3.count != 1 or buffer2.count != 3) and (buffer3.count != 3 or (buffer3.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or buffer3.remove or (buffer2.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer3.count != 3 or (buffer3.remove or buffer2.count != 3)) and (buffer3.count != 3 or buffer3.add)))) -> <bdd 14n 26p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.count = 0 or buffer2.count = 2) and buffer2.add or buffer2.count = 1 and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 14n 26p> [fixed point]. Controlled behavior: buffer3.count != 3 or (buffer2.count != 3 or buffer1.count != 3) -> <bdd 14n 26p>. @@ -211,9 +178,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 14n 26p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 26p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 26p> [fixed point]. Controlled behavior not changed. @@ -221,9 +185,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: (buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 0 or buffer2.count = 2) and (buffer1.count = 3 and buffer1.remove) or ((buffer3.count = 0 or buffer3.count = 2) and buffer2.count = 1 and (buffer1.count = 3 and buffer1.remove) or (buffer3.count = 0 or buffer3.count = 2) and buffer2.count = 3 and (buffer2.add and (buffer1.count = 3 and buffer1.remove))) or ((buffer3.count = 0 or buffer3.count = 2) and (buffer2.count = 3 and buffer2.remove) or (buffer3.count = 1 and (buffer2.count = 0 or buffer2.count = 2) and (buffer1.count = 3 and buffer1.remove) or buffer3.count = 1 and buffer2.count = 1 and (buffer1.count = 3 and buffer1.remove))) or (buffer3.count = 1 and buffer2.count = 3 and (buffer2.add and (buffer1.count = 3 and buffer1.remove)) or (buffer3.count = 1 and (buffer2.count = 3 and buffer2.remove) or buffer3.count = 3 and buffer3.add and ((buffer2.count = 0 or buffer2.count = 2) and (buffer1.count = 3 and buffer1.remove))) or (buffer3.count = 3 and buffer3.add and (buffer2.count = 1 and (buffer1.count = 3 and buffer1.remove)) or buffer3.count = 3 and buffer3.add and (buffer2.count = 3 and (buffer2.add and buffer1.count = 3)) or (buffer3.count = 3 and buffer3.add and (buffer2.count = 3 and buffer2.remove) or buffer3.count = 3 and buffer3.remove))) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_on.cif.out index ea1f9ffe179654fb6e3c3219718b281b111b5c9d..fef6c4e8cf15f2d7446e3131ac4b5b8cd557a90b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_algos_on.cif.out @@ -242,9 +242,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3) [restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3) [fixed point]. Controlled behavior not changed. @@ -252,41 +249,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer2.count = 3 and (buffer1.count = 3 and buffer3.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer2.add and (buffer2.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer3.count = 0 and buffer3.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 and buffer1.count = 0) and (buffer1.add and (buffer3.count = 0 and buffer3.add)) -> buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 0 and buffer3.add)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 0 and buffer3.add)) -> buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 0 and buffer3.add)) or buffer2.add and (buffer2.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer3.count = 0 and buffer3.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 0 and buffer3.add)) or buffer2.add and (buffer2.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer3.count = 0 and buffer3.add)) -> buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.add and buffer2.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.add and buffer2.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) -> buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer2.add and buffer2.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) or buffer2.add and (buffer2.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer3.count = 1 and buffer3.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.add and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer2.add and buffer2.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) or buffer2.add and (buffer2.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer3.count = 1 and buffer3.add))) -> buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.count = 0 and buffer1.count = 0 and (buffer3.count = 1 and buffer3.add) or (buffer2.count = 0 and buffer1.count = 1 and (buffer1.add and buffer3.count = 0) or buffer2.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer3.count = 1 and buffer3.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.count = 0 and buffer1.count = 0 and (buffer3.count = 1 and buffer3.add) or (buffer2.count = 0 and buffer1.count = 1 and (buffer1.add and buffer3.count = 0) or buffer2.count = 0 and buffer1.count = 1 and (buffer1.add and (buffer3.count = 1 and buffer3.add))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and buffer3.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) or buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer3.count = 1 and buffer3.add))) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) or buffer2.remove and (buffer2.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer3.count = 1 and buffer3.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and buffer3.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) or buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 1) and (buffer1.add and (buffer3.count = 1 and buffer3.add))) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and (buffer1.add and buffer3.count = 0)) or buffer2.remove and (buffer2.count = 0 and buffer1.count = 1) and (buffer1.add and (buffer3.count = 1 and buffer3.add)))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 1 and buffer3.add)) or (buffer2.remove and buffer2.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.count = 0) or buffer2.remove and buffer2.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 1 and buffer3.add))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 1 and buffer3.add)) or (buffer2.remove and buffer2.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and buffer3.count = 0) or buffer2.remove and buffer2.count = 0 and ((buffer1.count = 0 or buffer1.count = 1) and (buffer3.count = 1 and buffer3.add))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and buffer3.count = 0) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer3.count = 0))) or (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer3.count = 1 and buffer3.add)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer3.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and (buffer3.count = 1 and buffer3.add)))) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer3.count = 0))) or (buffer2.remove and (buffer2.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer3.count = 1 and buffer3.add)) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and buffer3.count = 0) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and (buffer3.count = 1 and buffer3.add))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and buffer3.count = 0) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and (buffer1.add and buffer3.count = 0))) or (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer1.count = 2) and (buffer1.add and (buffer3.count = 1 and buffer3.add)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and buffer3.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and (buffer3.count = 1 and buffer3.add)))) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and buffer3.count = 0) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 1 and buffer3.add)) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 2 and (buffer1.add and buffer3.count = 0))) or (buffer2.remove and (buffer2.count = 0 and buffer1.count = 2) and (buffer1.add and (buffer3.count = 1 and buffer3.add)) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and buffer3.count = 0) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and (buffer3.count = 1 and buffer3.add))))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and (buffer3.count = 0 or buffer3.count = 1))) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 2 and (buffer1.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and (buffer3.count = 0 or buffer3.count = 1)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 2 and (buffer1.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer1.count = 1 and (buffer3.count = 0 or buffer3.count = 1))) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 0 and (buffer3.count = 0 or buffer3.count = 1)) or (buffer2.remove and buffer2.count = 0 and (buffer1.count = 2 and (buffer1.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer2.remove and buffer2.count = 0 and (buffer1.count = 1 and (buffer3.count = 0 or buffer3.count = 1)))) -> (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 0 or buffer3.count != 3))) and ((buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 2 or buffer1.remove or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 2 or (buffer1.remove or buffer3.count != 3)))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.remove or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer2.add or buffer2.count != 0 or (buffer1.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer2.add or buffer2.count != 0 or (buffer1.count != 0 or buffer3.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer1.count != 2) or (buffer1.remove or (buffer3.count != 2 or buffer3.add))) and ((buffer2.add or buffer2.count != 0 or (buffer1.count != 2 or (buffer1.remove or buffer3.count != 3))) and (buffer2.add or buffer2.count != 0 or (buffer1.count != 2 or buffer1.add)))) and ((buffer2.add or buffer2.count != 0 or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and (buffer2.add or buffer2.count != 0 or (buffer1.count != 1 or buffer3.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer2.add or buffer2.count != 2) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 2)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 0 or buffer3.count != 3))) and ((buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 2 or buffer1.remove or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 2 or (buffer1.remove or buffer3.count != 3)))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 2 or buffer1.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.remove or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer2.add or buffer2.count != 0 or (buffer1.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer2.add or buffer2.count != 0 or (buffer1.count != 0 or buffer3.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer1.count != 2) or (buffer1.remove or (buffer3.count != 2 or buffer3.add))) and ((buffer2.add or buffer2.count != 0 or (buffer1.count != 2 or (buffer1.remove or buffer3.count != 3))) and (buffer2.add or buffer2.count != 0 or (buffer1.count != 2 or buffer1.add)))) and ((buffer2.add or buffer2.count != 0 or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and (buffer2.add or buffer2.count != 0 or (buffer1.count != 1 or buffer3.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer1.count != 3)) and ((buffer2.add or buffer2.count != 2) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 2)))))) -> (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 0 or buffer3.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 2) or (buffer1.remove or (buffer3.count != 2 or buffer3.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 2 or (buffer1.remove or buffer3.count != 3)))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 2 or buffer1.add)) and (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.count = 0 or buffer2.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 0 or (buffer3.count != 2 or buffer3.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 0 or buffer3.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 2) or (buffer1.remove or (buffer3.count != 2 or buffer3.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 2 or (buffer1.remove or buffer3.count != 3)))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 2 or buffer1.add)) and (buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.count = 0 or buffer2.count = 1)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and ((buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3)))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.remove or (buffer2.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and (buffer2.remove or buffer2.count != 1 or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count != 1 or buffer3.count != 3)) and (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and ((buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3)))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.remove or (buffer2.count != 1 or buffer1.count = 1) or (buffer1.count = 3 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and (buffer2.remove or buffer2.count != 1 or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count != 1 or buffer3.count != 3)) and (buffer2.remove or (buffer2.count != 1 or buffer1.count != 3)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count = 1 or buffer1.count = 3 or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 1 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer1.count != 3)) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer3.count != 3)))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.remove or buffer2.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count != 1 or buffer3.count != 3)) and (buffer2.remove or buffer2.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer3.count != 3))))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3)))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer3.count != 3))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer3.count != 3)))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.remove or buffer2.count != 1 or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count != 1 or buffer3.count != 3)) and (buffer2.remove or buffer2.count != 1 or (buffer1.count != 3 or (buffer1.remove or buffer3.count != 3))))) and ((buffer2.remove or buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count = 1 or (buffer1.count = 3 or buffer3.count != 3)))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 1 or buffer3.count != 3))) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer1.count != 3 or (buffer1.remove or buffer3.count != 3))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 1 or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer3.count != 3 or buffer3.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer2.count != 1 or buffer1.count != 1 or (buffer3.count != 3 or buffer3.add)) and ((buffer2.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer2.count != 3))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer2.count = 1 or (buffer2.count = 3 or buffer1.count = 1) or (buffer1.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 1 or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count = 1 or (buffer2.count = 3 or buffer1.count != 3) or (buffer1.remove or (buffer3.count != 3 or buffer3.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count != 1 or buffer1.count = 1 or (buffer1.count = 3 or (buffer3.count != 3 or buffer3.add))) and (buffer2.count != 1 or buffer1.count != 1 or (buffer3.count != 3 or buffer3.add)) and ((buffer2.count != 1 or buffer1.count != 3 or (buffer1.remove or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count != 1 or (buffer1.count != 3 or buffer1.add)) and buffer2.count != 3))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer2.count != 3 or (buffer1.count != 3 or buffer3.count != 3) -> <bdd 16n 44p>. @@ -298,9 +265,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -308,9 +272,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_off.cif.out index 7bb7d64d63b19eec915d07a40837b0dd3f990828..5030f909e4891f1a46126af2019f85a2a3d322db 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_off.cif.out @@ -146,9 +146,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) [restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) [fixed point]. Controlled behavior not changed. @@ -156,41 +153,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer1.count = 3 and (buffer2.count = 3 and buffer3.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) -> buffer1.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.count = 0 and buffer2.add and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) or buffer1.remove and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 0)) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer3.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer3.count = 0)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and (buffer2.count = 0 and buffer3.count = 0)) or buffer1.remove and buffer1.count = 0 and (buffer2.add and (buffer2.count = 0 and buffer3.count = 0)) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer2.add) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and buffer1.count = 0 and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) or (buffer1.remove and (buffer1.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) or (buffer1.remove and (buffer1.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and (buffer1.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)))) -> (buffer1.count = 0 or buffer1.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.count = 0 or buffer1.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.count = 0 or buffer1.count = 1) and buffer2.remove and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)))) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or (buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)))) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and buffer3.count = 0)) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and buffer3.count = 0))))) -> buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.remove and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 or buffer3.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer2.remove and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and (buffer1.count = 0 or buffer1.count = 2) and (buffer2.remove and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and buffer1.count = 1 and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 or buffer3.count = 1)))) or (buffer1.add and buffer1.count = 1 and (buffer2.remove and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and (buffer1.count = 0 or buffer1.count = 1) and (buffer2.remove and (buffer2.count = 0 and (buffer3.count = 0 or buffer3.count = 1))))) -> buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and buffer3.count = 1)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 1)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or (buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and buffer3.count = 1)) or buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1)))))) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 1)) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and buffer3.count = 1)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 1)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and buffer3.count = 1)) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2)))) or (buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 1)) or buffer1.add and ((buffer1.count = 0 or buffer1.count = 2) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or (buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and buffer3.count = 1)) or buffer1.add and (buffer1.count = 1 and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1)))))) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 1)) or (buffer1.add and (buffer1.count = 1 and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2)))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.add and buffer3.count = 1)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.add) and ((buffer2.count = 0 or buffer2.count = 1) and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and (buffer3.count = 0 or buffer3.count = 2))) or (buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.add and buffer3.count = 1)) or buffer1.remove and ((buffer1.count = 0 or buffer1.count = 1) and buffer2.remove) and (buffer2.count = 0 and (buffer3.remove and (buffer3.count = 0 or buffer3.count = 1))))))) -> (buffer1.remove or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count = 2 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.remove or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.remove or (buffer1.count != 1 or buffer2.count = 2) or (buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.remove or (buffer1.count != 1 or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))))) and ((buffer1.remove or buffer1.count != 1 or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer1.remove or buffer1.count != 3) and (buffer1.add or (buffer1.count = 2 or buffer1.count = 3) or (buffer2.count = 2 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3)))) and ((buffer1.add or buffer1.count = 2 or (buffer1.count = 3 or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.add or buffer1.count = 2 or (buffer1.count = 3 or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or (buffer1.count = 0 or buffer1.count = 1))))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.remove or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count = 2 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.remove or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.remove or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.remove or (buffer1.count != 1 or buffer2.count = 2) or (buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.remove or (buffer1.count != 1 or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))))) and ((buffer1.remove or buffer1.count != 1 or (buffer2.count = 0 or buffer2.count = 1)) and ((buffer1.remove or buffer1.count != 3) and (buffer1.add or (buffer1.count = 2 or buffer1.count = 3) or (buffer2.count = 2 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3)))) and ((buffer1.add or buffer1.count = 2 or (buffer1.count = 3 or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.add or buffer1.count = 2 or (buffer1.count = 3 or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or (buffer1.count = 0 or buffer1.count = 1))))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.count = 1 or (buffer1.count = 3 or buffer2.remove) or (buffer2.count = 1 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer2.remove) or (buffer2.count != 1 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count = 1 or (buffer1.count = 3 or buffer2.remove) or (buffer2.count != 1 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.remove or buffer2.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer2.add) or (buffer2.count = 2 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer1.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.count != 1 or buffer2.remove or (buffer2.count != 1 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count != 1 or (buffer2.remove or buffer2.count != 1) or (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))) and ((buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and ((buffer1.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer1.count != 3)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.count = 1 or (buffer1.count = 3 or buffer2.remove) or (buffer2.count = 1 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.count = 1 or (buffer1.count = 3 or buffer2.remove) or (buffer2.count != 1 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count = 1 or (buffer1.count = 3 or buffer2.remove) or (buffer2.count != 1 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.remove or buffer2.count != 3)) and (buffer1.count = 1 or (buffer1.count = 3 or buffer2.add) or (buffer2.count = 2 or buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and ((buffer1.count = 1 or buffer1.count = 3 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and (buffer1.count = 1 or buffer1.count = 3 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer1.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count != 1 or (buffer2.remove or buffer2.count = 1) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.count != 1 or buffer2.remove or (buffer2.count != 1 or (buffer3.remove or buffer3.count != 3))) and (buffer1.count != 1 or (buffer2.remove or buffer2.count != 1) or (buffer3.add or (buffer3.count = 0 or buffer3.count = 1)))) and ((buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or (buffer3.remove or buffer3.count != 3))) and ((buffer1.count != 1 or (buffer2.add or buffer2.count = 2) or (buffer2.count = 3 or buffer3.add or (buffer3.count = 0 or buffer3.count = 1))) and ((buffer1.count != 1 or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and buffer1.count != 3)))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.remove or buffer1.count != 3) and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.remove or buffer2.remove or (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3))) and (buffer1.remove or buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer1.remove or (buffer2.remove or buffer2.count != 3)) and (buffer1.remove or buffer2.add or (buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)))) and ((buffer1.remove or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.remove or (buffer2.count != 1 or buffer3.count != 3))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.add or (buffer1.count != 1 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)))) and ((buffer1.add or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.add or (buffer1.count != 1 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.remove or buffer2.remove or (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3))) and (buffer1.remove or buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer1.remove or (buffer2.remove or buffer2.count != 3)) and (buffer1.remove or buffer2.add or (buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)))) and ((buffer1.remove or buffer2.add or (buffer2.count = 0 or buffer2.count = 1)) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.remove or (buffer2.count != 1 or buffer3.count != 3))) and (buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or (buffer2.remove or buffer2.count != 3))))) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and ((buffer1.add or (buffer1.count != 1 or buffer2.remove) or (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3))) and (buffer1.add or buffer1.count != 1 or (buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)))) and ((buffer1.add or buffer1.count != 1 or (buffer2.remove or buffer2.count != 3)) and (buffer1.add or (buffer1.count != 1 or buffer2.add) or (buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))) and (buffer1.add or buffer1.count != 3)))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.remove or buffer3.count != 3) and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer1.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.remove or buffer2.count != 1 or (buffer3.add or buffer3.count != 3)) and ((buffer1.remove or buffer2.count != 3) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count != 1 or (buffer3.add or buffer3.count != 3))))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and (buffer1.add or (buffer1.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.add or buffer3.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 1 or (buffer3.add or buffer3.count != 3))) and ((buffer1.add or (buffer1.count != 1 or buffer2.count != 3)) and (buffer1.add or buffer1.count != 3)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - Forward controlled-behavior: (buffer1.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.remove or buffer2.count != 1 or (buffer3.add or buffer3.count != 3)) and ((buffer1.remove or buffer2.count != 3) and ((buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count = 1 or buffer2.count = 3 or (buffer3.add or buffer3.count != 3))) and (buffer1.add or (buffer1.count = 1 or buffer1.count = 3) or (buffer2.count != 1 or (buffer3.add or buffer3.count != 3))))) and ((buffer1.add or buffer1.count = 1 or (buffer1.count = 3 or buffer2.count != 3)) and (buffer1.add or (buffer1.count != 1 or buffer2.count = 1) or (buffer2.count = 3 or (buffer3.add or buffer3.count != 3))) and ((buffer1.add or buffer1.count != 1 or (buffer2.count != 1 or (buffer3.add or buffer3.count != 3))) and ((buffer1.add or (buffer1.count != 1 or buffer2.count != 3)) and (buffer1.add or buffer1.count != 3)))) -> <bdd 14n 50p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 14n 50p> [fixed point]. Controlled behavior: buffer1.count != 3 or (buffer2.count != 3 or buffer3.count != 3) -> <bdd 14n 50p>. @@ -202,9 +169,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 14n 50p> [restricted to current/previous controlled-behavior predicate: <bdd 14n 50p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 14n 50p> [fixed point]. Controlled behavior not changed. @@ -212,9 +176,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 14n 23p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_on.cif.out index b8782915b97652b02b3915ead7c8453157049220..ac24e20550b3c194d39c72b984e81bbafb0dff0a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_algos_on.cif.out @@ -233,9 +233,6 @@ Synthesis round 1: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3) [restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3) [fixed point]. Controlled behavior not changed. @@ -243,41 +240,11 @@ Synthesis round 1: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: buffer2.count = 3 and (buffer3.count = 3 and buffer1.count = 3) [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Computing forward controlled-behavior predicate: Forward controlled-behavior: buffer2.add and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.count = 0 and buffer1.add)) [initialization predicate] - Forward reachability iteration 1: - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.count = 0 and buffer1.add)) -> buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) -> buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) or buffer2.add and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer3.add and buffer1.count = 0)) or buffer2.add and (buffer2.count = 0 and buffer3.count = 0) and (buffer3.add and (buffer1.count = 1 and buffer1.add)) -> buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) -> buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.add and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.add and (buffer2.count = 0 and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.add and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.add and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.add and (buffer2.count = 0 and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add))) -> buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 1 and buffer1.add))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 0 and (buffer1.count = 1 and buffer1.add) or (buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and buffer1.count = 0) or buffer2.count = 0 and buffer3.count = 1 and (buffer3.add and (buffer1.count = 1 and buffer1.add))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add))) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.remove and (buffer2.count = 0 and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add)))) [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 2: - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.count = 0) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add))) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 1 and buffer1.add)) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or buffer2.remove and (buffer2.count = 0 and buffer3.count = 1) and (buffer3.add and (buffer1.count = 1 and buffer1.add)))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1))) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1)))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1))) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 0 or buffer1.count = 1)) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and (buffer1.count = 0 or buffer1.count = 1)))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and buffer1.count = 1)))) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or (buffer2.remove and (buffer2.count = 0 and buffer3.count = 1) and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 1))))) [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or (buffer2.add and ((buffer2.count = 0 or buffer2.count = 1) and buffer3.count = 1) and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and (buffer3.count = 1 and (buffer3.add and buffer1.count = 1)))) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 0) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and (buffer1.count = 2 and buffer1.add)) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 0 and buffer1.count = 1)) or (buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 0)) or (buffer2.remove and (buffer2.count = 0 and buffer3.count = 1) and (buffer3.add and (buffer1.count = 2 and buffer1.add)) or buffer2.remove and buffer2.count = 0 and (buffer3.count = 1 and (buffer3.add and buffer1.count = 1))))) -> buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1)) or (buffer2.remove and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.remove and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer2.remove and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer2.add and (buffer2.count = 0 or buffer2.count = 1) and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1)) or (buffer2.remove and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 0) or (buffer2.remove and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and (buffer1.count = 2 and buffer1.add)) or buffer2.remove and buffer2.count = 0 and ((buffer3.count = 0 or buffer3.count = 1) and buffer1.count = 1))) -> (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3))) and ((buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 2 or buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.remove or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer2.add or buffer2.count != 0 or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.add or buffer2.count != 0 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and ((buffer2.add or buffer2.count != 0 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.add or buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.add or buffer2.count != 0 or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and (buffer2.add or buffer2.count != 0 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer3.count != 3)) and ((buffer2.add or buffer2.count != 2) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 2)))))) [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3))) and ((buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 2 or buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3))) and ((buffer2.remove or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.remove or (buffer2.count = 0 or buffer2.count = 1))))) and ((buffer2.add or buffer2.count != 0 or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.add or buffer2.count != 0 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and ((buffer2.add or buffer2.count != 0 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.add or buffer2.count != 0 or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.add or buffer2.count != 0 or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and (buffer2.add or buffer2.count != 0 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.add or (buffer2.count != 0 or buffer3.count != 3)) and ((buffer2.add or buffer2.count != 2) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 2)))))) -> (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.count = 0 or buffer2.count = 1)))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 2) or (buffer3.remove or (buffer1.count != 2 or buffer1.add))) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3)))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 2 or buffer3.add)) and (buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 2 or buffer1.add))) and ((buffer2.count = 2 or buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3)) and ((buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.count = 0 or buffer2.count = 1)))) -> <bdd 11n 27p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 3: - Forward controlled-behavior: <bdd 11n 27p> -> (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3)))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.remove or buffer2.count != 1 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.remove or buffer2.count != 1 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.remove or buffer2.count != 1 or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.remove or buffer2.count != 1 or (buffer3.count != 1 or buffer1.count != 3)) and (buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3)))) and ((buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) [forward reach with edge: (event: buffer1.u_switch_loc) (guard: (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1 := buffer1.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 2 or buffer3.add))) and (buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3)))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.remove or buffer2.count != 1 or (buffer3.count != 0 or buffer1.count != 3)) and ((buffer2.remove or buffer2.count != 1 or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.remove or buffer2.count != 1 or (buffer3.count != 2 or buffer3.add)))) and ((buffer2.remove or buffer2.count != 1 or (buffer3.count != 1 or buffer1.count != 3)) and (buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 0 or buffer1.count != 3)))) and ((buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 2 or (buffer3.remove or buffer1.count != 3))) and (buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 2 or buffer3.add))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or (buffer3.count != 1 or buffer1.count != 3))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1)))))) -> <bdd 10n 27p> [forward reach with edge: (event: buffer1.c_add) (guard: buffer1.add -> (buffer1.count = 0 or buffer1.count = 2) and buffer1.add or buffer1.count = 1 and buffer1.add) (assignments: buffer1.count := buffer1.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 10n 27p> -> (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3)) and ((buffer2.remove or (buffer2.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.remove or buffer2.count != 1 or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) [forward reach with edge: (event: buffer3.u_switch_loc) (guard: (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3 := buffer3.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.remove or (buffer2.count = 1 or buffer2.count = 3) or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.remove or buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3)) and ((buffer2.remove or (buffer2.count != 1 or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.remove or buffer2.count != 1 or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))))) and ((buffer2.remove or (buffer2.count != 1 or buffer3.count != 3)) and ((buffer2.remove or buffer2.count != 3) and (buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count = 1 or buffer3.count = 3 or (buffer1.count != 3 or buffer1.add)))) and ((buffer2.add or (buffer2.count = 2 or buffer2.count = 3) or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.add or buffer2.count = 2 or (buffer2.count = 3 or buffer3.count != 3)) and (buffer2.add or (buffer2.count = 0 or buffer2.count = 1))))) -> <bdd 9n 27p> [forward reach with edge: (event: buffer3.c_add) (guard: buffer3.add -> (buffer3.count = 0 or buffer3.count = 2) and buffer3.add or buffer3.count = 1 and buffer3.add) (assignments: buffer3.count := buffer3.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: <bdd 9n 27p> -> (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3) or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count != 1 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 1 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 1 or buffer3.count != 3 or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and buffer2.count != 3))) [forward reach with edge: (event: buffer2.u_switch_loc) (guard: (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2 := buffer2.remove), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - Forward controlled-behavior: (buffer2.count = 1 or (buffer2.count = 3 or buffer3.count = 1) or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 1 or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count = 1 or (buffer2.count = 3 or buffer3.count != 3) or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and (buffer2.count = 1 or buffer2.count = 3 or (buffer3.count != 3 or buffer3.add))) and ((buffer2.count != 1 or buffer3.count = 1 or (buffer3.count = 3 or (buffer1.count != 3 or buffer1.add))) and (buffer2.count != 1 or buffer3.count != 1 or (buffer1.count != 3 or buffer1.add)) and ((buffer2.count != 1 or buffer3.count != 3 or (buffer3.remove or (buffer1.count != 3 or buffer1.add))) and ((buffer2.count != 1 or (buffer3.count != 3 or buffer3.add)) and buffer2.count != 3))) -> <bdd 16n 44p> [forward reach with edge: (event: buffer2.c_add) (guard: buffer2.add -> (buffer2.remove or buffer2.count != 3) and buffer2.add) (assignments: buffer2.count := buffer2.count + 1), restricted to current/previous controlled-behavior predicate: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3)] - - Forward reachability iteration 4: - No change this iteration. - Forward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior: buffer2.count != 3 or (buffer3.count != 3 or buffer1.count != 3) -> <bdd 16n 44p>. @@ -289,9 +256,6 @@ Synthesis round 2: Backward controlled-behavior: true [marker predicate] Backward controlled-behavior: true -> <bdd 16n 44p> [restricted to current/previous controlled-behavior predicate: <bdd 16n 44p>] - Backward reachability iteration 1: - No change this iteration. - Backward controlled-behavior: <bdd 16n 44p> [fixed point]. Controlled behavior not changed. @@ -299,9 +263,6 @@ Synthesis round 2: Computing backward uncontrolled bad-state predicate: Backward uncontrolled bad-state: <bdd 16n 21p> [current/previous controlled behavior predicate] - Backward reachability iteration 1: - No change this iteration. - Controlled behavior not changed. Finished: controlled behavior is stable. diff --git a/cif/org.eclipse.escet.cif.tests/tests/test_datasynth.tooldef b/cif/org.eclipse.escet.cif.tests/tests/test_datasynth.tooldef index 7ecf9e88dae7c5090963a9cdba22257d8c750b8d..abdc205f44077f42d405c191ecdf75a3db47e649 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/test_datasynth.tooldef +++ b/cif/org.eclipse.escet.cif.tests/tests/test_datasynth.tooldef @@ -34,156 +34,158 @@ string var_order_default = "--dcsh-order=on --force-order=on --sliding-window- string opt_simplify_all = "--bdd-simplify=guards-plants,guards-req-auts,guards-se-excl-plant-invs,guards-se-excl-req-invs,guards-state-plant-invs,guards-state-req-invs,guards-ctrl-beh,initial-unctrl,initial-state-plant-invs"; map(string:list string) test_options = { - "datasynth/bdd_dbg_maxnodes.cif": ["--bdd-dbg-maxnodes=2"], - "datasynth/bdd_dbg_maxpaths.cif": ["--bdd-dbg-maxpaths=2"], - "datasynth/bdd_out_cnf.cif": ["-t cnf"], - "datasynth/bdd_out_dnf.cif": ["-t dnf"], - "datasynth/bdd_out_nodes.cif": ["-t nodes -p n"], - "datasynth/bdd_out_normal.cif": ["-t normal"], - "datasynth/dining_philosophers4.cif": [opt_simplify_all], - "datasynth/edge_granularity_errors01_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors01_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors02_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors02_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors03_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors03_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors04_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors04_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors05_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors05_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors06_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors06_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors07_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors07_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors08_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors08_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors09_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors09_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors10_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors10_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors11_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors11_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors12_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors12_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_errors13_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_errors13_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates1_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates1_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates2_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates2_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates3_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates3_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates4_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates4_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates5_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates5_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates6_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates6_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates7_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates7_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_guards_updates8_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_guards_updates8_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_granularity_simple_per_edge.cif": ["--edge-granularity=per-edge --edge-workset=off"], - "datasynth/edge_granularity_simple_per_event.cif": ["--edge-granularity=per-event"], - "datasynth/edge_order_both_custom_basic.cif": ["--backward-edge-order=C,p.event,D,p.z,p.a,p.X,p.Y,p.c --forward-edge-order=C,p.event,D,p.z,p.a,p.X,p.Y,p.c"], - "datasynth/edge_order_both_custom_dupl_no.cif": ["--stats=ctrl-sys-states,bdd-perf-cache,bdd-perf-max-nodes --backward-edge-order=Counter.dec,Actuator.off,Counter.inc,Actuator.on --forward-edge-order=Counter.dec,Actuator.off,Counter.inc,Actuator.on"], - "datasynth/edge_order_both_custom_dupl_yes.cif": ["--stats=ctrl-sys-states,bdd-perf-cache,bdd-perf-max-nodes --backward-edge-order=Counter.dec,Counter.dec,Counter.dec,Counter.dec,Counter.dec,Actuator.off,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Actuator.on --forward-edge-order=Counter.dec,Counter.dec,Counter.dec,Counter.dec,Counter.dec,Actuator.off,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Actuator.on --edge-order-duplicate-events=allowed --edge-workset=off"], - "datasynth/edge_order_both_dupl_match1.cif": ["--backward-edge-order=p.c,* --forward-edge-order=p.c,*"], - "datasynth/edge_order_both_dupl_match2.cif": ["--backward-edge-order=p.event,* --forward-edge-order=p.event,*"], - "datasynth/edge_order_both_missing.cif": ["--backward-edge-order=q.* --forward-edge-order=q.*"], - "datasynth/edge_order_both_model.cif": ["--backward-edge-order=model --forward-edge-order=model"], - "datasynth/edge_order_both_no_match.cif": ["--backward-edge-order=*3 --forward-edge-order=*3"], - "datasynth/edge_order_both_random_invalid_seed.cif": ["--backward-edge-order=random:x --forward-edge-order=random:x"], - "datasynth/edge_order_both_random.cif": ["--backward-edge-order=random:88 --forward-edge-order=random:88"], - "datasynth/edge_order_both_reverse_model.cif": ["--backward-edge-order=reverse-model --forward-edge-order=reverse-model"], - "datasynth/edge_order_both_reverse_sorted.cif": ["--backward-edge-order=reverse-sorted --forward-edge-order=reverse-sorted"], - "datasynth/edge_order_both_sorted.cif": ["--backward-edge-order=sorted --forward-edge-order=sorted"], - "datasynth/edge_order_forward_random_off.cif": ["--forward-edge-order=random:88 --forward-reach=off"], - "datasynth/edge_order_forward_random_on.cif": ["--forward-edge-order=random:88 --forward-reach=on"], - "datasynth/edge_order_old_option_unsupported.cif": ["-e random"], - "datasynth/edge_order_single_backward_random.cif": ["--backward-edge-order=random:88"], - "datasynth/edge_order_single_forward_random.cif": ["--forward-edge-order=random:88"], - "datasynth/event_warnings.cif": ["--forward-reach=on"], - "datasynth/fixed_point_order_nonblock_ctrl_reach.cif": ["--forward-reach=on --fixed-point-order=nonblock-ctrl-reach"], - "datasynth/fixed_point_order_nonblock_reach_ctrl.cif": ["--forward-reach=on --fixed-point-order=nonblock-reach-ctrl"], - "datasynth/fixed_point_order_ctrl_nonblock_reach.cif": ["--forward-reach=on --fixed-point-order=ctrl-nonblock-reach"], - "datasynth/fixed_point_order_ctrl_reach_nonblock.cif": ["--forward-reach=on --fixed-point-order=ctrl-reach-nonblock"], - "datasynth/fixed_point_order_reach_nonblock_ctrl.cif": ["--forward-reach=on --fixed-point-order=reach-nonblock-ctrl"], - "datasynth/fixed_point_order_reach_ctrl_nonblock.cif": ["--forward-reach=on --fixed-point-order=reach-ctrl-nonblock"], - "datasynth/forward_reach_off.cif": ["--forward-reach=off --bdd-simplify="], - "datasynth/forward_reach_on.cif": ["--forward-reach=on --bdd-simplify="], - "datasynth/inv_state_evt_exclusion_plant_simple.cif": ["--event-warn=false"], - "datasynth/namespace.cif": ["-n a.b.c"], - "datasynth/namespace_conflict.cif": ["-n g.h.c.n"], - "datasynth/namespace_invalid.cif": ["-n a.b."], - "datasynth/namespace_non_empty.cif": ["-n g.h"], - "datasynth/reachability1_workset_off.cif": ["--edge-workset=off --edge-granularity=per-event"], - "datasynth/reachability1_workset_on.cif": ["--edge-workset=on --edge-granularity=per-event"], - "datasynth/reachability2_workset_off.cif": ["--edge-workset=off --edge-granularity=per-event"], - "datasynth/reachability2_workset_on.cif": ["--edge-workset=on --edge-granularity=per-event"], - "datasynth/simplify_ctrl_beh_off.cif": ["--bdd-simplify="], - "datasynth/simplify_ctrl_beh_on.cif": ["--bdd-simplify=guards-ctrl-beh"], - "datasynth/simplify_initial_plant_inv_off.cif": ["--bdd-simplify="], - "datasynth/simplify_initial_plant_inv_on.cif": ["--bdd-simplify=initial-state-plant-invs"], - "datasynth/simplify_initial_unctrl_off.cif": ["--bdd-simplify="], - "datasynth/simplify_initial_unctrl_on.cif": ["--bdd-simplify=initial-unctrl"], - "datasynth/simplify_plants_off.cif": ["--bdd-simplify="], - "datasynth/simplify_plants_on.cif": ["--bdd-simplify=guards-plants"], - "datasynth/simplify_propagation_all.cif": ["--bdd-simplify=guards-plants,guards-req-auts,guards-se-excl-req-invs,guards-state-req-invs,guards-ctrl-beh,initial-unctrl"], - "datasynth/simplify_propagation_none.cif": ["--bdd-simplify="], - "datasynth/simplify_range_invs_off.cif": ["--bdd-simplify="], - "datasynth/simplify_range_invs_on.cif": ["--bdd-simplify=guards-state-req-invs"], - "datasynth/simplify_req_auts_off.cif": ["--bdd-simplify="], - "datasynth/simplify_req_auts_on.cif": ["--bdd-simplify=guards-req-auts"], - "datasynth/simplify_se_excl_plant_invs_off.cif": ["--bdd-simplify="], - "datasynth/simplify_se_excl_plant_invs_on.cif": ["--bdd-simplify=guards-se-excl-plant-invs"], - "datasynth/simplify_se_excl_req_invs_off.cif": ["--bdd-simplify="], - "datasynth/simplify_se_excl_req_invs_on.cif": ["--bdd-simplify=guards-se-excl-req-invs"], - "datasynth/simplify_state_plant_invs_off.cif": ["--bdd-simplify="], - "datasynth/simplify_state_plant_invs_on.cif": ["--bdd-simplify=guards-state-plant-invs"], - "datasynth/simplify_state_req_invs_off.cif": ["--bdd-simplify="], - "datasynth/simplify_state_req_invs_on.cif": ["--bdd-simplify=guards-state-req-invs"], - "datasynth/state_plant_invs_ctrl.cif": [opt_simplify_all], - "datasynth/state_plant_invs_init.cif": ["--forward-reach=on"], - "datasynth/state_plant_invs_req_aut.cif": ["--forward-reach=on"], - "datasynth/state_plant_invs_simple.cif": ["--forward-reach=on"], - "datasynth/state_plant_invs_unctrl.cif": [opt_simplify_all], - "datasynth/state_req_inv_all_ctrl_beh.cif": ["--state-req-invs=all-ctrl-beh"], - "datasynth/state_req_inv_per_edge.cif": ["--state-req-invs=per-edge"], - "datasynth/stats.cif": ["--stats=ctrl-sys-states,bdd-perf-cache,bdd-perf-cont,bdd-perf-max-nodes"], - "datasynth/stats_none.cif": ["--stats="], - "datasynth/traffic_lights_req_state_inv_all_ctrl_beh.cif": ["--state-req-invs=all-ctrl-beh"], - "datasynth/traffic_lights_req_state_inv_per_edge.cif": ["--state-req-invs=per-edge"], - "datasynth/supname_custom.cif": ["-s g"], - "datasynth/supname_invalid.cif": ["-s b@"], - "datasynth/var_order_adv_dcsh_from_paper.cif": ["--adv-var-order=sorted->dcsh(metric=wes,relations=linearized)->force(metric=total-span,relations=legacy)->slidwin(metric=total-span,relations=legacy) " + var_order_default], - "datasynth/var_order_adv_parse_err.cif": ["--adv-var-order=model-> " + var_order_default], - "datasynth/var_order_adv_basic_mix.cif": ["--adv-var-order=random(seed=1)"], - "datasynth/var_order_adv_tcheck_err.cif": ["--adv-var-order=model(a=1) " + var_order_default], - "datasynth/var_order_custom_algos_off.cif": ["-r *c*;*3,*1;*2 " + opt_algos_off + " " + opt_simplify_all], - "datasynth/var_order_custom_algos_on.cif": ["-r *c*;*3,*1;*2 " + opt_algos_on + " " + opt_simplify_all], - "datasynth/var_order_custom_dupl_match.cif": ["-r p.x;*"], - "datasynth/var_order_custom_missing.cif": ["-r q"], - "datasynth/var_order_custom_no_match.cif": ["-r *3"], - "datasynth/var_order_hyper_edge_legacy.cif": ["--hyper-edge-algo=legacy"], - "datasynth/var_order_hyper_edge_linearized.cif": ["--hyper-edge-algo=linearized"], - "datasynth/var_order_model_algos_off.cif": ["-r model " + opt_algos_off + " " + opt_simplify_all], - "datasynth/var_order_model_algos_on.cif": ["-r model " + opt_algos_on + " " + opt_simplify_all], - "datasynth/var_order_random_algo_dcsh_on.cif": ["-r random:88 " + opt_algos_off + " --dcsh-order=on " + opt_simplify_all], - "datasynth/var_order_random_algo_force_on.cif": ["-r random:88 " + opt_algos_off + " --force-order=on " + opt_simplify_all], - "datasynth/var_order_random_algo_slidwin_on.cif": ["-r random:88 " + opt_algos_off + " --sliding-window-order=on " + opt_simplify_all], - "datasynth/var_order_random_algos_off.cif": ["-r random:88 " + opt_algos_off + " " + opt_simplify_all], - "datasynth/var_order_random_algos_on.cif": ["-r random:88 " + opt_algos_on + " " + opt_simplify_all], - "datasynth/var_order_random_invalid_seed.cif": ["-r random:x"], - "datasynth/var_order_reverse_model_algos_off.cif": ["-r reverse-model " + opt_algos_off + " " + opt_simplify_all], - "datasynth/var_order_reverse_model_algos_on.cif": ["-r reverse-model " + opt_algos_on + " " + opt_simplify_all], - "datasynth/var_order_reverse_sorted_algos_off.cif": ["-r reverse-sorted " + opt_algos_off + " " + opt_simplify_all], - "datasynth/var_order_reverse_sorted_algos_on.cif": ["-r reverse-sorted " + opt_algos_on + " " + opt_simplify_all], - "datasynth/var_order_sorted_algos_off.cif": ["-r sorted " + opt_algos_off + " " + opt_simplify_all], - "datasynth/var_order_sorted_algos_on.cif": ["-r sorted " + opt_algos_on + " " + opt_simplify_all], - "datasynth/workset_forward.cif": ["--edge-workset=on --edge-granularity=per-event --forward-reach=on"], - "datasynth/workset_with_edge_order_duplicate_events.cif": ["--edge-workset=on --edge-granularity=per-event --edge-order-duplicate-events=allowed"], - "datasynth/workset_with_per_edge_edge_granularity.cif": ["--edge-workset=on --edge-granularity=per-edge"], + "datasynth/bdd_dbg_maxnodes.cif": ["--bdd-dbg-maxnodes=2"], + "datasynth/bdd_dbg_maxpaths.cif": ["--bdd-dbg-maxpaths=2"], + "datasynth/bdd_out_cnf.cif": ["-t cnf"], + "datasynth/bdd_out_dnf.cif": ["-t dnf"], + "datasynth/bdd_out_nodes.cif": ["-t nodes -p n"], + "datasynth/bdd_out_normal.cif": ["-t normal"], + "datasynth/chaining_fixed.cif": ["--exploration-strategy=chaining-fixed"], + "datasynth/chaining_fixed_forward.cif": ["--exploration-strategy=chaining-fixed --forward-reach=on"], + "datasynth/chaining_workset_forward.cif": ["--exploration-strategy=chaining-workset --edge-granularity=per-event --forward-reach=on"], + "datasynth/chaining_workset_with_edge_order_duplicate_events.cif": ["--exploration-strategy=chaining-workset --edge-granularity=per-event --edge-order-duplicate-events=allowed"], + "datasynth/chaining_workset_with_per_edge_edge_granularity.cif": ["--exploration-strategy=chaining-workset --edge-granularity=per-edge"], + "datasynth/dining_philosophers4.cif": [opt_simplify_all], + "datasynth/edge_granularity_errors01_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors01_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors02_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors02_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors03_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors03_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors04_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors04_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors05_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors05_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors06_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors06_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors07_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors07_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors08_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors08_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors09_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors09_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors10_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors10_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors11_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors11_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors12_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors12_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_errors13_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_errors13_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates1_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates1_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates2_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates2_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates3_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates3_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates4_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates4_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates5_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates5_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates6_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates6_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates7_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates7_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_guards_updates8_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_guards_updates8_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_granularity_simple_per_edge.cif": ["--edge-granularity=per-edge"], + "datasynth/edge_granularity_simple_per_event.cif": ["--edge-granularity=per-event"], + "datasynth/edge_order_both_custom_basic.cif": ["--backward-edge-order=C,p.event,D,p.z,p.a,p.X,p.Y,p.c --forward-edge-order=C,p.event,D,p.z,p.a,p.X,p.Y,p.c"], + "datasynth/edge_order_both_custom_dupl_no.cif": ["--stats=ctrl-sys-states,bdd-perf-cache,bdd-perf-max-nodes --backward-edge-order=Counter.dec,Actuator.off,Counter.inc,Actuator.on --forward-edge-order=Counter.dec,Actuator.off,Counter.inc,Actuator.on"], + "datasynth/edge_order_both_custom_dupl_yes.cif": ["--exploration-strategy=chaining-fixed --stats=ctrl-sys-states,bdd-perf-cache,bdd-perf-max-nodes --backward-edge-order=Counter.dec,Counter.dec,Counter.dec,Counter.dec,Counter.dec,Actuator.off,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Actuator.on --forward-edge-order=Counter.dec,Counter.dec,Counter.dec,Counter.dec,Counter.dec,Actuator.off,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Counter.inc,Actuator.on --edge-order-duplicate-events=allowed"], + "datasynth/edge_order_both_dupl_match1.cif": ["--backward-edge-order=p.c,* --forward-edge-order=p.c,*"], + "datasynth/edge_order_both_dupl_match2.cif": ["--backward-edge-order=p.event,* --forward-edge-order=p.event,*"], + "datasynth/edge_order_both_missing.cif": ["--backward-edge-order=q.* --forward-edge-order=q.*"], + "datasynth/edge_order_both_model.cif": ["--backward-edge-order=model --forward-edge-order=model"], + "datasynth/edge_order_both_no_match.cif": ["--backward-edge-order=*3 --forward-edge-order=*3"], + "datasynth/edge_order_both_random_invalid_seed.cif": ["--backward-edge-order=random:x --forward-edge-order=random:x"], + "datasynth/edge_order_both_random.cif": ["--backward-edge-order=random:88 --forward-edge-order=random:88"], + "datasynth/edge_order_both_reverse_model.cif": ["--backward-edge-order=reverse-model --forward-edge-order=reverse-model"], + "datasynth/edge_order_both_reverse_sorted.cif": ["--backward-edge-order=reverse-sorted --forward-edge-order=reverse-sorted"], + "datasynth/edge_order_both_sorted.cif": ["--backward-edge-order=sorted --forward-edge-order=sorted"], + "datasynth/edge_order_forward_random_off.cif": ["--forward-edge-order=random:88 --forward-reach=off"], + "datasynth/edge_order_forward_random_on.cif": ["--forward-edge-order=random:88 --forward-reach=on"], + "datasynth/edge_order_old_option_unsupported.cif": ["-e random"], + "datasynth/edge_order_single_backward_random.cif": ["--backward-edge-order=random:88"], + "datasynth/edge_order_single_forward_random.cif": ["--forward-edge-order=random:88"], + "datasynth/event_warnings.cif": ["--forward-reach=on"], + "datasynth/fixed_point_order_nonblock_ctrl_reach.cif": ["--forward-reach=on --fixed-point-order=nonblock-ctrl-reach"], + "datasynth/fixed_point_order_nonblock_reach_ctrl.cif": ["--forward-reach=on --fixed-point-order=nonblock-reach-ctrl"], + "datasynth/fixed_point_order_ctrl_nonblock_reach.cif": ["--forward-reach=on --fixed-point-order=ctrl-nonblock-reach"], + "datasynth/fixed_point_order_ctrl_reach_nonblock.cif": ["--forward-reach=on --fixed-point-order=ctrl-reach-nonblock"], + "datasynth/fixed_point_order_reach_nonblock_ctrl.cif": ["--forward-reach=on --fixed-point-order=reach-nonblock-ctrl"], + "datasynth/fixed_point_order_reach_ctrl_nonblock.cif": ["--forward-reach=on --fixed-point-order=reach-ctrl-nonblock"], + "datasynth/forward_reach_off.cif": ["--forward-reach=off --bdd-simplify="], + "datasynth/forward_reach_on.cif": ["--forward-reach=on --bdd-simplify="], + "datasynth/inv_state_evt_exclusion_plant_simple.cif": ["--event-warn=false"], + "datasynth/namespace.cif": ["-n a.b.c"], + "datasynth/namespace_conflict.cif": ["-n g.h.c.n"], + "datasynth/namespace_invalid.cif": ["-n a.b."], + "datasynth/namespace_non_empty.cif": ["-n g.h"], + "datasynth/reachability1_workset_off.cif": ["--edge-granularity=per-event"], + "datasynth/reachability1_workset_on.cif": ["--exploration-strategy=chaining-workset --edge-granularity=per-event"], + "datasynth/reachability2_workset_off.cif": ["--edge-granularity=per-event"], + "datasynth/reachability2_workset_on.cif": ["--exploration-strategy=chaining-workset --edge-granularity=per-event"], + "datasynth/simplify_ctrl_beh_off.cif": ["--bdd-simplify="], + "datasynth/simplify_ctrl_beh_on.cif": ["--bdd-simplify=guards-ctrl-beh"], + "datasynth/simplify_initial_plant_inv_off.cif": ["--bdd-simplify="], + "datasynth/simplify_initial_plant_inv_on.cif": ["--bdd-simplify=initial-state-plant-invs"], + "datasynth/simplify_initial_unctrl_off.cif": ["--bdd-simplify="], + "datasynth/simplify_initial_unctrl_on.cif": ["--bdd-simplify=initial-unctrl"], + "datasynth/simplify_plants_off.cif": ["--bdd-simplify="], + "datasynth/simplify_plants_on.cif": ["--bdd-simplify=guards-plants"], + "datasynth/simplify_propagation_all.cif": ["--bdd-simplify=guards-plants,guards-req-auts,guards-se-excl-req-invs,guards-state-req-invs,guards-ctrl-beh,initial-unctrl"], + "datasynth/simplify_propagation_none.cif": ["--bdd-simplify="], + "datasynth/simplify_range_invs_off.cif": ["--bdd-simplify="], + "datasynth/simplify_range_invs_on.cif": ["--bdd-simplify=guards-state-req-invs"], + "datasynth/simplify_req_auts_off.cif": ["--bdd-simplify="], + "datasynth/simplify_req_auts_on.cif": ["--bdd-simplify=guards-req-auts"], + "datasynth/simplify_se_excl_plant_invs_off.cif": ["--bdd-simplify="], + "datasynth/simplify_se_excl_plant_invs_on.cif": ["--bdd-simplify=guards-se-excl-plant-invs"], + "datasynth/simplify_se_excl_req_invs_off.cif": ["--bdd-simplify="], + "datasynth/simplify_se_excl_req_invs_on.cif": ["--bdd-simplify=guards-se-excl-req-invs"], + "datasynth/simplify_state_plant_invs_off.cif": ["--bdd-simplify="], + "datasynth/simplify_state_plant_invs_on.cif": ["--bdd-simplify=guards-state-plant-invs"], + "datasynth/simplify_state_req_invs_off.cif": ["--bdd-simplify="], + "datasynth/simplify_state_req_invs_on.cif": ["--bdd-simplify=guards-state-req-invs"], + "datasynth/state_plant_invs_ctrl.cif": [opt_simplify_all], + "datasynth/state_plant_invs_init.cif": ["--forward-reach=on"], + "datasynth/state_plant_invs_req_aut.cif": ["--forward-reach=on"], + "datasynth/state_plant_invs_simple.cif": ["--forward-reach=on"], + "datasynth/state_plant_invs_unctrl.cif": [opt_simplify_all], + "datasynth/state_req_inv_all_ctrl_beh.cif": ["--state-req-invs=all-ctrl-beh"], + "datasynth/state_req_inv_per_edge.cif": ["--state-req-invs=per-edge"], + "datasynth/stats.cif": ["--stats=ctrl-sys-states,bdd-perf-cache,bdd-perf-cont,bdd-perf-max-nodes"], + "datasynth/stats_none.cif": ["--stats="], + "datasynth/traffic_lights_req_state_inv_all_ctrl_beh.cif": ["--state-req-invs=all-ctrl-beh"], + "datasynth/traffic_lights_req_state_inv_per_edge.cif": ["--state-req-invs=per-edge"], + "datasynth/supname_custom.cif": ["-s g"], + "datasynth/supname_invalid.cif": ["-s b@"], + "datasynth/var_order_adv_dcsh_from_paper.cif": ["--adv-var-order=sorted->dcsh(metric=wes,relations=linearized)->force(metric=total-span,relations=legacy)->slidwin(metric=total-span,relations=legacy) " + var_order_default], + "datasynth/var_order_adv_parse_err.cif": ["--adv-var-order=model-> " + var_order_default], + "datasynth/var_order_adv_basic_mix.cif": ["--adv-var-order=random(seed=1)"], + "datasynth/var_order_adv_tcheck_err.cif": ["--adv-var-order=model(a=1) " + var_order_default], + "datasynth/var_order_custom_algos_off.cif": ["-r *c*;*3,*1;*2 " + opt_algos_off + " " + opt_simplify_all], + "datasynth/var_order_custom_algos_on.cif": ["-r *c*;*3,*1;*2 " + opt_algos_on + " " + opt_simplify_all], + "datasynth/var_order_custom_dupl_match.cif": ["-r p.x;*"], + "datasynth/var_order_custom_missing.cif": ["-r q"], + "datasynth/var_order_custom_no_match.cif": ["-r *3"], + "datasynth/var_order_hyper_edge_legacy.cif": ["--hyper-edge-algo=legacy"], + "datasynth/var_order_hyper_edge_linearized.cif": ["--hyper-edge-algo=linearized"], + "datasynth/var_order_model_algos_off.cif": ["-r model " + opt_algos_off + " " + opt_simplify_all], + "datasynth/var_order_model_algos_on.cif": ["-r model " + opt_algos_on + " " + opt_simplify_all], + "datasynth/var_order_random_algo_dcsh_on.cif": ["-r random:88 " + opt_algos_off + " --dcsh-order=on " + opt_simplify_all], + "datasynth/var_order_random_algo_force_on.cif": ["-r random:88 " + opt_algos_off + " --force-order=on " + opt_simplify_all], + "datasynth/var_order_random_algo_slidwin_on.cif": ["-r random:88 " + opt_algos_off + " --sliding-window-order=on " + opt_simplify_all], + "datasynth/var_order_random_algos_off.cif": ["-r random:88 " + opt_algos_off + " " + opt_simplify_all], + "datasynth/var_order_random_algos_on.cif": ["-r random:88 " + opt_algos_on + " " + opt_simplify_all], + "datasynth/var_order_random_invalid_seed.cif": ["-r random:x"], + "datasynth/var_order_reverse_model_algos_off.cif": ["-r reverse-model " + opt_algos_off + " " + opt_simplify_all], + "datasynth/var_order_reverse_model_algos_on.cif": ["-r reverse-model " + opt_algos_on + " " + opt_simplify_all], + "datasynth/var_order_reverse_sorted_algos_off.cif": ["-r reverse-sorted " + opt_algos_off + " " + opt_simplify_all], + "datasynth/var_order_reverse_sorted_algos_on.cif": ["-r reverse-sorted " + opt_algos_on + " " + opt_simplify_all], + "datasynth/var_order_sorted_algos_off.cif": ["-r sorted " + opt_algos_off + " " + opt_simplify_all], + "datasynth/var_order_sorted_algos_on.cif": ["-r sorted " + opt_algos_on + " " + opt_simplify_all], }; set string test_skip = {};