From 60055de096ad48ca80e193fac9be6129fadff0b0 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Mon, 27 Nov 2023 23:04:35 +0100 Subject: [PATCH 01/91] begin sketching proof infrastructure: IProofProducer & friends --- .../META-INF/MANIFEST.MF | 1 + .../proofs/IProofConverter.java | 48 +++++++++ .../proofs/IProofPostProcessor.java | 67 +++++++++++++ .../proofs/IProofProducer.java | 97 +++++++++++++++++++ 4 files changed, 213 insertions(+) create mode 100644 trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java create mode 100644 trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java create mode 100644 trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofProducer.java diff --git a/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF b/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF index 5c3db1340b6..11f8e473f0d 100644 --- a/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF +++ b/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF @@ -16,6 +16,7 @@ Export-Package: de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.dangerinvariants, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple, + de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.biesenb, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.equalityanalysis, diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java new file mode 100644 index 00000000000..e9bcbd6f3f4 --- /dev/null +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE ModelCheckerUtils Library. + * + * The ULTIMATE ModelCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE ModelCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE ModelCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE ModelCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs; + +/** + * A specialization of {@link IProofPostProcessor} for post-processings that implement only a proof format conversion, + * but do not reflect a program transformation. + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + * @param + * The type of program for which proofs are converted + * @param + * The type of proofs provided as input for the conversion + * @param + * The type of proofs produced as output of the conversion + */ +public interface IProofConverter + extends IProofPostProcessor { + @Override + default PROGRAM getTransformedProgram() { + return getOriginalProgram(); + } +} diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java new file mode 100644 index 00000000000..92fdc25583e --- /dev/null +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE ModelCheckerUtils Library. + * + * The ULTIMATE ModelCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE ModelCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE ModelCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE ModelCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs; + +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; + +/** + * Post-processes a proof artifact of some kind, resulting in a new proof artifact. This post-processing may for + * instance be intended to accommodate a transformation of the program whose correctness is proven by the proof, or to + * implement a change of proof format, or both. + * + * An instance of this interface is always bound to a specific pair of an original program and a transformed program + * (which may be equal, if no program transformation took place). These programs should not change, and are typically + * provided to the constructor. If a transformation took place, additional information may also be provided to the + * constructor, and be used to implement the post-processing. + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + * @param + * The type of program for which a proof is provided as input to the post processor + * @param + * The type of proof which is provided as input to the post processor + * @param + * The type of program for which this instance provides proofs + * @param + * The type of proof resulting from the post-processing + */ +public interface IProofPostProcessor { + OUTPROGRAM getOriginalProgram(); + + INPROGRAM getTransformedProgram(); + + /** + * Given a proof for {@link #getTransformedProgram()}, computes a proof for {@link #getOriginalProgram()}. + * + * @param proof + * the given input proof + * @return the post-processed proof + */ + OUTPROOF processProof(INPROOF proof); + + IStatisticsDataProvider getStatistics(); +} diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofProducer.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofProducer.java new file mode 100644 index 00000000000..44e1cd1707a --- /dev/null +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofProducer.java @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE ModelCheckerUtils Library. + * + * The ULTIMATE ModelCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE ModelCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE ModelCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE ModelCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs; + +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; + +/** + * An interface for classes that compute some kind of proof artifact for a program. + * + * An instance of this interface is always bound to a specific program. This program should not change, and is typically + * provided to the constructor. + * + * Beyond that, proof producers are typically stateful and may gather information necessary to compute a proof, e.g. + * during verification of the program. The method {@link #hasProof()} can be used to determine if all information to + * compute a proof has been collected. If so, invoking {@link #getOrComputeProof()} should produce the desired proof. + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + * @param + * The type of program for which a proof is produced + * @param + * The type of proof which is produced + */ +public interface IProofProducer { + /** + * Retrieves the (fixed) program for which this instance computes a proof. + * + * @return + */ + PROGRAM getProgram(); + + /** + * Determines if the producer has all the necessary information available to compute a proof. + * + * @return true if a call to {@link #getOrComputeProof()} will succeed, false otherwise. + */ + boolean hasProof(); + + /** + * Attempts to compute the proof artifact. If successful, the artifact must be cached and returned again on + * subsequent calls. + * + * @throws UnsupportedOperationException + * If not all the necessary information to compute the proof is available. + * + * @return the computed proof artifact, if successful. If unsuccessful, an exception is thrown. + */ + PROOF getOrComputeProof(); + + /** + * Obtains a new proof producer which applies the given postprocessing to the proof artifact as it would be computed + * by this instance. The returned object should be an instance of the same class as this instance; implementing + * classes are encouraged to specialize the return type of this method. + * + * There is no guarantee that this proof producer remains valid, or if so, that computed proofs are shared between + * the instances. + * + * @param + * The type of program for which the post processor outputs a proof + * @param + * The type of proof artifact returned by the post processor + * @param postProcessor + * A post processor to apply to the computed proof. The program returned by + * {@link IProofPostProcessor#getTransformedProgram()} must equal the program returned by + * {@link #getProgram()}. + * @return A new proof producer that applies the given post processor after computing a proof, thereby computing a + * proof for the program returned by {@link IProofPostProcessor#getOriginalProgram()}. + */ + IProofProducer + withPostProcessor(IProofPostProcessor postProcessor); + + IStatisticsDataProvider getStatistics(); +} From a30dbb169ae5b25e3a3fce985e5f2ddd10519660 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Mon, 27 Nov 2023 23:05:43 +0100 Subject: [PATCH 02/91] IInitialAbstractionProvider should provide proof producers --- .../IInitialAbstractionProvider.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java index d5b8f576734..f3da944864e 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java @@ -33,6 +33,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; /** @@ -73,5 +74,27 @@ public interface IInitialAbstractionProvider, A ext A getInitialAbstraction(IIcfg icfg, Set errorLocs) throws AutomataLibraryException; + /** + * After an initial abstraction has been computed, attempts to create a proof producer for the abstraction. + * + * @param + * The type of proofs that shall be produced + * @param proofType + * The type of proofs that shall be produced + * @param proofUpdates + * If this is non-null, the returned producer must implement this interface. If no such producer can be + * found, fail instead. + * @return A proof producer satisfying the above constraints. + * @throws UnsupportedOperationException + * if no proof producer satisfying the constraints is known + */ + // TODO #proofRefactor + default IProofProducer getProofProducer(final Class proofType, + final Class proofUpdates) { + final String suffix = proofUpdates == null ? "" : (" while implementing " + proofUpdates.getSimpleName()); + throw new UnsupportedOperationException(getClass().getSimpleName() + + " does not support producing proofs of type " + proofType.getSimpleName() + suffix); + } + // TODO Add statistics support } From d72b396c1fc5f70c38f940953aade4e4f84dcb0e Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Mon, 27 Nov 2023 23:12:58 +0100 Subject: [PATCH 03/91] begin sketching proof production in CEGAR loops --- .../traceabstraction/AbstractCegarLoop.java | 3 ++ .../traceabstraction/BasicCegarLoop.java | 1 + .../traceabstraction/EagerReuseCegarLoop.java | 4 ++ .../IncrementalInclusionCegarLoop.java | 2 + .../traceabstraction/LazyReuseCegarLoop.java | 4 ++ .../traceabstraction/NwaCegarLoop.java | 45 +++++++++++++++++-- .../concurrency/CegarLoopForPetriNet.java | 1 + .../CegarLoopConcurrentAutomata.java | 3 ++ .../TAwAFAsCegarLoop.java | 5 +++ 9 files changed, 65 insertions(+), 3 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index cfac4d6a58e..cf9282d5401 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -496,6 +496,7 @@ private void refineAbstractionInternal(final AutomatonType automatonType) mLogger.info("%s automaton has %s", automatonType, mInterpolAutomaton.sizeInformation()); } + // TODO #proofRefactor if (mComputeHoareAnnotation && mPref.getHoareAnnotationPositions() == HoareAnnotationPositions.All) { assert new InductivityCheck<>(getServices(), (INestedWordAutomaton) mAbstraction, false, true, new IncrementalHoareTripleChecker(mCsToolkit, false)).getResult() : "Not inductive"; @@ -869,6 +870,7 @@ public CegarLoopResult getResult() { floydHoareAutomata = null; } + // TODO #proofRefactor if (mComputeHoareAnnotation && mResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE)) { computeIcfgHoareAnnotation(); writeHoareAnnotationToLogger(); @@ -882,6 +884,7 @@ public int remainingErrorLocs() { return mErrorLocs.size() - mResults.size(); } + // TODO #proofRefactor @SuppressWarnings("unchecked") private void writeHoareAnnotationToLogger() { final IIcfg root = (IIcfg) mIcfg; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index ec3144d049d..e6027179126 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -202,6 +202,7 @@ public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, fi mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationLocs, mPref.getHoareAnnotationPositions()); mStateFactoryForRefinement = stateFactoryForRefinement; + // TODO #proofRefactor mPredicateFactoryInterpolantAutomata = new PredicateFactoryForInterpolantAutomata( super.mCsToolkit.getManagedScript(), mPredicateFactory, computeHoareAnnotation); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index 12ed1376507..8db30513e41 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -157,11 +157,15 @@ private void computeDifferenceForReuseAutomaton(final int iteration, dumpOrAppendAutomatonForReuseIfEnabled(reuseAut, predicateUnifier); if (REMOVE_DEAD_ENDS) { + // TODO #proofRefactor if (mComputeHoareAnnotation) { final Difference difference = (Difference) diff; mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } + diff.removeDeadEnds(); + + // TODO #proofRefactor if (mComputeHoareAnnotation) { mHaf.addDeadEndDoubleDeckers(diff); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index fe064ec0430..02acc77a033 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -92,6 +92,8 @@ public IncrementalInclusionCegarLoop(final DebugIdentifier name, super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, computeHoareAnnotation, hoareAnnotationLocs, services, transitionClazz, stateFactoryForRefinement); mLanguageOperation = languageOperation; + + // TODO #proofRefactor if (mComputeHoareAnnotation) { throw new UnsupportedOperationException( "while using this CEGAR loop computation of Hoare annotation is unsupported "); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index f16f5c7385b..fc38e9bc534 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -188,11 +188,15 @@ protected boolean refineAbstraction() throws AutomataLibraryException { dumpOrAppendAutomatonForReuseIfEnabled(reuseAut, reuseAutPair.getSecond()); if (REMOVE_DEAD_ENDS) { + // TODO #proofRefactor if (mComputeHoareAnnotation) { final Difference difference = (Difference) diff; mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } + diff.removeDeadEnds(); + + // TODO #proofRefactor if (mComputeHoareAnnotation) { mHaf.addDeadEndDoubleDeckers(diff); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 8c1ea3d927e..013a2f52461 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -57,6 +57,7 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.IsEmptyHeuristic.AStarHeuristic; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.IsEmptyHeuristic.IHeuristic; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.PowersetDeterminizer; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.ProductNwa; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.oldapi.IOpWithDelayedDeadEndRemoval; import de.uni_freiburg.informatik.ultimate.automata.nestedword.senwa.DifferenceSenwa; import de.uni_freiburg.informatik.ultimate.core.lib.exceptions.RunningTaskInfo; @@ -132,6 +133,9 @@ public class NwaCegarLoop> extends BasicCegarLoop mProofUpdater = null; + public NwaCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, @@ -314,7 +318,9 @@ protected boolean refineAbstraction() throws AutomataLibraryException { } else { automatonType = AutomatonType.FLOYD_HOARE; useErrorAutomaton = false; - exploitSigmaStarConcatOfIa = !mComputeHoareAnnotation; + // TODO #proofRefactor + exploitSigmaStarConcatOfIa = + !mComputeHoareAnnotation && (mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa()); subtrahendBeforeEnhancement = mInterpolAutomaton; enhanceMode = mPref.interpolantAutomatonEnhancement(); subtrahend = enhanceInterpolantAutomaton(enhanceMode, predicateUnifier, htc, subtrahendBeforeEnhancement); @@ -392,14 +398,25 @@ private void computeAutomataDifference(final INestedWordAutomaton } if (REMOVE_DEAD_ENDS) { + // TODO #proofRefactor if (mComputeHoareAnnotation) { final Difference difference = (Difference) diff; mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } + if (mProofUpdater != null) { + final Difference difference = (Difference) diff; + mProofUpdater.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); + } + diff.removeDeadEnds(); + + // TODO #proofRefactor if (mComputeHoareAnnotation) { mHaf.addDeadEndDoubleDeckers(diff); } + if (mProofUpdater != null) { + mProofUpdater.addDeadEndDoubleDeckers(diff); + } } mAbstraction = diff.getResult(); if (mPref.dumpAutomata()) { @@ -488,8 +505,10 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac : new HashSet<>(Arrays.asList(((IMLPredicate) x).getProgramPoints()))); AutomataMinimization, IPredicate, L> am; try { - am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, mComputeHoareAnnotation, - mIteration, predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, + // TODO #proofRefactor + final boolean computeOld2New = mComputeHoareAnnotation || mProofUpdater != null; + am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, mIteration, + predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, lcsProvider, true); } catch (final AutomataMinimizationTimeout e) { mCegarLoopBenchmark.addAutomataMinimizationData(e.getStatistics()); @@ -503,6 +522,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac final IDoubleDeckerAutomaton newAbstraction = am.getMinimizedAutomaton(); // extract Hoare annotation + // TODO #proofRefactor if (mComputeHoareAnnotation) { final Map oldState2newState = am.getOldState2newStateMapping(); if (oldState2newState == null) { @@ -510,6 +530,13 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac } mHaf.updateOnMinimization(oldState2newState, newAbstraction); } + if (mProofUpdater != null) { + final Map oldState2newState = am.getOldState2newStateMapping(); + if (oldState2newState == null) { + throw new AssertionError("Proof production and " + minimization + " incompatible"); + } + mProofUpdater.updateOnMinimization(oldState2newState, newAbstraction); + } // statistics final int oldSize = mAbstraction.size(); @@ -562,4 +589,16 @@ private static SearchStrategy getSearchStrategy(final IPreferenceProvider mPrefs throw new IllegalArgumentException(); } } + + public interface IProofUpdater { + boolean exploitSigmaStarConcatOfIa(); + + void updateOnIntersection(Map.ProductState>> fst2snd2res, + IDoubleDeckerAutomaton result); + + void updateOnMinimization(final Map old2New, + final INwaOutgoingLetterAndTransitionProvider abstraction); + + void addDeadEndDoubleDeckers(IOpWithDelayedDeadEndRemoval diff); + } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index 627473118ef..fc337351300 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -524,6 +524,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { throw new UnsupportedOperationException(); } + // TODO #proofRefactor if (mComputeHoareAnnotation) { assert new InductivityCheck<>(getServices(), dia, false, true, new IncrementalHoareTripleChecker(super.mCsToolkit, false)).getResult() : "Not inductive"; diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 1cbf965e8f4..ea9893d2886 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -104,6 +104,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac final Function> lcsProvider = x -> asHashSet(x.getProgramPoints()); AutomataMinimization, IMLPredicate, L> am; try { + // TODO #proofRefactor am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, mComputeHoareAnnotation, mIteration, predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, lcsProvider, false); @@ -120,6 +121,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac final IDoubleDeckerAutomaton newAbstraction = am.getMinimizedAutomaton(); // extract Hoare annotation + // TODO #proofRefactor if (mComputeHoareAnnotation) { final Map oldState2newState = am.getOldState2newStateMapping(); if (oldState2newState == null) { @@ -145,6 +147,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // howDifferentAreInterpolants(mInterpolAutomaton.getStates()); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); + // TODO #proofRefactor final boolean explointSigmaStarConcatOfIA = !mComputeHoareAnnotation; final INestedWordAutomaton oldAbstraction = mAbstraction; diff --git a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java index 4e843cbe057..15990a318d4 100644 --- a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java +++ b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java @@ -466,6 +466,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // copie mStateFactoryForRefinement.setIteration(super.mIteration); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); + // TODO #proofRefactor final boolean explointSigmaStarConcatOfIA = !mComputeHoareAnnotation; final INestedWordAutomaton oldAbstraction = (INestedWordAutomaton) mAbstraction; @@ -497,11 +498,15 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // copie // checkInductivity if (REMOVE_DEAD_ENDS) { + // TODO #proofRefactor if (mComputeHoareAnnotation) { final Difference difference = (Difference) diff; mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } + diff.removeDeadEnds(); + + // TODO #proofRefactor if (mComputeHoareAnnotation) { mHaf.addDeadEndDoubleDeckers(diff); } From 62f36a96cd3e7db6610171dfea7288dbf06dffbf Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Tue, 28 Nov 2023 13:42:27 +0100 Subject: [PATCH 04/91] add operators for proof post processing and conversion --- .../proofs/IProofConverter.java | 52 ++++++++++++++++++- .../proofs/IProofPostProcessor.java | 52 +++++++++++++++++++ 2 files changed, 103 insertions(+), 1 deletion(-) diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java index e9bcbd6f3f4..b6fa6c57a88 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java @@ -26,6 +26,8 @@ */ package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; + /** * A specialization of {@link IProofPostProcessor} for post-processings that implement only a proof format conversion, * but do not reflect a program transformation. @@ -41,8 +43,56 @@ */ public interface IProofConverter extends IProofPostProcessor { + PROGRAM getProgram(); + + @Override + default PROGRAM getOriginalProgram() { + return getProgram(); + } + @Override default PROGRAM getTransformedProgram() { - return getOriginalProgram(); + return getProgram(); + } + + static IProofConverter identity(final PROGRAM program) { + return new IProofConverter<>() { + @Override + public PROGRAM getProgram() { + return program; + } + + @Override + public PROOF processProof(final PROOF proof) { + return proof; + } + + @Override + public IStatisticsDataProvider getStatistics() { + throw new UnsupportedOperationException(); + } + }; + } + + static IProofConverter compose( + final IProofConverter left, + final IProofConverter right) { + assert right.getProgram() == left.getProgram(); + return new IProofConverter<>() { + @Override + public PROGRAM getProgram() { + return right.getProgram(); + } + + @Override + public OUTPROOF processProof(final INPROOF proof) { + return right.processProof(left.processProof(proof)); + } + + @Override + public IStatisticsDataProvider getStatistics() { + throw new UnsupportedOperationException(); + } + }; } } diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java index 92fdc25583e..ced5310c233 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java @@ -64,4 +64,56 @@ public interface IProofPostProcessor { OUTPROOF processProof(INPROOF proof); IStatisticsDataProvider getStatistics(); + + static IProofPostProcessor identity(final PROGRAM program) { + return new IProofPostProcessor<>() { + @Override + public PROGRAM getOriginalProgram() { + return program; + } + + @Override + public PROGRAM getTransformedProgram() { + return program; + } + + @Override + public PROOF processProof(final PROOF proof) { + return proof; + } + + @Override + public IStatisticsDataProvider getStatistics() { + throw new UnsupportedOperationException(); + } + }; + } + + static + IProofPostProcessor + compose(final IProofPostProcessor left, + final IProofPostProcessor right) { + assert right.getTransformedProgram() == left.getOriginalProgram(); + return new IProofPostProcessor<>() { + @Override + public OUTPROGRAM getOriginalProgram() { + return right.getOriginalProgram(); + } + + @Override + public INPROGRAM getTransformedProgram() { + return left.getTransformedProgram(); + } + + @Override + public OUTPROOF processProof(final INPROOF proof) { + return right.processProof(left.processProof(proof)); + } + + @Override + public IStatisticsDataProvider getStatistics() { + throw new UnsupportedOperationException(); + } + }; + } } From c5a333284778f8fe8710579dd997448eaba36819 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Tue, 28 Nov 2023 13:43:45 +0100 Subject: [PATCH 05/91] start sketching Hoare proof producer --- .../NwaInitialAbstractionProvider.java | 84 ++++++++++++++++++- 1 file changed, 82 insertions(+), 2 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index 5010ee683b4..97f36c09f52 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -26,6 +26,7 @@ */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction; +import java.util.Map; import java.util.Set; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; @@ -34,9 +35,13 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofConverter; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofPostProcessor; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; /** * Provides an initial abstraction in the form of a nested word automaton. This is only applicable to sequential @@ -55,6 +60,8 @@ public class NwaInitialAbstractionProvider> private final boolean mInterprocedural; private final PredicateFactory mPredicateFactory; + private INestedWordAutomaton mAbstraction; + /** * Create a new instance. For documentation of the parameters, see the corresponding parameters in * {@link CFG2NestedWordAutomaton#constructAutomatonWithSPredicates(IUltimateServiceProvider, IIcfg, IEmptyStackStateFactory, java.util.Collection, boolean, PredicateFactory)}. @@ -71,7 +78,80 @@ public NwaInitialAbstractionProvider(final IUltimateServiceProvider services, @Override public INestedWordAutomaton getInitialAbstraction(final IIcfg icfg, final Set errorLocs) { - return Cfg2Automaton.constructAutomatonWithSPredicates(mServices, icfg, mStateFactory, errorLocs, - mInterprocedural, mPredicateFactory); + if (mAbstraction == null) { + mAbstraction = Cfg2Automaton.constructAutomatonWithSPredicates(mServices, icfg, mStateFactory, errorLocs, + mInterprocedural, mPredicateFactory); + } + return mAbstraction; + } + + @Override + public IProofProducer, PROOF> + getProofProducer(final Class proofType, final Class proofUpdates) { + // TODO replace Map by new class/interface (I)FloydHoareAnnotation + if (proofUpdates == null || proofUpdates.isAssignableFrom(NwaHoareProofProducer.class)) { + // TODO implement retrieval of suitable proof converter, if one exists + final IProofConverter, Map, PROOF> converter = + null; + + if (converter != null) { + return NwaHoareProofProducer.create(mAbstraction).withPostProcessor(converter); + } + } + + return IInitialAbstractionProvider.super.getProofProducer(proofType, proofUpdates); + } + + // TODO can't implement INwaCegarLoop.ProofProducer because in wrong project + private static final class NwaHoareProofProducer + implements IProofProducer /* , INwaCegarLoop.ProofProducer */ { + + private final INestedWordAutomaton mProgram; + + // TODO replace Map by new class/interface (I)FloydHoareAnnotation + private final IProofPostProcessor, Map, PROGRAM, PROOF> mPost; + + private NwaHoareProofProducer(final INestedWordAutomaton program, + final IProofPostProcessor, Map, PROGRAM, PROOF> postProcessor) { + mProgram = program; + mPost = postProcessor; + + assert postProcessor.getOriginalProgram() == mProgram; + } + + public static NwaHoareProofProducer, Map> + create(final INestedWordAutomaton program) { + return new NwaHoareProofProducer<>(program, IProofPostProcessor.identity(program)); + } + + @Override + public PROGRAM getProgram() { + return mPost.getOriginalProgram(); + } + + @Override + public boolean hasProof() { + // TODO Auto-generated method stub + return false; + } + + @Override + public PROOF getOrComputeProof() { + // TODO + final Map floydHoare = null; + return mPost.processProof(floydHoare); + } + + @Override + public IProofProducer + withPostProcessor(final IProofPostProcessor postProcessor) { + return new NwaHoareProofProducer<>(mProgram, IProofPostProcessor.compose(mPost, postProcessor)); + } + + @Override + public IStatisticsDataProvider getStatistics() { + // TODO Auto-generated method stub + throw new UnsupportedOperationException(); + } } } From 76a50a26bfa7cd7690e5e866cd8f557a1a84314f Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Wed, 29 Nov 2023 22:47:04 +0100 Subject: [PATCH 06/91] cherry-pick Floyd-Hoare changes from wip/dk/empire-owicki These changes allow computing Floyd/Hoare annotations for product automata of concurrent programs. --- .../operations/PetriNet2FiniteAutomaton.java | 4 + .../smt/predicates/PredicateUtils.java | 12 +++ .../cfg2automaton/Cfg2Automaton.java | 20 +++-- .../traceabstraction/BasicCegarLoop.java | 18 ++++- .../HoareAnnotationComposer.java | 60 ++++++++------- .../HoareAnnotationExtractor.java | 5 +- .../HoareAnnotationFragments.java | 75 ++++++++++++------- .../HoareAnnotationWriter.java | 23 +++++- .../traceabstraction/NwaCegarLoop.java | 24 +++--- .../PredicateFactoryRefinement.java | 9 ++- .../TraceAbstractionStarter.java | 7 +- 11 files changed, 170 insertions(+), 87 deletions(-) diff --git a/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java b/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java index 12eea4d10e0..284243f73c2 100644 --- a/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java +++ b/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java @@ -208,6 +208,10 @@ public INestedWordAutomaton getResult() { return mResult; } + public Map, PLACE> getStateMap() { + return mMarking2State; + } + @Override public boolean checkResult(final IStateFactory stateFactory) throws AutomataLibraryException { return true; diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java index 682f4108fc9..792ea2b06f1 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java @@ -35,8 +35,10 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import java.util.stream.Stream; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.ModifiableGlobalsTable; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.transitions.UnmodifiableTransFormula; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramNonOldVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramOldVar; @@ -396,4 +398,14 @@ private static Term rename(final Script script, final IPredicate postcond, final assert result.getFreeVars().length == 0 : "there are free vars"; return result; } + + public static Stream getLocations(final IPredicate pred) { + if (pred instanceof ISLPredicate) { + return Stream.of(((ISLPredicate) pred).getProgramPoint()); + } + if (pred instanceof IMLPredicate) { + return Arrays.stream(((IMLPredicate) pred).getProgramPoints()); + } + return Stream.of(); + } } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/cfg2automaton/Cfg2Automaton.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/cfg2automaton/Cfg2Automaton.java index abafd28e1d9..b4830608fd0 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/cfg2automaton/Cfg2Automaton.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/cfg2automaton/Cfg2Automaton.java @@ -269,15 +269,19 @@ private static BoundedPetriNet constructPetriNet( { for (final Entry, List> entry : icfg .getCfgSmtToolkit().getConcurrencyInformation().getThreadInstanceMap().entrySet()) { + + final ManagedScript mgdScript = icfg.getCfgSmtToolkit().getManagedScript(); + final Term trueTerm = mgdScript.getScript().term("true"); + final List threadInstances = entry.getValue(); final List notinUseStates = new ArrayList<>(); final List inUseStates = new ArrayList<>(); for (final ThreadInstance ti : threadInstances) { final String threadInstanceId = ti.getThreadInstanceName(); final IPredicate threadNotInUsePredicate = threadInstance2notinUseState.computeIfAbsent( - threadInstanceId, x -> createThreadNotInUsePredicate(x, net, predicateFactory)); + threadInstanceId, x -> createThreadNotInUsePredicate(x, net, predicateFactory, trueTerm)); final IPredicate threadInUsePredicate = threadInstance2inUseState.computeIfAbsent(threadInstanceId, - x -> createThreadInUsePredicate(x, net, predicateFactory)); + x -> createThreadInUsePredicate(x, net, predicateFactory, trueTerm)); notinUseStates.add(threadNotInUsePredicate); inUseStates.add(threadInUsePredicate); @@ -387,17 +391,21 @@ private static IcfgEdge getIncomingEdge(final IcfgLocation location) { } private static IPredicate createThreadNotInUsePredicate(final String threadInstanceId, - final BoundedPetriNet net, final PredicateFactory predicateFactory) { + final BoundedPetriNet net, final PredicateFactory predicateFactory, + final Term predicateTerm) { + // TODO (2020-09-03 Dominik) Label predicate with the string below; but use trueTerm (not dontCare). final String threadNotInUseString = threadInstanceId + "NotInUse"; - final IPredicate threadNotInUsePredicate = predicateFactory.newDebugPredicate(threadNotInUseString); + final IPredicate threadNotInUsePredicate = predicateFactory.newPredicate(predicateTerm); net.addPlace(threadNotInUsePredicate, true, false); return threadNotInUsePredicate; } private static IPredicate createThreadInUsePredicate(final String threadInstanceId, - final BoundedPetriNet net, final PredicateFactory predicateFactory) { + final BoundedPetriNet net, final PredicateFactory predicateFactory, + final Term predicateTerm) { + // TODO (2020-09-03 Dominik) Label predicate with the string below; but use trueTerm (not dontCare). final String threadInUseString = threadInstanceId + "InUse"; - final IPredicate threadInUsePredicate = predicateFactory.newDebugPredicate(threadInUseString); + final IPredicate threadInUsePredicate = predicateFactory.newPredicate(predicateTerm); net.addPlace(threadInUsePredicate, false, false); return threadInUsePredicate; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index e6027179126..090c850c842 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -43,6 +43,7 @@ import java.util.Map; import java.util.Scanner; import java.util.Set; +import java.util.stream.Collectors; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryException; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryServices; @@ -91,6 +92,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskIterationIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult.BasicRefinementEngineResult; @@ -199,7 +201,17 @@ public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, fi } mStoreFloydHoareAutomata = taPrefs.getFloydHoareAutomataReuse() != FloydHoareAutomataReuse.NONE; - mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationLocs, mPref.getHoareAnnotationPositions()); + + final Set hoareAnnotationStates; + if (initialAbstraction instanceof INestedWordAutomaton) { + final var nwa = (INestedWordAutomaton) initialAbstraction; + hoareAnnotationStates = nwa.getStates().stream() + .filter(p -> PredicateUtils.getLocations(p).anyMatch(hoareAnnotationLocs::contains)) + .collect(Collectors.toSet()); + } else { + hoareAnnotationStates = Set.of(); + } + mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates, mPref.getHoareAnnotationPositions()); mStateFactoryForRefinement = stateFactoryForRefinement; // TODO #proofRefactor @@ -457,8 +469,8 @@ protected final IHoareTripleChecker getHoareTripleChecker() { } // Use all edges of the interpolant automaton that is already constructed as an // initial cache for the Hoare triple checker. - final HoareTripleCheckerCache initialCache = TraceAbstractionUtils - .extractHoareTriplesfromAutomaton(mRefinementResult.getInfeasibilityProof()); + final HoareTripleCheckerCache initialCache = + TraceAbstractionUtils.extractHoareTriplesfromAutomaton(mRefinementResult.getInfeasibilityProof()); return HoareTripleCheckerUtils.constructEfficientHoareTripleCheckerWithCaching(getServices(), mPref.getHoareTripleChecks(), mCsToolkit, mRefinementResult.getPredicateUnifier(), initialCache); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationComposer.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationComposer.java index dbbb184617e..5cf8c0f9dbe 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationComposer.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationComposer.java @@ -37,7 +37,6 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.BasicPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; @@ -78,10 +77,10 @@ public class HoareAnnotationComposer { private final HoareAnnotationStatisticsGenerator mHoareAnnotationStatisticsGenerator; - private final NestedMap2 mLoc2callPred2disjunction; + private final NestedMap2 mLoc2callPred2disjunction; private int mNumberOfFragments = 0; - private final Map mLoc2hoare; + private final Map mLoc2hoare; private final IPredicate mSurrogateForEmptyCallPred; @@ -96,7 +95,7 @@ public HoareAnnotationComposer(final CfgSmtToolkit csToolkit, final PredicateFac mHoareAnnotationStatisticsGenerator = new HoareAnnotationStatisticsGenerator(); mSurrogateForEmptyCallPred = mPredicateFactory.newPredicate(mCsToolkit.getManagedScript().getScript().term("true")); - final HashRelation3 loc2callPred2disjuncts = + final HashRelation3 loc2callPred2disjuncts = constructLoc2CallPred2DisjunctsMapping(); mLoc2callPred2disjunction = constructLoc2Callpred2DisjunctionMapping(loc2callPred2disjuncts); mHoareAnnotationStatisticsGenerator.setNumberOfFragments(mNumberOfFragments); @@ -106,10 +105,10 @@ public HoareAnnotationComposer(final CfgSmtToolkit csToolkit, final PredicateFac } - private Map - combineInter(final NestedMap2 loc2callPred2invariant) { - final Map result = new HashMap<>(); - for (final IcfgLocation loc : loc2callPred2invariant.keySet()) { + private Map + combineInter(final NestedMap2 loc2callPred2invariant) { + final Map result = new HashMap<>(); + for (final IPredicate loc : loc2callPred2invariant.keySet()) { final Map callpred2invariant = loc2callPred2invariant.get(loc); final List conjuncts = new ArrayList<>(callpred2invariant.size()); for (final Entry entry : callpred2invariant.entrySet()) { @@ -140,12 +139,17 @@ public HoareAnnotationComposer(final CfgSmtToolkit csToolkit, final PredicateFac } conjuncts.add(precondImpliesInvariant); } - Term conjunction = SmtUtils.and(mCsToolkit.getManagedScript().getScript(), conjuncts); + final Term conjunction = SmtUtils.and(mCsToolkit.getManagedScript().getScript(), conjuncts); + + final Set vars = TermVarsProc + .computeTermVarsProc(conjunction, mCsToolkit.getManagedScript(), mCsToolkit.getSymbolTable()) + .getVars(); + + // TODO (2020-09-03 Dominik) Functionality below is probably necessary. Make it work with IPredicate instead + // of IcfgLocation. + // conjunction = TraceAbstractionUtils.substituteOldVarsOfNonModifiableGlobals(loc.getProcedure(), vars, + // conjunction, mCsToolkit.getModifiableGlobalsTable(), mCsToolkit.getManagedScript()); - final Set vars = TermVarsProc.computeTermVarsProc(conjunction, - mCsToolkit.getManagedScript(), mCsToolkit.getSymbolTable()).getVars(); - conjunction = TraceAbstractionUtils.substituteOldVarsOfNonModifiableGlobals(loc.getProcedure(), vars, - conjunction, mCsToolkit.getModifiableGlobalsTable(), mCsToolkit.getManagedScript()); final ExtendedSimplificationResult simplificationResult = SmtUtils.simplifyWithStatistics( mCsToolkit.getManagedScript(), conjunction, mServices, SimplificationTechnique.SIMPLIFY_DDA); mHoareAnnotationStatisticsGenerator.reportSimplificationInter(); @@ -163,10 +167,10 @@ public HoareAnnotationComposer(final CfgSmtToolkit csToolkit, final PredicateFac return result; } - private NestedMap2 constructLoc2Callpred2DisjunctionMapping( - final HashRelation3 loc2precond2invariantSet) { - final NestedMap2 loc2precond2invariant = new NestedMap2<>(); - for (final IcfgLocation loc : loc2precond2invariantSet.projectToFst()) { + private NestedMap2 constructLoc2Callpred2DisjunctionMapping( + final HashRelation3 loc2precond2invariantSet) { + final NestedMap2 loc2precond2invariant = new NestedMap2<>(); + for (final IPredicate loc : loc2precond2invariantSet.projectToFst()) { for (final IPredicate precond : loc2precond2invariantSet.projectToSnd(loc)) { final Set terms = loc2precond2invariantSet.projectToTrd(loc, precond); mNumberOfFragments += terms.size(); @@ -192,20 +196,20 @@ private Term or(final Set terms) { * invariants for live callpred * */ - public HashRelation3 constructLoc2CallPred2DisjunctsMapping() { - final HashRelation3 loc2callpred2invariant = new HashRelation3<>(); + public HashRelation3 constructLoc2CallPred2DisjunctsMapping() { + final HashRelation3 loc2callpred2invariant = new HashRelation3<>(); addHoareAnnotationForCallPred(loc2callpred2invariant, mSurrogateForEmptyCallPred, mHoareAnnotationFragments.getProgPoint2StatesWithEmptyContext()); for (final IPredicate callPred : mHoareAnnotationFragments.getDeadContexts2ProgPoint2Preds().keySet()) { - final HashRelation pp2preds = + final HashRelation pp2preds = mHoareAnnotationFragments.getDeadContexts2ProgPoint2Preds().get(callPred); addHoareAnnotationForCallPred(loc2callpred2invariant, callPred, pp2preds); } for (final IPredicate callPred : mHoareAnnotationFragments.getLiveContexts2ProgPoint2Preds().keySet()) { - final HashRelation pp2preds = + final HashRelation pp2preds = mHoareAnnotationFragments.getLiveContexts2ProgPoint2Preds().get(callPred); addHoareAnnotationForCallPred(loc2callpred2invariant, callPred, pp2preds); } @@ -217,8 +221,8 @@ public HashRelation3 constructLoc2CallPred2Disju * invariants for live callpred * */ - public HashRelation3 constructMappingOld() { - final HashRelation3 loc2callpred2invariant = new HashRelation3<>(); + public HashRelation3 constructMappingOld() { + final HashRelation3 loc2callpred2invariant = new HashRelation3<>(); final IPredicate surrogateForEmptyCallPred = mPredicateFactory.newPredicate(mCsToolkit.getManagedScript().getScript().term("true")); @@ -234,7 +238,7 @@ public HashRelation3 constructMappingOld() { precondForContext = mHoareAnnotationFragments.getCallpred2Entry().get(context); precondForContext = TraceAbstractionUtils.renameGlobalsToOldGlobals(precondForContext, mServices, mCsToolkit.getManagedScript(), mPredicateFactory, SimplificationTechnique.SIMPLIFY_DDA); - final HashRelation pp2preds = + final HashRelation pp2preds = mHoareAnnotationFragments.getDeadContexts2ProgPoint2Preds().get(context); addHoareAnnotationForCallPred(loc2callpred2invariant, precondForContext, pp2preds); } @@ -248,7 +252,7 @@ public HashRelation3 constructMappingOld() { precondForContext = mHoareAnnotationFragments.getCallpred2Entry().get(context); precondForContext = TraceAbstractionUtils.renameGlobalsToOldGlobals(precondForContext, mServices, mCsToolkit.getManagedScript(), mPredicateFactory, SimplificationTechnique.SIMPLIFY_DDA); - final HashRelation pp2preds = + final HashRelation pp2preds = mHoareAnnotationFragments.getLiveContexts2ProgPoint2Preds().get(context); addHoareAnnotationForCallPred(loc2callpred2invariant, precondForContext, pp2preds); } @@ -260,8 +264,8 @@ public HashRelation3 constructMappingOld() { * @param precondForContext * @param pp2preds */ - private static void addHoareAnnotationForCallPred( - final HashRelation3 loc2callPred2invariant, + private static void addHoareAnnotationForCallPred( + final HashRelation3 loc2callPred2invariant, final IPredicate precondForContext, final HashRelation pp2preds) { for (final DOM loc : pp2preds.getDomain()) { final Set preds = pp2preds.getImage(loc); @@ -279,7 +283,7 @@ public HoareAnnotationStatisticsGenerator getHoareAnnotationStatisticsGenerator( return mHoareAnnotationStatisticsGenerator; } - public Map getLoc2hoare() { + public Map getLoc2hoare() { return mLoc2hoare; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationExtractor.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationExtractor.java index 0970068dbc1..ff3565f7aee 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationExtractor.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationExtractor.java @@ -44,6 +44,7 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.MLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.SPredicate; /** @@ -86,10 +87,10 @@ private void addContext(final DoubleDecker doubleDecker) { protected Collection getInitialStates() { final Collection result = mTraversedNwa.getInitialStates(); if (result.size() == 1) { - // case where automaton is emtpy minimized and contains only one + // case where automaton is empty minimized and contains only one // dummy state. final IPredicate p = result.iterator().next(); - if (!(p instanceof SPredicate)) { + if (!(p instanceof SPredicate) && !(p instanceof MLPredicate)) { throw new AssertionError("No State Automaton would be ok"); // result = new ArrayList(0); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java index 4e4bef18979..b779254dad2 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java @@ -30,6 +30,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; +import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; @@ -44,10 +45,7 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.OutgoingCallTransition; import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.SPredicate; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.UnknownState; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.HashRelation; @@ -63,32 +61,33 @@ public class HoareAnnotationFragments { private final ILogger mLogger; + private final Map mPred2ProgPoint = new HashMap<>(); + /** * States for contexts were the context was already removed (because it was a dead end) from the abstraction. */ - private final Map> mDeadContexts2ProgPoint2Preds = - new HashMap<>(); + private final Map> mDeadContexts2ProgPoint2Preds = new HashMap<>(); /** * States for contexts were the are still in the current abstraction. */ - private Map> mLiveContexts2ProgPoint2Preds = new HashMap<>(); + private Map> mLiveContexts2ProgPoint2Preds = new HashMap<>(); private final HashMap mContext2Entry = new HashMap<>(); - private final HashRelation mProgPoint2StatesWithEmptyContext = new HashRelation<>(); + private final HashRelation mProgPoint2StatesWithEmptyContext = new HashRelation<>(); - private final Set mHoareAnnotationPositions; + private final Set mHoareAnnotationPositions; private final HoareAnnotationPositions mHoareAnnotationPos; - Map> getDeadContexts2ProgPoint2Preds() { + Map> getDeadContexts2ProgPoint2Preds() { return mDeadContexts2ProgPoint2Preds; } - Map> getLiveContexts2ProgPoint2Preds() { + Map> getLiveContexts2ProgPoint2Preds() { return mLiveContexts2ProgPoint2Preds; } - HashRelation getProgPoint2StatesWithEmptyContext() { + HashRelation getProgPoint2StatesWithEmptyContext() { return mProgPoint2StatesWithEmptyContext; } @@ -96,7 +95,7 @@ HashMap getCallpred2Entry() { return mContext2Entry; } - public HoareAnnotationFragments(final ILogger logger, final Set hoareAnnotationLocations, + public HoareAnnotationFragments(final ILogger logger, final Set hoareAnnotationLocations, final HoareAnnotationPositions hoareAnnotationPos) { mLogger = logger; mHoareAnnotationPositions = hoareAnnotationLocations; @@ -131,11 +130,35 @@ public void updateOnMinimization(final Map old2New, * WARNING: At the moment we update only the contexts and the context2enry mapping, because we expect the our * HoareAnnotationFragments stores double deckers that have been removed by a dead end removal. */ - private void update(final IUpdate update, final INwaOutgoingLetterAndTransitionProvider newAbstraction) { - final Map> oldLiveContexts2ProgPoint2Preds = + private void update(final IUpdate update, + final INwaOutgoingLetterAndTransitionProvider newAbstraction) { + final Set oldStates; + if (mPred2ProgPoint.isEmpty()) { + oldStates = mHoareAnnotationPositions; + } else { + oldStates = new HashSet<>(mPred2ProgPoint.keySet()); + } + // TODO possibly merge this loop with the next, avoid redundant computation of getNewPredicates + for (final IPredicate oldState : oldStates) { + final IPredicate pp = getProgramPoint(oldState); + final List newStates = update.getNewPredicates(oldState); + if (newStates != null) { + for (final IPredicate newState : newStates) { + if (mPred2ProgPoint.containsKey(newState)) { + final IPredicate oldPP = mPred2ProgPoint.get(newState); + assert oldPP == pp : "State " + newState + " cannot represent both " + oldPP + " and " + pp + "!"; + } else { + mPred2ProgPoint.put(newState, pp); + } + } + mPred2ProgPoint.remove(oldState); + } + } + + final Map> oldLiveContexts2ProgPoint2Preds = mLiveContexts2ProgPoint2Preds; mLiveContexts2ProgPoint2Preds = new HashMap<>(); - for (final Entry> contextHrPair : oldLiveContexts2ProgPoint2Preds + for (final Entry> contextHrPair : oldLiveContexts2ProgPoint2Preds .entrySet()) { final IPredicate oldContext = contextHrPair.getKey(); final List newContexts = update.getNewPredicates(oldContext); @@ -146,7 +169,7 @@ private void update(final IUpdate update, final INwaOutgoingLetterAndTransitionP final IPredicate oldEntry = mContext2Entry.get(oldContext); mContext2Entry.remove(oldContext); for (int i = 0; i < newContexts.size(); i++) { - final HashRelation hr; + final HashRelation hr; if (i == newContexts.size() - 1) { // last iteration, we can use the original hr instead of // copy @@ -243,18 +266,18 @@ public List getNewPredicates(final IPredicate oldPredicate) { } } - void addDoubleDecker(final IPredicate down, final IPredicate up, final IPredicate emtpy) { - final IcfgLocation pp = getProgramPoint(up); + void addDoubleDecker(final IPredicate down, final IPredicate up, final IPredicate empty) { + final IPredicate pp = getProgramPoint(up); if ((mHoareAnnotationPos == HoareAnnotationPositions.LoopsAndPotentialCycles || mHoareAnnotationPos == HoareAnnotationPositions.LoopHeads) && !mHoareAnnotationPositions.contains(pp)) { // do not compute Hoare annotation for this program point return; } - if (down == emtpy) { + if (down == empty) { mProgPoint2StatesWithEmptyContext.addPair(pp, up); } else { - HashRelation pp2preds = mLiveContexts2ProgPoint2Preds.get(down); + HashRelation pp2preds = mLiveContexts2ProgPoint2Preds.get(down); if (pp2preds == null) { pp2preds = new HashRelation<>(); mLiveContexts2ProgPoint2Preds.put(down, pp2preds); @@ -263,14 +286,10 @@ void addDoubleDecker(final IPredicate down, final IPredicate up, final IPredicat } } - private IcfgLocation getProgramPoint(final IPredicate pred) { - final IcfgLocation pp; - if (pred instanceof SPredicate) { - pp = ((SPredicate) pred).getProgramPoint(); - } else if (pred instanceof UnknownState) { - pp = ((UnknownState) pred).getProgramPoint(); - } else { - throw new AssertionError("predicate does not offer program point"); + private IPredicate getProgramPoint(final IPredicate pred) { + final IPredicate pp = mPred2ProgPoint.get(pred); + if (pp == null) { + return pred; } return pp; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java index f381baf971f..e23cf7f4909 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java @@ -36,6 +36,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.SPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.UnknownState; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; @@ -66,17 +68,30 @@ public HoareAnnotationWriter(final IIcfg icfg, final CfgSmtToolkit csToolkit, } public void addHoareAnnotationToCFG() { - for (final Entry entry : mCegarLoopHoareAnnotation.getLoc2hoare().entrySet()) { - final HoareAnnotation taAnnot = HoareAnnotation.getAnnotation(entry.getKey()); + for (final Entry entry : mCegarLoopHoareAnnotation.getLoc2hoare().entrySet()) { + final IcfgLocation loc = getProgramPoint(entry.getKey()); + final HoareAnnotation taAnnot = HoareAnnotation.getAnnotation(loc); final HoareAnnotation hoareAnnot; if (taAnnot == null) { hoareAnnot = - mPredicateFactory.getNewHoareAnnotation(entry.getKey(), mCsToolkit.getModifiableGlobalsTable()); - hoareAnnot.annotate(entry.getKey()); + mPredicateFactory.getNewHoareAnnotation(loc, mCsToolkit.getModifiableGlobalsTable()); + hoareAnnot.annotate(loc); } else { hoareAnnot = taAnnot; } hoareAnnot.addInvariant(entry.getValue()); } } + + private IcfgLocation getProgramPoint(final IPredicate pred) { + final IcfgLocation pp; + if (pred instanceof SPredicate) { + pp = ((SPredicate) pred).getProgramPoint(); + } else if (pred instanceof UnknownState) { + pp = ((UnknownState) pred).getProgramPoint(); + } else { + throw new AssertionError("predicate does not offer program point"); + } + return pp; + } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 013a2f52461..aa38aca7a39 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -556,24 +556,30 @@ protected void finish() { @Override protected void computeIcfgHoareAnnotation() { - if (mCsToolkit.getManagedScript().isLocked()) { - throw new AssertionError("SMTManager must not be locked at the beginning of Hoare annotation computation"); - } - final INestedWordAutomaton abstraction = mAbstraction; mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); try { - new HoareAnnotationExtractor<>(getServices(), abstraction, mHaf); - final HoareAnnotationComposer clha = new HoareAnnotationComposer(mCsToolkit, mPredicateFactory, mHaf, - getServices(), mSimplificationTechnique, mXnfConversionTechnique); + final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); final HoareAnnotationWriter writer = new HoareAnnotationWriter(mIcfg, mCsToolkit, mPredicateFactory, clha, - getServices(), mSimplificationTechnique, mXnfConversionTechnique); - writer.addHoareAnnotationToCFG(); + mServices, mSimplificationTechnique, mXnfConversionTechnique); + // writer.addHoareAnnotationToCFG(); + mCegarLoopBenchmark.stop(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); mCegarLoopBenchmark.addHoareAnnotationData(clha.getHoareAnnotationStatisticsGenerator()); } finally { mCegarLoopBenchmark.stop(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); } } + protected HoareAnnotationComposer computeHoareAnnotationComposer() { + if (mCsToolkit.getManagedScript().isLocked()) { + throw new AssertionError("SMTManager must not be locked at the beginning of Hoare annotation computation"); + } + final INestedWordAutomaton abstraction = mAbstraction; + new HoareAnnotationExtractor<>(mServices, abstraction, mHaf); + final HoareAnnotationComposer clha = new HoareAnnotationComposer(mCsToolkit, mPredicateFactory, mHaf, mServices, + mSimplificationTechnique, mXnfConversionTechnique); + return clha; + } + private static final boolean checkStoreCounterExamples(final TAPreferences pref) { return pref.getMinimization() == Minimization.NWA_OVERAPPROXIMATION; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryRefinement.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryRefinement.java index 8859ee3e513..4cc5a937da2 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryRefinement.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryRefinement.java @@ -27,6 +27,7 @@ package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; import java.util.Iterator; import java.util.Map; @@ -73,8 +74,14 @@ public PredicateFactoryRefinement(final IUltimateServiceProvider services, final @Override public IPredicate intersection(final IPredicate p1, final IPredicate p2) { if (p1 instanceof IMLPredicate) { + final IcfgLocation[] pps = ((IMLPredicate) p1).getProgramPoints(); // assert mCsToolkit.isDontCare(p2); - assert !mComputeHoareAnnotation; + if (Arrays.stream(pps).anyMatch(mHoareAnnotationProgramPoints::contains)) { + Term conjunction = mPredicateFactory.and(p1, p2).getFormula(); + conjunction = new CommuhashNormalForm(mServices, mMgdScript.getScript()).transform(conjunction); + // TODO (2020-09-03 Dominik) Possibly support DEBUG_COMPUTE_HISTORY like below? + return mPredicateFactory.newMLPredicate(pps, conjunction); + } return mPredicateFactory.newMLDontCarePredicate(((IMLPredicate) p1).getProgramPoints()); } else if (p1 instanceof ISLPredicate) { final IcfgLocation pp = ((ISLPredicate) p1).getProgramPoint(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java index 3cc9c5ca88f..9f6dfa2e929 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java @@ -141,12 +141,7 @@ public TraceAbstractionStarter(final IUltimateServiceProvider services, final II mResultReporter = new CegarLoopResultReporter<>(mServices, mLogger, Activator.PLUGIN_ID, Activator.PLUGIN_NAME, this::recordLocationResult); - if (mPrefs.computeHoareAnnotation() && mIsConcurrent) { - mLogger.warn("Switching off computation of Hoare annotation because input is a concurrent program"); - mComputeHoareAnnotation = false; - } else { - mComputeHoareAnnotation = mPrefs.computeHoareAnnotation(); - } + mComputeHoareAnnotation = mPrefs.computeHoareAnnotation(); mCegarFactory = new CegarLoopFactory<>(transitionClazz, mPrefs, createCompositionFactory, copyFactory, mComputeHoareAnnotation); From 2c4dc825a8d7d8cb755394f61a57d9ca5abab6ac Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Wed, 29 Nov 2023 23:17:24 +0100 Subject: [PATCH 07/91] introduce IFloydHoareAnnotation --- .../FloydHoareForInterpolantAutomaton.java | 70 ++++++++++++++ .../floydhoare/FloydHoareMapping.java | 91 +++++++++++++++++++ .../floydhoare/IFloydHoareAnnotation.java | 41 +++++++++ .../NwaInitialAbstractionProvider.java | 18 ++-- .../predicates/InductivityCheck.java | 1 + 5 files changed, 212 insertions(+), 9 deletions(-) create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java new file mode 100644 index 00000000000..89b15376d79 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingTransitionProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; + +public class FloydHoareForInterpolantAutomaton implements IFloydHoareAnnotation { + private final INwaOutgoingTransitionProvider mInterpolantAutomaton; + private final IPredicate mPrecondition; + private final IPredicate mPostcondition; + + public FloydHoareForInterpolantAutomaton(final INwaOutgoingTransitionProvider interpolantAutomaton, + final IPredicateUnifier unifier) { + this(interpolantAutomaton, unifier.getTruePredicate(), unifier.getFalsePredicate()); + } + + public FloydHoareForInterpolantAutomaton(final INwaOutgoingTransitionProvider interpolantAutomaton, + final IPredicate precondition, final IPredicate postcondition) { + mInterpolantAutomaton = interpolantAutomaton; + mPrecondition = precondition; + mPostcondition = postcondition; + } + + @Override + public INwaOutgoingTransitionProvider getAnnotatedAutomaton() { + return mInterpolantAutomaton; + } + + @Override + public IPredicate getPrecondition() { + return mPrecondition; + } + + @Override + public IPredicate getPostcondition() { + return mPostcondition; + } + + @Override + public IPredicate getAnnotation(final IPredicate state) { + return state; + } +} diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java new file mode 100644 index 00000000000..e04be315314 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; + +import java.util.Map; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingTransitionProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; + +public class FloydHoareMapping implements IFloydHoareAnnotation { + private final INwaOutgoingTransitionProvider mAutomaton; + private final IPredicate mPrecondition; + private final IPredicate mPostcondition; + private final Map mAnnotation; + + private final IPredicate mDefaultPredicate; + + public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicateUnifier unifier, + final Map annotation) { + this(automaton, unifier, annotation, null); + } + + public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicateUnifier unifier, + final Map annotation, final IPredicate defaultPredicate) { + this(automaton, unifier.getTruePredicate(), unifier.getFalsePredicate(), annotation, defaultPredicate); + } + + public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicate precondition, + final IPredicate postcondition, final Map annotation) { + this(automaton, precondition, postcondition, annotation, null); + } + + public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicate precondition, + final IPredicate postcondition, final Map annotation, final IPredicate defaultPredicate) { + mAutomaton = automaton; + mPrecondition = precondition; + mPostcondition = postcondition; + mAnnotation = annotation; + mDefaultPredicate = defaultPredicate; + } + + @Override + public INwaOutgoingTransitionProvider getAnnotatedAutomaton() { + return mAutomaton; + } + + @Override + public IPredicate getPrecondition() { + return mPrecondition; + } + + @Override + public IPredicate getPostcondition() { + return mPostcondition; + } + + @Override + public IPredicate getAnnotation(final S state) { + final var predicate = mAnnotation.getOrDefault(state, mDefaultPredicate); + if (predicate == null) { + throw new IllegalArgumentException("No annotation for " + state); + } + return predicate; + } +} diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java new file mode 100644 index 00000000000..58d622af732 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingTransitionProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; + +public interface IFloydHoareAnnotation { + INwaOutgoingTransitionProvider getAnnotatedAutomaton(); + + IPredicate getPrecondition(); + + IPredicate getPostcondition(); + + IPredicate getAnnotation(S state); +} diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index 97f36c09f52..a149a0fb892 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -26,12 +26,12 @@ */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction; -import java.util.Map; import java.util.Set; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.statefactory.IEmptyStackStateFactory; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; @@ -41,6 +41,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IFloydHoareAnnotation; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; /** @@ -88,10 +89,9 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg IProofProducer, PROOF> getProofProducer(final Class proofType, final Class proofUpdates) { - // TODO replace Map by new class/interface (I)FloydHoareAnnotation if (proofUpdates == null || proofUpdates.isAssignableFrom(NwaHoareProofProducer.class)) { // TODO implement retrieval of suitable proof converter, if one exists - final IProofConverter, Map, PROOF> converter = + final IProofConverter, IFloydHoareAnnotation, PROOF> converter = null; if (converter != null) { @@ -103,23 +103,23 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg + private static final class NwaHoareProofProducer implements IProofProducer /* , INwaCegarLoop.ProofProducer */ { private final INestedWordAutomaton mProgram; - // TODO replace Map by new class/interface (I)FloydHoareAnnotation - private final IProofPostProcessor, Map, PROGRAM, PROOF> mPost; + private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; private NwaHoareProofProducer(final INestedWordAutomaton program, - final IProofPostProcessor, Map, PROGRAM, PROOF> postProcessor) { + final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { mProgram = program; mPost = postProcessor; assert postProcessor.getOriginalProgram() == mProgram; } - public static NwaHoareProofProducer, Map> + public static + NwaHoareProofProducer, IFloydHoareAnnotation> create(final INestedWordAutomaton program) { return new NwaHoareProofProducer<>(program, IProofPostProcessor.identity(program)); } @@ -138,7 +138,7 @@ public boolean hasProof() { @Override public PROOF getOrComputeProof() { // TODO - final Map floydHoare = null; + final IFloydHoareAnnotation floydHoare = null; return mPost.processProof(floydHoare); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java index 19951a304ba..e194c494078 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java @@ -51,6 +51,7 @@ * @param assertInductivity * if true, assert statements require inductivity (resp. anti-inductivity) */ +// TODO #proofRefactor : Make full-blown validity checker for IFloydHoareAnnotation public class InductivityCheck { private final IUltimateServiceProvider mServices; From a87a7c0f0931b9eb4a0d8d02ddcfb29c60471f59 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Wed, 29 Nov 2023 23:52:08 +0100 Subject: [PATCH 08/91] move Floyd/Hoare handling BasicCegarLoop should not refer to Floyd/Hoare proofs, let NwaCegarLoop handle this. Also, CEGAR loops refer directly to Hoare annotation states, not IcfgLocations. --- .../traceabstraction/BasicCegarLoop.java | 19 +------- .../traceabstraction/CegarLoopFactory.java | 46 +++++++++++-------- .../CegarLoopSWBnonRecursive.java | 4 +- .../traceabstraction/EagerReuseCegarLoop.java | 4 +- .../IncrementalInclusionCegarLoop.java | 4 +- .../traceabstraction/LazyReuseCegarLoop.java | 4 +- .../traceabstraction/NwaCegarLoop.java | 6 ++- .../traceabstraction/ReuseCegarLoop.java | 4 +- .../concurrency/CegarLoopForPetriNet.java | 4 +- .../concurrency/PartialOrderCegarLoop.java | 3 +- 10 files changed, 46 insertions(+), 52 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index 090c850c842..5e4055a2923 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -43,7 +43,6 @@ import java.util.Map; import java.util.Scanner; import java.util.Set; -import java.util.stream.Collectors; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryException; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryServices; @@ -92,7 +91,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskIterationIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult.BasicRefinementEngineResult; @@ -180,7 +178,6 @@ public String getShortString() { new LinkedHashSet<>(); protected boolean mFallbackToFpIfInterprocedural = false; - protected HoareAnnotationFragments mHaf; protected IRefinementEngineResult> mRefinementResult; private boolean mFirstReuseDump = true; @@ -188,9 +185,8 @@ public String getShortString() { public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, InterpolationTechnique interpolation, - final boolean computeHoareAnnotation, final Set hoareAnnotationLocs, - final IUltimateServiceProvider services, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { + final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(services, name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, services.getLoggingService().getLogger(Activator.PLUGIN_ID), transitionClazz, computeHoareAnnotation); mPathProgramDumpController = new PathProgramDumpController<>(getServices(), mPref, mIcfg); @@ -201,17 +197,6 @@ public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, fi } mStoreFloydHoareAutomata = taPrefs.getFloydHoareAutomataReuse() != FloydHoareAutomataReuse.NONE; - - final Set hoareAnnotationStates; - if (initialAbstraction instanceof INestedWordAutomaton) { - final var nwa = (INestedWordAutomaton) initialAbstraction; - hoareAnnotationStates = nwa.getStates().stream() - .filter(p -> PredicateUtils.getLocations(p).anyMatch(hoareAnnotationLocs::contains)) - .collect(Collectors.toSet()); - } else { - hoareAnnotationStates = Set.of(); - } - mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates, mPref.getHoareAnnotationPositions()); mStateFactoryForRefinement = stateFactoryForRefinement; // TODO #proofRefactor diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index c4660cfcfe6..68ef1ffb7ec 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -32,6 +32,7 @@ import java.util.List; import java.util.Set; import java.util.function.Supplier; +import java.util.stream.Collectors; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryException; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryServices; @@ -53,6 +54,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.IInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.NwaInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.PartialOrderAbstractionProvider; @@ -145,20 +147,20 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr csToolkit.getManagedScript(), predicateFactory, mComputeHoareAnnotation, hoareAnnotationLocs); if (languageOperation != LanguageOperation.DIFFERENCE) { - return new IncrementalInclusionCegarLoop<>(name, - createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, - witnessAutomaton), - root, csToolkit, predicateFactory, mPrefs, errorLocs, mPrefs.interpolation(), - mComputeHoareAnnotation, hoareAnnotationLocs, services, languageOperation, mTransitionClazz, - stateFactoryForRefinement); + final var abstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, + stateFactoryForRefinement, witnessAutomaton); + return new IncrementalInclusionCegarLoop<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, + errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + hoareAnnotationStates(hoareAnnotationLocs, abstraction), services, languageOperation, + mTransitionClazz, stateFactoryForRefinement); } if (mPrefs.interpolantAutomaton() == InterpolantAutomaton.TOTALINTERPOLATION) { - return new CegarLoopSWBnonRecursive<>(name, - createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, - witnessAutomaton), - root, csToolkit, predicateFactory, mPrefs, errorLocs, mPrefs.interpolation(), - mComputeHoareAnnotation, hoareAnnotationLocs, services, mTransitionClazz, + final var abstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, + stateFactoryForRefinement, witnessAutomaton); + return new CegarLoopSWBnonRecursive<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, + errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + hoareAnnotationStates(hoareAnnotationLocs, abstraction), services, mTransitionClazz, stateFactoryForRefinement); } @@ -225,17 +227,18 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService switch (mPrefs.getFloydHoareAutomataReuse()) { case EAGER: return new EagerReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, hoareAnnotationLocs, services, - Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, - stateFactoryForRefinement); + errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, Collections.emptyList(), + rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case LAZY_IN_ORDER: return new LazyReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, hoareAnnotationLocs, services, - Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, - stateFactoryForRefinement); + errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, Collections.emptyList(), + rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case NONE: return new NwaCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, errorLocs, - mPrefs.interpolation(), mComputeHoareAnnotation, hoareAnnotationLocs, services, mTransitionClazz, + mPrefs.interpolation(), mComputeHoareAnnotation, + hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, mTransitionClazz, stateFactoryForRefinement); default: throw new AssertionError("Unknown Setting: " + mPrefs.getFloydHoareAutomataReuse()); @@ -349,6 +352,13 @@ private > A constructInitialAbstraction( } } + private static Set hoareAnnotationStates(final Set hoareAnnotationLocs, + final INestedWordAutomaton initialAbstraction) { + return initialAbstraction.getStates().stream() + .filter(p -> PredicateUtils.getLocations(p).anyMatch(hoareAnnotationLocs::contains)) + .collect(Collectors.toSet()); + } + public CegarLoopStatisticsGenerator getStatistics() { return mCegarLoopBenchmark; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 0d6f90b4656..8ff29f3fd6a 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -174,11 +174,11 @@ public CegarLoopSWBnonRecursive(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg icfg, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, - final boolean computeHoareAnnotation, final Set hoareAnnotationLocs, + final boolean computeHoareAnnotation, final Set hoareAnnotationStates, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationLocs, services, transitionClazz, stateFactoryForRefinement); + computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, stateFactoryForRefinement); mErrorPathHistory = new ArrayList<>(); mnofStates = new ArrayList<>(); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index 8db30513e41..a568ee7e0a7 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -80,12 +80,12 @@ public EagerReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomato final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationLocs, final IUltimateServiceProvider services, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationLocs, services, floydHoareAutomataFromOtherLocations, + computeHoareAnnotation, hoareAnnotationStates, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFile, transitionClazz, stateFactoryForRefinement); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index 02acc77a033..1637082673c 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -86,11 +86,11 @@ public IncrementalInclusionCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, - final boolean computeHoareAnnotation, final Set hoareAnnotationLocs, + final boolean computeHoareAnnotation, final Set hoareAnnotationStates, final IUltimateServiceProvider services, final LanguageOperation languageOperation, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationLocs, services, transitionClazz, stateFactoryForRefinement); + computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, stateFactoryForRefinement); mLanguageOperation = languageOperation; // TODO #proofRefactor diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index fc38e9bc534..08213130180 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -79,12 +79,12 @@ public LazyReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationLocs, final IUltimateServiceProvider services, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFiles, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationLocs, services, floydHoareAutomataFromOtherLocations, + computeHoareAnnotation, hoareAnnotationStates, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFiles, transitionClazz, stateFactoryForRefinement); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index aa38aca7a39..413187611cf 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -135,16 +135,18 @@ public class NwaCegarLoop> extends BasicCegarLoop mProofUpdater = null; + protected HoareAnnotationFragments mHaf; public NwaCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationLocs, final IUltimateServiceProvider services, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationLocs, services, transitionClazz, stateFactoryForRefinement); + computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates, mPref.getHoareAnnotationPositions()); mErrorGeneralizationEngine = new ErrorGeneralizationEngine<>(services); final IPreferenceProvider prefs = mServices.getPreferenceProvider(Activator.PLUGIN_ID); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java index 3b5b5c46aa3..28757a8ff55 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java @@ -109,12 +109,12 @@ public ReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationLocs, final IUltimateServiceProvider services, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationLocs, services, transitionClazz, stateFactoryForRefinement); + computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, stateFactoryForRefinement); mFloydHoareAutomataFromOtherErrorLocations = floydHoareAutomataFromOtherLocations; mRawFloydHoareAutomataFromFile = rawFloydHoareAutomataFromFile; mFloydHoareAutomataFromFile = new ArrayList<>(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index fc337351300..f9fb2b1af78 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -27,7 +27,6 @@ */ package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.concurrency; -import java.util.Collections; import java.util.HashSet; import java.util.Map; import java.util.Map.Entry; @@ -155,8 +154,7 @@ public CegarLoopForPetriNet(final DebugIdentifier name, final BoundedPetriNet errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - taPrefs.interpolation(), false, Collections.emptySet(), services, transitionClazz, - stateFactoryForRefinement); + taPrefs.interpolation(), false, services, transitionClazz, stateFactoryForRefinement); mPetriClStatisticsGenerator = new PetriCegarLoopStatisticsGenerator(mCegarLoopBenchmark); mCounterexampleCache = new CounterexampleCache<>(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java index 7275f9555b5..61c8fffa24b 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java @@ -28,7 +28,6 @@ package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.concurrency; import java.util.Arrays; -import java.util.Collections; import java.util.Comparator; import java.util.LinkedList; import java.util.List; @@ -136,7 +135,7 @@ public PartialOrderCegarLoop(final DebugIdentifier name, final List> independenceProviders, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, false, - Collections.emptySet(), services, transitionClazz, stateFactoryForRefinement); + services, transitionClazz, stateFactoryForRefinement); assert !mPref.applyOneShotPOR() : "Turn off one-shot partial order reduction when using this CEGAR loop."; From 224148a46ea3cdd11af22658f4978594b8cdc945 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 00:33:58 +0100 Subject: [PATCH 09/91] HoareAnnotationFragments: rely on supplied hoareAnnotationStates Do not check the setting again, the caller should supply the appropriate states. --- .../traceabstraction/HoareAnnotationFragments.java | 14 ++++---------- .../generator/traceabstraction/NwaCegarLoop.java | 2 +- 2 files changed, 5 insertions(+), 11 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java index b779254dad2..988b59b5769 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java @@ -46,7 +46,6 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.HashRelation; /** @@ -77,8 +76,6 @@ public class HoareAnnotationFragments { private final Set mHoareAnnotationPositions; - private final HoareAnnotationPositions mHoareAnnotationPos; - Map> getDeadContexts2ProgPoint2Preds() { return mDeadContexts2ProgPoint2Preds; } @@ -95,11 +92,9 @@ HashMap getCallpred2Entry() { return mContext2Entry; } - public HoareAnnotationFragments(final ILogger logger, final Set hoareAnnotationLocations, - final HoareAnnotationPositions hoareAnnotationPos) { + public HoareAnnotationFragments(final ILogger logger, final Set hoareAnnotationStates) { mLogger = logger; - mHoareAnnotationPositions = hoareAnnotationLocations; - mHoareAnnotationPos = hoareAnnotationPos; + mHoareAnnotationPositions = hoareAnnotationStates; } /** @@ -268,12 +263,11 @@ public List getNewPredicates(final IPredicate oldPredicate) { void addDoubleDecker(final IPredicate down, final IPredicate up, final IPredicate empty) { final IPredicate pp = getProgramPoint(up); - if ((mHoareAnnotationPos == HoareAnnotationPositions.LoopsAndPotentialCycles - || mHoareAnnotationPos == HoareAnnotationPositions.LoopHeads) - && !mHoareAnnotationPositions.contains(pp)) { + if (!mHoareAnnotationPositions.contains(pp)) { // do not compute Hoare annotation for this program point return; } + if (down == empty) { mProgPoint2StatesWithEmptyContext.addPair(pp, up); } else { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 413187611cf..f4b24040e77 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -145,8 +145,8 @@ public NwaCegarLoop(final DebugIdentifier name, final INestedWordAutomaton transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates); - mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates, mPref.getHoareAnnotationPositions()); mErrorGeneralizationEngine = new ErrorGeneralizationEngine<>(services); final IPreferenceProvider prefs = mServices.getPreferenceProvider(Activator.PLUGIN_ID); From 0cd99438141ca5ec8fc800811188798fca541b4f Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 00:51:10 +0100 Subject: [PATCH 10/91] move HoareAnnotationPositions to its own file Also define their semantics in the class itself, rather than in some utility class. --- .../META-INF/MANIFEST.MF | 1 + .../proofs/HoareAnnotationPositions.java | 66 +++++++++++++++++++ .../traceabstraction/AbstractCegarLoop.java | 2 +- .../traceabstraction/CegarLoopFactory.java | 4 +- .../TraceAbstractionUtils.java | 30 --------- .../preferences/TAPreferences.java | 2 +- ...TraceAbstractionPreferenceInitializer.java | 8 +-- 7 files changed, 72 insertions(+), 41 deletions(-) create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java diff --git a/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF b/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF index 0ed517d9925..49641243192 100644 --- a/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF +++ b/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF @@ -13,6 +13,7 @@ Export-Package: de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.abstraction, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.predicates, + de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.lib.smtlib, diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java new file mode 100644 index 00000000000..4b9010a9477 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; + +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgUtils; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; + +/** + * Hoare annotation position. + */ +public enum HoareAnnotationPositions { + All, LoopHeads, LoopsAndPotentialCycles; + + public Set getLocationsForWhichHoareAnnotationIsComputed(final IIcfg root) { + final Set hoareAnnotationLocs = new HashSet<>(); + switch (this) { + case All: + for (final Map value : root.getProgramPoints().values()) { + hoareAnnotationLocs.addAll(value.values()); + } + break; + case LoopsAndPotentialCycles: + hoareAnnotationLocs.addAll(root.getLoopLocations()); + hoareAnnotationLocs.addAll(IcfgUtils.getCallerAndCalleePoints(root)); + hoareAnnotationLocs.addAll(IcfgUtils.getPotentialCycleProgramPoints(root)); + break; + case LoopHeads: + hoareAnnotationLocs.addAll(root.getLoopLocations()); + hoareAnnotationLocs.addAll(IcfgUtils.getCallerAndCalleePoints(root)); + break; + default: + throw new AssertionError("unknown value " + this); + } + return hoareAnnotationLocs; + } +} \ No newline at end of file diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index cf9282d5401..fb4de455eb9 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -85,6 +85,7 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.logic.Script; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; @@ -93,7 +94,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences.Artifact; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.FloydHoareAutomataReuse; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.util.CoreUtil; import de.uni_freiburg.informatik.ultimate.util.ReflectionUtil; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 68ef1ffb7ec..0116a87c810 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -138,8 +138,8 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr final Set hoareAnnotationLocs; if (mComputeHoareAnnotation) { - hoareAnnotationLocs = TraceAbstractionUtils.getLocationsForWhichHoareAnnotationIsComputed(root, - mPrefs.getHoareAnnotationPositions()); + hoareAnnotationLocs = + mPrefs.getHoareAnnotationPositions().getLocationsForWhichHoareAnnotationIsComputed(root); } else { hoareAnnotationLocs = Collections.emptySet(); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java index d5cdd1bffe1..c5637dc52d5 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java @@ -32,7 +32,6 @@ import java.util.HashSet; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Set; import java.util.function.Function; @@ -45,14 +44,10 @@ import de.uni_freiburg.informatik.ultimate.automata.util.PartitionBackedSetOfPairs; import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.ModifiableGlobalsTable; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.ICallAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IInternalAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IReturnAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramNonOldVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramOldVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramVar; @@ -69,7 +64,6 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.Substitution; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.BoogieIcfgLocation; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.HashRelation; /** @@ -156,30 +150,6 @@ public static Term renameGlobalsToOldGlobals(final IPredicate ps, final IUltimat return result; } - public static Set getLocationsForWhichHoareAnnotationIsComputed( - final IIcfg root, final HoareAnnotationPositions hoareAnnotationPositions) { - final Set hoareAnnotationLocs = new HashSet<>(); - switch (hoareAnnotationPositions) { - case All: - for (final Entry> entry : root.getProgramPoints().entrySet()) { - hoareAnnotationLocs.addAll(entry.getValue().values()); - } - break; - case LoopsAndPotentialCycles: - hoareAnnotationLocs.addAll(root.getLoopLocations()); - hoareAnnotationLocs.addAll(IcfgUtils.getCallerAndCalleePoints(root)); - hoareAnnotationLocs.addAll(IcfgUtils.getPotentialCycleProgramPoints(root)); - break; - case LoopHeads: - hoareAnnotationLocs.addAll(root.getLoopLocations()); - hoareAnnotationLocs.addAll(IcfgUtils.getCallerAndCalleePoints(root)); - break; - default: - throw new AssertionError("unknown value " + hoareAnnotationPositions); - } - return hoareAnnotationLocs; - } - /** * For each oldVar in vars that is not modifiable by procedure proc: substitute * the oldVar by the corresponding globalVar in term and remove the oldvar from diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java index ca7a3cf6b92..8cb5a8d17a7 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java @@ -45,6 +45,7 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.AbstractionType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.IndependenceType; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Logics; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.preferences.RcfgPreferenceInitializer; @@ -52,7 +53,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.CoinflipMode; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.FloydHoareAutomataReuse; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.FloydHoareAutomataReuseEnhancement; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.InterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.McrInterpolantMethod; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.Minimization; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java index 8447996dd9b..05a2cd76dcc 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java @@ -56,6 +56,7 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.AbstractionType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.IndependenceType; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.preferences.RcfgPreferenceInitializer; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.Activator; @@ -814,13 +815,6 @@ public enum LanguageOperation { INCREMENTAL_INCLUSION_5_2, } - /** - * Hoare annotation position. - */ - public enum HoareAnnotationPositions { - All, LoopHeads, LoopsAndPotentialCycles, - } - /** * Search strategy for counterexamples in the remainder language of the current abstraction (automaton). * From c9454fed79ccf992ce1b1d3774b32cdc58bc595b Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 00:54:12 +0100 Subject: [PATCH 11/91] begin defining interfaces for proof updates in NwaCegarLoop --- .../proofs/IUpdateOnDifference.java | 43 +++++++++++++++++++ .../proofs/IUpdateOnMinimization.java | 37 ++++++++++++++++ 2 files changed, 80 insertions(+) create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnDifference.java create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnMinimization.java diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnDifference.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnDifference.java new file mode 100644 index 00000000000..1c549eb8681 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnDifference.java @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; + +import java.util.Map; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.IDoubleDeckerAutomaton; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.ProductNwa; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.oldapi.IOpWithDelayedDeadEndRemoval; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; + +public interface IUpdateOnDifference { + boolean exploitSigmaStarConcatOfIa(); + + void updateOnIntersection(Map.ProductState>> fst2snd2res, + IDoubleDeckerAutomaton result); + + void addDeadEndDoubleDeckers(IOpWithDelayedDeadEndRemoval diff); +} \ No newline at end of file diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnMinimization.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnMinimization.java new file mode 100644 index 00000000000..16231f16848 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnMinimization.java @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; + +import java.util.Map; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingLetterAndTransitionProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; + +public interface IUpdateOnMinimization { + void updateOnMinimization(final Map old2New, + final INwaOutgoingLetterAndTransitionProvider abstraction); +} \ No newline at end of file From c3557f28687c10ff20a0710d2e03fecdb518881e Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 00:55:15 +0100 Subject: [PATCH 12/91] move NwaHoareProofProducer to its own file --- .../NwaHoareProofProducer.java | 128 ++++++++++++++++++ .../NwaInitialAbstractionProvider.java | 61 +-------- 2 files changed, 132 insertions(+), 57 deletions(-) create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java new file mode 100644 index 00000000000..a1a6913cbc7 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction; + +import java.util.Map; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.IDoubleDeckerAutomaton; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingLetterAndTransitionProvider; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.ProductNwa; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.oldapi.IOpWithDelayedDeadEndRemoval; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofPostProcessor; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IFloydHoareAnnotation; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; + +final class NwaHoareProofProducer + implements IProofProducer, IUpdateOnMinimization, IUpdateOnDifference { + + private final INestedWordAutomaton mProgram; + // private final Set mHoareAnnotationStates; + private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; + + private NwaHoareProofProducer(final INestedWordAutomaton program, // final Set hoareAnnotationStates, + final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { + mProgram = program; + // mHoareAnnotationStates = hoareAnnotationStates; + // mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates); + mPost = postProcessor; + + assert postProcessor.getOriginalProgram() == mProgram; + } + + public static + NwaHoareProofProducer, IFloydHoareAnnotation> + create(final INestedWordAutomaton program + // , final Set hoareAnnotationStates + ) { + return new NwaHoareProofProducer<>(program, + // hoareAnnotationStates, + IProofPostProcessor.identity(program)); + } + + @Override + public PROGRAM getProgram() { + return mPost.getOriginalProgram(); + } + + @Override + public boolean hasProof() { + // TODO Auto-generated method stub + return false; + } + + @Override + public PROOF getOrComputeProof() { + // TODO + final IFloydHoareAnnotation floydHoare = null; + return mPost.processProof(floydHoare); + } + + @Override + public IProofProducer + withPostProcessor(final IProofPostProcessor postProcessor) { + return new NwaHoareProofProducer<>(mProgram, // mHoareAnnotationStates, + IProofPostProcessor.compose(mPost, postProcessor)); + } + + @Override + public IStatisticsDataProvider getStatistics() { + // TODO Auto-generated method stub + throw new UnsupportedOperationException(); + } + + @Override + public boolean exploitSigmaStarConcatOfIa() { + return false; + } + + @Override + public void updateOnIntersection( + final Map.ProductState>> fst2snd2res, + final IDoubleDeckerAutomaton result) { + // TODO Auto-generated method stub + + } + + @Override + public void addDeadEndDoubleDeckers(final IOpWithDelayedDeadEndRemoval diff) { + // TODO Auto-generated method stub + + } + + @Override + public void updateOnMinimization(final Map old2New, + final INwaOutgoingLetterAndTransitionProvider abstraction) { + // TODO Auto-generated method stub + + } +} \ No newline at end of file diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index a149a0fb892..cd21bc5848c 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -31,18 +31,15 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.statefactory.IEmptyStackStateFactory; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofConverter; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofPostProcessor; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IFloydHoareAnnotation; -import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; /** * Provides an initial abstraction in the form of a nested word automaton. This is only applicable to sequential @@ -69,7 +66,10 @@ public class NwaInitialAbstractionProvider> */ public NwaInitialAbstractionProvider(final IUltimateServiceProvider services, final IEmptyStackStateFactory stateFactory, final boolean interprocedural, - final PredicateFactory predicateFactory) { + final PredicateFactory predicateFactory // , + // TODO: Add HoareAnnotationPositions.NONE in place of this boolean + // final boolean computeHoareAnnotation, final HoareAnnotationPositions hoarePositions + ) { mServices = services; mStateFactory = stateFactory; mInterprocedural = interprocedural; @@ -101,57 +101,4 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg - implements IProofProducer /* , INwaCegarLoop.ProofProducer */ { - - private final INestedWordAutomaton mProgram; - - private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; - - private NwaHoareProofProducer(final INestedWordAutomaton program, - final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { - mProgram = program; - mPost = postProcessor; - - assert postProcessor.getOriginalProgram() == mProgram; - } - - public static - NwaHoareProofProducer, IFloydHoareAnnotation> - create(final INestedWordAutomaton program) { - return new NwaHoareProofProducer<>(program, IProofPostProcessor.identity(program)); - } - - @Override - public PROGRAM getProgram() { - return mPost.getOriginalProgram(); - } - - @Override - public boolean hasProof() { - // TODO Auto-generated method stub - return false; - } - - @Override - public PROOF getOrComputeProof() { - // TODO - final IFloydHoareAnnotation floydHoare = null; - return mPost.processProof(floydHoare); - } - - @Override - public IProofProducer - withPostProcessor(final IProofPostProcessor postProcessor) { - return new NwaHoareProofProducer<>(mProgram, IProofPostProcessor.compose(mPost, postProcessor)); - } - - @Override - public IStatisticsDataProvider getStatistics() { - // TODO Auto-generated method stub - throw new UnsupportedOperationException(); - } - } } From 94a263cd8eeb0c5566140de86689a2cbd208b34c Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 00:58:31 +0100 Subject: [PATCH 13/91] let CEGAR loops accept proof updaters --- .../traceabstraction/CegarLoopFactory.java | 13 +++-- .../CegarLoopSWBnonRecursive.java | 15 +++--- .../traceabstraction/EagerReuseCegarLoop.java | 18 ++++--- .../IncrementalInclusionCegarLoop.java | 20 ++++--- .../traceabstraction/LazyReuseCegarLoop.java | 18 ++++--- .../traceabstraction/NwaCegarLoop.java | 54 ++++++++++++++----- .../traceabstraction/ReuseCegarLoop.java | 16 +++--- .../CegarLoopConcurrentAutomata.java | 4 +- 8 files changed, 103 insertions(+), 55 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 0116a87c810..6900117be33 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -149,8 +149,9 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr if (languageOperation != LanguageOperation.DIFFERENCE) { final var abstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); + // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new IncrementalInclusionCegarLoop<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, hoareAnnotationStates(hoareAnnotationLocs, abstraction), services, languageOperation, mTransitionClazz, stateFactoryForRefinement); } @@ -158,8 +159,9 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr if (mPrefs.interpolantAutomaton() == InterpolantAutomaton.TOTALINTERPOLATION) { final var abstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); + // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new CegarLoopSWBnonRecursive<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, hoareAnnotationStates(hoareAnnotationLocs, abstraction), services, mTransitionClazz, stateFactoryForRefinement); } @@ -220,6 +222,7 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService final Set hoareAnnotationLocs, final PredicateFactoryRefinement stateFactoryForRefinement, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton) { + // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loops final INestedWordAutomaton initialAbstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); final CfgSmtToolkit csToolkit = root.getCfgSmtToolkit(); @@ -227,17 +230,17 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService switch (mPrefs.getFloydHoareAutomataReuse()) { case EAGER: return new EagerReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case LAZY_IN_ORDER: return new LazyReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), mComputeHoareAnnotation, + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case NONE: return new NwaCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, errorLocs, - mPrefs.interpolation(), mComputeHoareAnnotation, + mPrefs.interpolation(), null, mComputeHoareAnnotation, hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, mTransitionClazz, stateFactoryForRefinement); default: diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 8ff29f3fd6a..4c4c2414791 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -64,6 +64,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.tracecheck.ITraceCheckPreferences.AssertCodeBlockOrder; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheckCraig; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheck; @@ -170,15 +172,16 @@ public class CegarLoopSWBnonRecursive> extends NwaC * @param services * @param transitionClazz */ - public CegarLoopSWBnonRecursive(final DebugIdentifier name, - final INestedWordAutomaton initialAbstraction, final IIcfg icfg, - final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final InterpolationTechnique interpolation, - final boolean computeHoareAnnotation, final Set hoareAnnotationStates, + public & IUpdateOnMinimization> CegarLoopSWBnonRecursive( + final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + final IIcfg icfg, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, + final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, + final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, + stateFactoryForRefinement); mErrorPathHistory = new ArrayList<>(); mnofStates = new ArrayList<>(); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index a568ee7e0a7..89c64c705ad 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -49,6 +49,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; @@ -76,17 +78,19 @@ private enum MinimizeInitially { private static final boolean IDENTIFY_USELESS_FLOYDHOARE_AUTOMATA = false; // TODO can this method be removed? - public EagerReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, - final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, + public & IUpdateOnMinimization> EagerReuseCegarLoop(final DebugIdentifier name, + final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, + final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, + final Set errorLocs, final InterpolationTechnique interpolation, + final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationStates, services, floydHoareAutomataFromOtherLocations, - rawFloydHoareAutomataFromFile, transitionClazz, stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, + floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFile, transitionClazz, + stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index 1637082673c..02fadc606bf 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -66,6 +66,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; @@ -82,15 +84,17 @@ public class IncrementalInclusionCegarLoop> extends protected final List> mInterpolantAutomata = new ArrayList<>(); protected final List mHoareTripleChecker = new ArrayList<>(); - public IncrementalInclusionCegarLoop(final DebugIdentifier name, - final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, - final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final InterpolationTechnique interpolation, - final boolean computeHoareAnnotation, final Set hoareAnnotationStates, - final IUltimateServiceProvider services, final LanguageOperation languageOperation, - final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + public & IUpdateOnMinimization> IncrementalInclusionCegarLoop( + final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, + final TAPreferences taPrefs, final Set errorLocs, + final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, + final LanguageOperation languageOperation, final Class transitionClazz, + final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, + stateFactoryForRefinement); mLanguageOperation = languageOperation; // TODO #proofRefactor diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index 08213130180..5e1ad33503c 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -53,6 +53,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; @@ -75,17 +77,19 @@ public class LazyReuseCegarLoop> extends ReuseCegar private Pair, IPredicateUnifier> mAutomatonAcceptingCounterexample; - public LazyReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, - final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, + public & IUpdateOnMinimization> LazyReuseCegarLoop(final DebugIdentifier name, + final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, + final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, + final Set errorLocs, final InterpolationTechnique interpolation, + final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFiles, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationStates, services, floydHoareAutomataFromOtherLocations, - rawFloydHoareAutomataFromFiles, transitionClazz, stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, + floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFiles, transitionClazz, + stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index f4b24040e77..44f11fceca5 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -87,6 +87,8 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SMTFeatureExtractionTermClassifier.ScoringMethod; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.PathProgram; @@ -134,17 +136,19 @@ public class NwaCegarLoop> extends BasicCegarLoop mProofUpdater = null; + private final ProofUpdater mProofUpdater; protected HoareAnnotationFragments mHaf; - public NwaCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, - final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, - final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + public & IUpdateOnMinimization> NwaCegarLoop(final DebugIdentifier name, + final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, + final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, + final Set errorLocs, final InterpolationTechnique interpolation, + final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, + final IUltimateServiceProvider services, final Class transitionClazz, + final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + mProofUpdater = proofUpdater == null ? null : new ProofUpdater<>(proofUpdater); mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates); mErrorGeneralizationEngine = new ErrorGeneralizationEngine<>(services); @@ -598,15 +602,37 @@ private static SearchStrategy getSearchStrategy(final IPreferenceProvider mPrefs } } - public interface IProofUpdater { - boolean exploitSigmaStarConcatOfIa(); + // Annoyingly, this wrapper seems currently necessary due to Java's limited support for intersection types. + // The alternative is including a type parameter as below in the NwaCegarLoop itself. + private static final class ProofUpdater & IUpdateOnDifference> + implements IUpdateOnMinimization, IUpdateOnDifference { + private final T mUpdater; - void updateOnIntersection(Map.ProductState>> fst2snd2res, - IDoubleDeckerAutomaton result); + public ProofUpdater(final T updater) { + mUpdater = updater; + } + + @Override + public boolean exploitSigmaStarConcatOfIa() { + return mUpdater.exploitSigmaStarConcatOfIa(); + } - void updateOnMinimization(final Map old2New, - final INwaOutgoingLetterAndTransitionProvider abstraction); + @Override + public void updateOnIntersection( + final Map.ProductState>> fst2snd2res, + final IDoubleDeckerAutomaton result) { + mUpdater.updateOnIntersection(fst2snd2res, result); + } - void addDeadEndDoubleDeckers(IOpWithDelayedDeadEndRemoval diff); + @Override + public void addDeadEndDoubleDeckers(final IOpWithDelayedDeadEndRemoval diff) { + mUpdater.addDeadEndDoubleDeckers(diff); + } + + @Override + public void updateOnMinimization(final Map old2New, + final INwaOutgoingLetterAndTransitionProvider abstraction) { + mUpdater.updateOnMinimization(old2New, abstraction); + } } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java index 28757a8ff55..fd25ecdf506 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java @@ -69,6 +69,8 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; @@ -105,16 +107,18 @@ public class ReuseCegarLoop> extends NwaCegarLoop initialAbstraction, - final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, + public & IUpdateOnMinimization> ReuseCegarLoop(final DebugIdentifier name, + final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, + final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, + final Set errorLocs, final InterpolationTechnique interpolation, + final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, + stateFactoryForRefinement); mFloydHoareAutomataFromOtherErrorLocations = floydHoareAutomataFromOtherLocations; mRawFloydHoareAutomataFromFile = rawFloydHoareAutomataFromFile; mFloydHoareAutomataFromFile = new ArrayList<>(); diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index ea9893d2886..c7b6a2322ea 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -79,8 +79,8 @@ public CegarLoopConcurrentAutomata(final DebugIdentifier name, final IIcfg ro final Set errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, createInitialAbstraction(services, csToolkit, predicateFactory, taPrefs, rootNode), rootNode, - csToolkit, predicateFactory, taPrefs, errorLocs, taPrefs.interpolation(), false, Collections.emptySet(), - services, transitionClazz, stateFactoryForRefinement); + csToolkit, predicateFactory, taPrefs, errorLocs, taPrefs.interpolation(), null, false, + Collections.emptySet(), services, transitionClazz, stateFactoryForRefinement); } private static > INestedWordAutomaton createInitialAbstraction( From 05c04795d35614cec97a1fddd90fa426d97e345a Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 01:15:35 +0100 Subject: [PATCH 14/91] add HoareAnnotationPositions.None --- .../initialabstraction/NwaInitialAbstractionProvider.java | 2 ++ .../tracecheckerutils/proofs/HoareAnnotationPositions.java | 4 +++- .../traceabstraction/preferences/TAPreferences.java | 6 ++++-- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index cd21bc5848c..7fa749fb5e9 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -89,6 +89,8 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg IProofProducer, PROOF> getProofProducer(final Class proofType, final Class proofUpdates) { + // TODO if hoareAnnotationStates.isEmpty() return null + if (proofUpdates == null || proofUpdates.isAssignableFrom(NwaHoareProofProducer.class)) { // TODO implement retrieval of suitable proof converter, if one exists final IProofConverter, IFloydHoareAnnotation, PROOF> converter = diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java index 4b9010a9477..db24bf964b5 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java @@ -39,7 +39,7 @@ * Hoare annotation position. */ public enum HoareAnnotationPositions { - All, LoopHeads, LoopsAndPotentialCycles; + All, LoopHeads, LoopsAndPotentialCycles, None; public Set getLocationsForWhichHoareAnnotationIsComputed(final IIcfg root) { final Set hoareAnnotationLocs = new HashSet<>(); @@ -58,6 +58,8 @@ public Set getLocationsForWhichHoareAnnotationIs hoareAnnotationLocs.addAll(root.getLoopLocations()); hoareAnnotationLocs.addAll(IcfgUtils.getCallerAndCalleePoints(root)); break; + case None: + return Set.of(); default: throw new AssertionError("unknown value " + this); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java index 8cb5a8d17a7..902acc902f0 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java @@ -126,8 +126,8 @@ public TAPreferences(final IUltimateServiceProvider services) { mHoare = mPrefs.getBoolean(TraceAbstractionPreferenceInitializer.LABEL_HOARE); - mHoareAnnotationPositions = mPrefs.getEnum(TraceAbstractionPreferenceInitializer.LABEL_HOARE_POSITIONS, - HoareAnnotationPositions.class); + mHoareAnnotationPositions = mHoare ? mPrefs.getEnum(TraceAbstractionPreferenceInitializer.LABEL_HOARE_POSITIONS, + HoareAnnotationPositions.class) : HoareAnnotationPositions.None; mInterpolation = mPrefs.getEnum(TraceAbstractionPreferenceInitializer.LABEL_INTERPOLATED_LOCS, InterpolationTechnique.class); @@ -346,6 +346,8 @@ public Concurrency getAutomataTypeConcurrency() { return mAutomataTypeConcurrency; } + // TODO #proofRefactor + @Deprecated public boolean computeHoareAnnotation() { return mHoare; } From 87eb079b6edaa9271a0f9313ae513ad0c838925a Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 01:29:01 +0100 Subject: [PATCH 15/91] specialize return type --- .../initialabstraction/NwaHoareProofProducer.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java index a1a6913cbc7..0bc2a600c85 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java @@ -88,7 +88,7 @@ public PROOF getOrComputeProof() { } @Override - public IProofProducer + public NwaHoareProofProducer withPostProcessor(final IProofPostProcessor postProcessor) { return new NwaHoareProofProducer<>(mProgram, // mHoareAnnotationStates, IProofPostProcessor.compose(mPost, postProcessor)); From 3f177bc06c4c0192f0e00ae8a1b1badc8118ea8e Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 19:26:09 +0100 Subject: [PATCH 16/91] IFloydHoareAnnoation: decouple from automaton --- .../FloydHoareForInterpolantAutomaton.java | 16 +++------------- .../floydhoare/FloydHoareMapping.java | 7 ------- .../floydhoare/IFloydHoareAnnotation.java | 3 --- 3 files changed, 3 insertions(+), 23 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java index 89b15376d79..a44e569a622 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java @@ -26,33 +26,23 @@ */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingTransitionProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; public class FloydHoareForInterpolantAutomaton implements IFloydHoareAnnotation { - private final INwaOutgoingTransitionProvider mInterpolantAutomaton; private final IPredicate mPrecondition; private final IPredicate mPostcondition; - public FloydHoareForInterpolantAutomaton(final INwaOutgoingTransitionProvider interpolantAutomaton, - final IPredicateUnifier unifier) { - this(interpolantAutomaton, unifier.getTruePredicate(), unifier.getFalsePredicate()); + public FloydHoareForInterpolantAutomaton(final IPredicateUnifier unifier) { + this(unifier.getTruePredicate(), unifier.getFalsePredicate()); } - public FloydHoareForInterpolantAutomaton(final INwaOutgoingTransitionProvider interpolantAutomaton, - final IPredicate precondition, final IPredicate postcondition) { - mInterpolantAutomaton = interpolantAutomaton; + public FloydHoareForInterpolantAutomaton(final IPredicate precondition, final IPredicate postcondition) { mPrecondition = precondition; mPostcondition = postcondition; } - @Override - public INwaOutgoingTransitionProvider getAnnotatedAutomaton() { - return mInterpolantAutomaton; - } - @Override public IPredicate getPrecondition() { return mPrecondition; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java index e04be315314..158e3602e31 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java @@ -34,7 +34,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; public class FloydHoareMapping implements IFloydHoareAnnotation { - private final INwaOutgoingTransitionProvider mAutomaton; private final IPredicate mPrecondition; private final IPredicate mPostcondition; private final Map mAnnotation; @@ -58,18 +57,12 @@ public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, f public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicate precondition, final IPredicate postcondition, final Map annotation, final IPredicate defaultPredicate) { - mAutomaton = automaton; mPrecondition = precondition; mPostcondition = postcondition; mAnnotation = annotation; mDefaultPredicate = defaultPredicate; } - @Override - public INwaOutgoingTransitionProvider getAnnotatedAutomaton() { - return mAutomaton; - } - @Override public IPredicate getPrecondition() { return mPrecondition; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java index 58d622af732..bdd6db1410e 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java @@ -26,13 +26,10 @@ */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingTransitionProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; public interface IFloydHoareAnnotation { - INwaOutgoingTransitionProvider getAnnotatedAutomaton(); - IPredicate getPrecondition(); IPredicate getPostcondition(); From 276e2b5d2cbd099f6dfb2542ec1565705ab48f64 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 19:26:38 +0100 Subject: [PATCH 17/91] rename method --- .../lib/tracecheckerutils/proofs/HoareAnnotationPositions.java | 2 +- .../plugins/generator/traceabstraction/CegarLoopFactory.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java index db24bf964b5..b654c804f1f 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java @@ -41,7 +41,7 @@ public enum HoareAnnotationPositions { All, LoopHeads, LoopsAndPotentialCycles, None; - public Set getLocationsForWhichHoareAnnotationIsComputed(final IIcfg root) { + public Set getLocations(final IIcfg root) { final Set hoareAnnotationLocs = new HashSet<>(); switch (this) { case All: diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 6900117be33..ff8809865cb 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -139,7 +139,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr final Set hoareAnnotationLocs; if (mComputeHoareAnnotation) { hoareAnnotationLocs = - mPrefs.getHoareAnnotationPositions().getLocationsForWhichHoareAnnotationIsComputed(root); + mPrefs.getHoareAnnotationPositions().getLocations(root); } else { hoareAnnotationLocs = Collections.emptySet(); } From d17f6f05548f3de13270b7f35fc0cdfb6993b169 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 30 Nov 2023 19:50:44 +0100 Subject: [PATCH 18/91] move code for Floyd-Hoare annotations to package in Library-TraceCheckerUtils --- .../META-INF/MANIFEST.MF | 1 + .../floydhoare}/HoareAnnotationComposer.java | 79 +++++++++++++++---- .../floydhoare}/HoareAnnotationExtractor.java | 30 +++---- .../floydhoare}/HoareAnnotationFragments.java | 19 ++--- .../HoareAnnotationPositions.java | 2 +- .../HoareAnnotationStatisticsDefinitions.java | 16 ++-- .../HoareAnnotationStatisticsGenerator.java | 33 ++++---- .../HoareAnnotationStatisticsType.java | 22 +++--- .../traceabstraction/AbstractCegarLoop.java | 2 +- .../HoareAnnotationWriter.java | 1 + .../traceabstraction/NwaCegarLoop.java | 3 + .../TraceAbstractionUtils.java | 55 +------------ .../preferences/TAPreferences.java | 2 +- ...TraceAbstractionPreferenceInitializer.java | 2 +- 14 files changed, 135 insertions(+), 132 deletions(-) rename trunk/source/{TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction => Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare}/HoareAnnotationComposer.java (77%) rename trunk/source/{TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction => Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare}/HoareAnnotationExtractor.java (87%) rename trunk/source/{TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction => Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare}/HoareAnnotationFragments.java (91%) rename trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/{proofs => floydhoare}/HoareAnnotationPositions.java (99%) rename trunk/source/{TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction => Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare}/HoareAnnotationStatisticsDefinitions.java (81%) rename trunk/source/{TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction => Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare}/HoareAnnotationStatisticsGenerator.java (80%) rename trunk/source/{TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction => Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare}/HoareAnnotationStatisticsType.java (63%) diff --git a/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF b/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF index 49641243192..60078302bf7 100644 --- a/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF +++ b/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF @@ -7,6 +7,7 @@ Bundle-RequiredExecutionEnvironment: JavaSE-11 Export-Package: de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton, + de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence, diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationComposer.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java similarity index 77% rename from trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationComposer.java rename to trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java index 5cf8c0f9dbe..67ad0587f3b 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationComposer.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java @@ -3,29 +3,29 @@ * Copyright (C) 2014-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2015 University of Freiburg * - * This file is part of the ULTIMATE TraceAbstraction plug-in. + * This file is part of the ULTIMATE TraceCheckerUtils Library. * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import java.util.ArrayList; import java.util.HashMap; @@ -37,15 +37,19 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramNonOldVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.BasicPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.BasicPredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.TermVarsProc; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.ExtendedSimplificationResult; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.Substitution; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.normalforms.NnfTransformer; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.normalforms.NnfTransformer.QuantifierHandling; import de.uni_freiburg.informatik.ultimate.logic.Term; @@ -88,7 +92,7 @@ public HoareAnnotationComposer(final CfgSmtToolkit csToolkit, final PredicateFac final HoareAnnotationFragments hoareAnnotationFragments, final IUltimateServiceProvider services, final SimplificationTechnique simplicationTechnique, final XnfConversionTechnique xnfConversionTechnique) { mServices = services; - mLogger = services.getLoggingService().getLogger(Activator.PLUGIN_ID); + mLogger = services.getLoggingService().getLogger(getClass()); mCsToolkit = csToolkit; mPredicateFactory = predicateFactory; mHoareAnnotationFragments = hoareAnnotationFragments; @@ -124,8 +128,8 @@ public HoareAnnotationComposer(final CfgSmtToolkit csToolkit, final PredicateFac postForCallpred = mHoareAnnotationFragments.getCallpred2Entry().get(entry.getKey()); } assert postForCallpred != null : "no post for callpred"; - final Term precond = TraceAbstractionUtils.renameGlobalsToOldGlobals(postForCallpred, mServices, - mCsToolkit.getManagedScript()); + final Term precond = + renameGlobalsToOldGlobals(postForCallpred, mServices, mCsToolkit.getManagedScript()); if (mLogger.isDebugEnabled()) { mLogger.debug("In " + loc + " holds " + entry.getValue() + " for precond " + precond); @@ -236,8 +240,8 @@ public HashRelation3 constructMappingOld() { throw new AssertionError("not implemented"); } precondForContext = mHoareAnnotationFragments.getCallpred2Entry().get(context); - precondForContext = TraceAbstractionUtils.renameGlobalsToOldGlobals(precondForContext, mServices, - mCsToolkit.getManagedScript(), mPredicateFactory, SimplificationTechnique.SIMPLIFY_DDA); + precondForContext = renameGlobalsToOldGlobals(precondForContext, mServices, mCsToolkit.getManagedScript(), + mPredicateFactory, SimplificationTechnique.SIMPLIFY_DDA); final HashRelation pp2preds = mHoareAnnotationFragments.getDeadContexts2ProgPoint2Preds().get(context); addHoareAnnotationForCallPred(loc2callpred2invariant, precondForContext, pp2preds); @@ -250,8 +254,8 @@ public HashRelation3 constructMappingOld() { throw new AssertionError("not implemented"); } precondForContext = mHoareAnnotationFragments.getCallpred2Entry().get(context); - precondForContext = TraceAbstractionUtils.renameGlobalsToOldGlobals(precondForContext, mServices, - mCsToolkit.getManagedScript(), mPredicateFactory, SimplificationTechnique.SIMPLIFY_DDA); + precondForContext = renameGlobalsToOldGlobals(precondForContext, mServices, mCsToolkit.getManagedScript(), + mPredicateFactory, SimplificationTechnique.SIMPLIFY_DDA); final HashRelation pp2preds = mHoareAnnotationFragments.getLiveContexts2ProgPoint2Preds().get(context); addHoareAnnotationForCallPred(loc2callpred2invariant, precondForContext, pp2preds); @@ -287,4 +291,49 @@ public Map getLoc2hoare() { return mLoc2hoare; } + /** + * Construct Predicate which represents the same Predicate as ps, but where all globalVars are renamed to + * oldGlobalVars. + * + * @param services + * @param mgdScript + * @param predicateFactory + * @param simplificationTechnique + */ + private static IPredicate renameGlobalsToOldGlobals(final IPredicate ps, final IUltimateServiceProvider services, + final ManagedScript mgdScript, final BasicPredicateFactory predicateFactory, + final SimplificationTechnique simplificationTechnique) { + if (predicateFactory.isDontCare(ps)) { + throw new UnsupportedOperationException("don't cat not expected"); + } + final Map substitutionMapping = new HashMap<>(); + for (final IProgramVar pv : ps.getVars()) { + if (pv instanceof IProgramNonOldVar) { + final IProgramVar oldVar = ((IProgramNonOldVar) pv).getOldVar(); + substitutionMapping.put(pv.getTermVariable(), oldVar.getTermVariable()); + } + } + Term renamedFormula = Substitution.apply(mgdScript, substitutionMapping, ps.getFormula()); + renamedFormula = SmtUtils.simplify(mgdScript, renamedFormula, services, simplificationTechnique); + final IPredicate result = predicateFactory.newPredicate(renamedFormula); + return result; + } + + /** + * Construct Term which represents the same set of states as ps, but where all globalVars are renamed to + * oldGlobalVars. + * + */ + private static Term renameGlobalsToOldGlobals(final IPredicate ps, final IUltimateServiceProvider services, + final ManagedScript mgdScript) { + final Map substitutionMapping = new HashMap<>(); + for (final IProgramVar pv : ps.getVars()) { + if (pv instanceof IProgramNonOldVar) { + final IProgramVar oldVar = ((IProgramNonOldVar) pv).getOldVar(); + substitutionMapping.put(pv.getTermVariable(), oldVar.getTermVariable()); + } + } + final Term result = Substitution.apply(mgdScript, substitutionMapping, ps.getFormula()); + return result; + } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationExtractor.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java similarity index 87% rename from trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationExtractor.java rename to trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java index ff3565f7aee..0d2d435c7fa 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationExtractor.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java @@ -2,30 +2,30 @@ * Copyright (C) 2014-2015 Daniel Dietsch (dietsch@informatik.uni-freiburg.de) * Copyright (C) 2011-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2015 University of Freiburg - * - * This file is part of the ULTIMATE TraceAbstraction plug-in. - * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. - * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . - * + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import java.util.ArrayList; import java.util.Collection; @@ -49,9 +49,9 @@ /** * Extract an interprocedural Hoare annotation from an abstraction. - * + * * @author heizmann@informatik.uni-freiburg.de - * + * */ public class HoareAnnotationExtractor> extends DoubleDeckerVisitor { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java similarity index 91% rename from trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java rename to trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java index 988b59b5769..52832548c82 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationFragments.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java @@ -3,29 +3,29 @@ * Copyright (C) 2012-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2015 University of Freiburg * - * This file is part of the ULTIMATE TraceAbstraction plug-in. + * This file is part of the ULTIMATE TraceCheckerUtils Library. * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import java.util.ArrayList; import java.util.Collections; @@ -141,7 +141,8 @@ private void update(final IUpdate update, for (final IPredicate newState : newStates) { if (mPred2ProgPoint.containsKey(newState)) { final IPredicate oldPP = mPred2ProgPoint.get(newState); - assert oldPP == pp : "State " + newState + " cannot represent both " + oldPP + " and " + pp + "!"; + assert oldPP == pp : "State " + newState + " cannot represent both " + oldPP + " and " + pp + + "!"; } else { mPred2ProgPoint.put(newState, pp); } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationPositions.java similarity index 99% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java rename to trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationPositions.java index b654c804f1f..2bdeba27e39 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/HoareAnnotationPositions.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationPositions.java @@ -24,7 +24,7 @@ * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import java.util.HashSet; import java.util.Map; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsDefinitions.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsDefinitions.java similarity index 81% rename from trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsDefinitions.java rename to trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsDefinitions.java index 985988f4d84..b82b9dfad49 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsDefinitions.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsDefinitions.java @@ -2,29 +2,29 @@ * Copyright (C) 2016 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2016 University of Freiburg * - * This file is part of the ULTIMATE TraceAbstraction plug-in. + * This file is part of the ULTIMATE TraceCheckerUtils Library. * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import java.util.function.Function; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsGenerator.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsGenerator.java similarity index 80% rename from trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsGenerator.java rename to trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsGenerator.java index acddd1a4e25..ae3299c5d76 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsGenerator.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsGenerator.java @@ -2,29 +2,29 @@ * Copyright (C) 2016 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2016 University of Freiburg * - * This file is part of the ULTIMATE TraceAbstraction plug-in. + * This file is part of the ULTIMATE TraceCheckerUtils Library. * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import java.util.Collection; @@ -32,18 +32,18 @@ import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsType; public class HoareAnnotationStatisticsGenerator implements IStatisticsDataProvider { - + private int mFormulaSimplifications; private long mFormulaSimplificationTreeSizeReduction; private long mHoareSimplificationTime; - + private int mFormulaSimplificationsInter; private long mFormulaSimplificationTreeSizeReductionInter; private long mHoareSimplificationTimeInter; - + private long mHoareAnnotationTime; private long mHoareAnnotationTreeSize; - + private int mLocationsWithAnnotation; private int mPreInvPairs; private int mNumberOfFragments; @@ -54,7 +54,8 @@ public HoareAnnotationStatisticsGenerator() { @Override public Object getValue(final String key) { - final HoareAnnotationStatisticsDefinitions keyEnum = Enum.valueOf(HoareAnnotationStatisticsDefinitions.class, key); + final HoareAnnotationStatisticsDefinitions keyEnum = + Enum.valueOf(HoareAnnotationStatisticsDefinitions.class, key); switch (keyEnum) { case FormulaSimplifications: return mFormulaSimplifications; @@ -104,7 +105,7 @@ public void reportReduction(final long reductionOfTreeSize) { public void reportSimplificationTime(final long simplificationTimeNano) { mHoareSimplificationTime += simplificationTimeNano; } - + public void reportSimplificationInter() { mFormulaSimplificationsInter++; } @@ -116,8 +117,6 @@ public void reportReductionInter(final long reductionOfTreeSize) { public void reportSimplificationTimeInter(final long simplificationTimeNano) { mHoareSimplificationTimeInter += simplificationTimeNano; } - - public void setLocationsWithHoareAnnotation(final int size) { if (mLocationsWithAnnotation != 0) { @@ -125,7 +124,7 @@ public void setLocationsWithHoareAnnotation(final int size) { } mLocationsWithAnnotation = size; } - + public void setPreInvPairs(final int size) { if (mPreInvPairs != 0) { throw new AssertionError("already set"); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsType.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsType.java similarity index 63% rename from trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsType.java rename to trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsType.java index 923cce2f02b..1df0c5a9bfc 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationStatisticsType.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsType.java @@ -2,42 +2,42 @@ * Copyright (C) 2016 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2016 University of Freiburg * - * This file is part of the ULTIMATE TraceAbstraction plug-in. + * This file is part of the ULTIMATE TraceCheckerUtils Library. * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import de.uni_freiburg.informatik.ultimate.util.statistics.StatisticsType; public class HoareAnnotationStatisticsType extends StatisticsType { - + public HoareAnnotationStatisticsType() { super(HoareAnnotationStatisticsDefinitions.class); } private static HoareAnnotationStatisticsType s_Instance = new HoareAnnotationStatisticsType(); - + public static HoareAnnotationStatisticsType getInstance() { return s_Instance; } - + } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index fb4de455eb9..552ab256a45 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -85,7 +85,7 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.HoareAnnotationPositions; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.logic.Script; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java index e23cf7f4909..9cd18078ebd 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java @@ -40,6 +40,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.UnknownState; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationComposer; /** * Write a Hoare annotation provided by HoareAnnotationFragments to the CFG. diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 44f11fceca5..328f2299fa3 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -87,6 +87,9 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SMTFeatureExtractionTermClassifier.ScoringMethod; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationComposer; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationExtractor; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationFragments; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java index c5637dc52d5..967c738968e 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionUtils.java @@ -43,7 +43,6 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.OutgoingReturnTransition; import de.uni_freiburg.informatik.ultimate.automata.util.PartitionBackedSetOfPairs; import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; -import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.ModifiableGlobalsTable; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.ICallAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IInternalAction; @@ -53,14 +52,11 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.HoareTripleCheckerCache; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.interpolant.TracePredicates; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.BasicPredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IMLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.Substitution; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.BoogieIcfgLocation; @@ -105,55 +101,8 @@ public static PartitionBackedSetOfPairs substitutionMapping = new HashMap<>(); - for (final IProgramVar pv : ps.getVars()) { - if (pv instanceof IProgramNonOldVar) { - final IProgramVar oldVar = ((IProgramNonOldVar) pv).getOldVar(); - substitutionMapping.put(pv.getTermVariable(), oldVar.getTermVariable()); - } - } - Term renamedFormula = Substitution.apply(mgdScript, substitutionMapping, ps.getFormula()); - renamedFormula = SmtUtils.simplify(mgdScript, renamedFormula, services, simplificationTechnique); - final IPredicate result = predicateFactory.newPredicate(renamedFormula); - return result; - } - - /** - * Construct Term which represents the same set of states as ps, but where all globalVars are renamed to - * oldGlobalVars. - * - */ - public static Term renameGlobalsToOldGlobals(final IPredicate ps, final IUltimateServiceProvider services, - final ManagedScript mgdScript) { - final Map substitutionMapping = new HashMap<>(); - for (final IProgramVar pv : ps.getVars()) { - if (pv instanceof IProgramNonOldVar) { - final IProgramVar oldVar = ((IProgramNonOldVar) pv).getOldVar(); - substitutionMapping.put(pv.getTermVariable(), oldVar.getTermVariable()); - } - } - final Term result = Substitution.apply(mgdScript, substitutionMapping, ps.getFormula()); - return result; - } - - /** - * For each oldVar in vars that is not modifiable by procedure proc: substitute - * the oldVar by the corresponding globalVar in term and remove the oldvar from - * vars. + * For each oldVar in vars that is not modifiable by procedure proc: substitute the oldVar by the corresponding + * globalVar in term and remove the oldvar from vars. */ public static Term substituteOldVarsOfNonModifiableGlobals(final String proc, final Set vars, final Term term, final ModifiableGlobalsTable modifiableGlobals, final ManagedScript mgdScript) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java index 902acc902f0..c5beadb4ab2 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java @@ -40,12 +40,12 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SMTFeatureExtractionTermClassifier.ScoringMethod; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.ExternalSolver; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.SolverMode; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderMode; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderReductionFacade.OrderType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.AbstractionType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.IndependenceType; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Logics; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.preferences.RcfgPreferenceInitializer; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java index 05a2cd76dcc..d6ac21e172a 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java @@ -51,12 +51,12 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SMTFeatureExtractionTermClassifier.ScoringMethod; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.ExternalSolver; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.SolverMode; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderMode; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderReductionFacade.OrderType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.AbstractionType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.IndependenceType; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.preferences.RcfgPreferenceInitializer; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.Activator; From 1604caeb0073f6d1d6c8a96dfcea7b077a123095 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 1 Dec 2023 11:29:17 +0100 Subject: [PATCH 19/91] IFloydHoareAnnotation: remove unused type parameter --- .../floydhoare/FloydHoareForInterpolantAutomaton.java | 3 +-- .../tracecheckerutils/floydhoare/FloydHoareMapping.java | 3 +-- .../floydhoare/IFloydHoareAnnotation.java | 3 +-- .../initialabstraction/NwaHoareProofProducer.java | 8 ++++---- .../initialabstraction/NwaInitialAbstractionProvider.java | 2 +- 5 files changed, 8 insertions(+), 11 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java index a44e569a622..be16a16390f 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java @@ -26,11 +26,10 @@ */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; -public class FloydHoareForInterpolantAutomaton implements IFloydHoareAnnotation { +public class FloydHoareForInterpolantAutomaton implements IFloydHoareAnnotation { private final IPredicate mPrecondition; private final IPredicate mPostcondition; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java index 158e3602e31..49ac707c60d 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java @@ -29,11 +29,10 @@ import java.util.Map; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingTransitionProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; -public class FloydHoareMapping implements IFloydHoareAnnotation { +public class FloydHoareMapping implements IFloydHoareAnnotation { private final IPredicate mPrecondition; private final IPredicate mPostcondition; private final Map mAnnotation; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java index bdd6db1410e..d171ca7793b 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java @@ -26,10 +26,9 @@ */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -public interface IFloydHoareAnnotation { +public interface IFloydHoareAnnotation { IPredicate getPrecondition(); IPredicate getPostcondition(); diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java index 0bc2a600c85..ea513dea106 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java @@ -47,10 +47,10 @@ final class NwaHoareProofProducer private final INestedWordAutomaton mProgram; // private final Set mHoareAnnotationStates; - private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; + private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; private NwaHoareProofProducer(final INestedWordAutomaton program, // final Set hoareAnnotationStates, - final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { + final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { mProgram = program; // mHoareAnnotationStates = hoareAnnotationStates; // mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates); @@ -60,7 +60,7 @@ private NwaHoareProofProducer(final INestedWordAutomaton program, // final } public static - NwaHoareProofProducer, IFloydHoareAnnotation> + NwaHoareProofProducer, IFloydHoareAnnotation> create(final INestedWordAutomaton program // , final Set hoareAnnotationStates ) { @@ -83,7 +83,7 @@ public boolean hasProof() { @Override public PROOF getOrComputeProof() { // TODO - final IFloydHoareAnnotation floydHoare = null; + final IFloydHoareAnnotation floydHoare = null; return mPost.processProof(floydHoare); } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index 7fa749fb5e9..06a679f71c0 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -93,7 +93,7 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg, IFloydHoareAnnotation, PROOF> converter = + final IProofConverter, IFloydHoareAnnotation, PROOF> converter = null; if (converter != null) { From 6f4c56bfdb1fe31d17f032a0ac31863668ae9ecb Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 1 Dec 2023 11:30:08 +0100 Subject: [PATCH 20/91] FloydHoareMapping: remove unused automaton --- .../floydhoare/FloydHoareMapping.java | 24 +++++++++---------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java index 49ac707c60d..dc99cf3bdf7 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java @@ -28,34 +28,32 @@ import java.util.Map; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingTransitionProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; -public class FloydHoareMapping implements IFloydHoareAnnotation { +public class FloydHoareMapping implements IFloydHoareAnnotation { private final IPredicate mPrecondition; private final IPredicate mPostcondition; private final Map mAnnotation; private final IPredicate mDefaultPredicate; - public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicateUnifier unifier, - final Map annotation) { - this(automaton, unifier, annotation, null); + public FloydHoareMapping(final IPredicateUnifier unifier, final Map annotation) { + this(unifier, annotation, null); } - public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicateUnifier unifier, - final Map annotation, final IPredicate defaultPredicate) { - this(automaton, unifier.getTruePredicate(), unifier.getFalsePredicate(), annotation, defaultPredicate); + public FloydHoareMapping(final IPredicateUnifier unifier, final Map annotation, + final IPredicate defaultPredicate) { + this(unifier.getTruePredicate(), unifier.getFalsePredicate(), annotation, defaultPredicate); } - public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicate precondition, - final IPredicate postcondition, final Map annotation) { - this(automaton, precondition, postcondition, annotation, null); + public FloydHoareMapping(final IPredicate precondition, final IPredicate postcondition, + final Map annotation) { + this(precondition, postcondition, annotation, null); } - public FloydHoareMapping(final INwaOutgoingTransitionProvider automaton, final IPredicate precondition, - final IPredicate postcondition, final Map annotation, final IPredicate defaultPredicate) { + public FloydHoareMapping(final IPredicate precondition, final IPredicate postcondition, + final Map annotation, final IPredicate defaultPredicate) { mPrecondition = precondition; mPostcondition = postcondition; mAnnotation = annotation; From f2110d5311aefff4ed5ec6dc5b9224d032defe71 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 1 Dec 2023 11:30:28 +0100 Subject: [PATCH 21/91] add Validity::and method --- .../IncrementalPlicationChecker.java | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/trunk/source/Library-SmtLibUtils/src/de/uni_freiburg/informatik/ultimate/lib/smtlibutils/IncrementalPlicationChecker.java b/trunk/source/Library-SmtLibUtils/src/de/uni_freiburg/informatik/ultimate/lib/smtlibutils/IncrementalPlicationChecker.java index cc8931d0770..30e5a0e6be2 100644 --- a/trunk/source/Library-SmtLibUtils/src/de/uni_freiburg/informatik/ultimate/lib/smtlibutils/IncrementalPlicationChecker.java +++ b/trunk/source/Library-SmtLibUtils/src/de/uni_freiburg/informatik/ultimate/lib/smtlibutils/IncrementalPlicationChecker.java @@ -49,7 +49,22 @@ public class IncrementalPlicationChecker { public enum Validity { - VALID, INVALID, UNKNOWN, NOT_CHECKED + VALID, INVALID, UNKNOWN, NOT_CHECKED; + + public Validity and(final Validity other) { + switch (this) { + case INVALID: + return INVALID; + case NOT_CHECKED: + return other == INVALID ? other : this; + case UNKNOWN: + return (other == NOT_CHECKED || other == INVALID) ? other : this; + case VALID: + return other; + default: + throw new AssertionError("unexpected validity " + this); + } + } } public static Validity convertLBool2Validity(final LBool lbool) { From eea7867eaa9964a7907ba1b37b2b51b8df6b5830 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 1 Dec 2023 16:35:06 +0100 Subject: [PATCH 22/91] add FloydHoareValidityCheck --- .../cegar/AbstractBuchiCegarLoop.java | 11 +- .../InvariantSynthesis/META-INF/MANIFEST.MF | 1 + .../InvariantSynthesisStarter.java | 4 +- .../floydhoare/FloydHoareValidityCheck.java | 286 ++++++++++++++++++ .../IcfgFloydHoareValidityCheck.java | 110 +++++++ .../NwaFloydHoareValidityCheck.java | 72 +++++ .../traceabstraction/AbstractCegarLoop.java | 7 +- .../traceabstraction/BasicCegarLoop.java | 28 +- .../CegarLoopSWBnonRecursive.java | 5 +- .../traceabstraction/EagerReuseCegarLoop.java | 7 +- .../IncrementalInclusionCegarLoop.java | 9 +- .../traceabstraction/LazyReuseCegarLoop.java | 7 +- .../TraceAbstractionStarter.java | 4 +- .../concurrency/CegarLoopForPetriNet.java | 5 +- .../predicates/HoareAnnotationChecker.java | 177 ----------- .../predicates/InductivityCheck.java | 159 ---------- .../CegarLoopConcurrentAutomata.java | 7 +- .../TAwAFAsCegarLoop.java | 7 +- 18 files changed, 514 insertions(+), 392 deletions(-) create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareValidityCheck.java create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java delete mode 100644 trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/HoareAnnotationChecker.java delete mode 100644 trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java diff --git a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java index d5366c70345..2ba543e6d65 100644 --- a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java +++ b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java @@ -81,6 +81,7 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.CoverageAnalysis.BackwardCoveringInformation; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.NwaFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheckCraig; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; @@ -110,7 +111,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.PredicateFactoryForInterpolantAutomata; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.NondeterministicInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.InterpolationPreferenceChecker; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer; @@ -488,8 +488,9 @@ private A refineFiniteInternal(final A abstraction, final LassoCheck lassoChe mTermcompProofBenchmark.reportFiniteModule(mIteration, interpolAutomaton); } mMDBenchmark.reportTrivialModule(mIteration, interpolAutomaton.size()); - assert new InductivityCheck<>(mServices, interpolAutomaton, false, true, - new IncrementalHoareTripleChecker(mCsToolkitWithRankVars, false)).getResult(); + assert NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, mCsToolkitWithRankVars.getManagedScript(), + new IncrementalHoareTripleChecker(mCsToolkitWithRankVars, false), traceCheck.getPredicateUnifier(), + interpolAutomaton, true).getResult(); mBenchmarkGenerator.addEdgeCheckerData(htc.getStatistics()); mBenchmarkGenerator.stop(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); return result; @@ -573,7 +574,9 @@ private A refineBuchiInternal(final LassoCheck lassoCheck) throws AutomataOpe HoareTripleChecks.INCREMENTAL, mCsToolkitWithRankVars, pu); final BuchiHoareTripleChecker bhtc = new BuchiHoareTripleChecker(ehtc); bhtc.putDecreaseEqualPair(hondaPredicate, rankEqAndSi); - assert new InductivityCheck<>(mServices, inputAutomaton, false, true, bhtc).getResult(); + assert NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, + mCsToolkitWithRankVars.getManagedScript(), bhtc, pu, inputAutomaton, true).getResult(); + assert new BuchiAccepts<>(new AutomataLibraryServices(mServices), inputAutomaton, mCounterexample.getNestedLassoWord()).getResult(); diff --git a/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF b/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF index eebe6ccf1e7..523cce2ae42 100644 --- a/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF +++ b/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF @@ -11,6 +11,7 @@ Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.lib.boogieast, de.uni_freiburg.informatik.ultimate.core, de.uni_freiburg.informatik.ultimate.lib.automata, + de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils, de.uni_freiburg.informatik.ultimate.smtinterpol, de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder, de.uni_freiburg.informatik.ultimate.smtsolver.external, diff --git a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java index f77ace9224a..f34340bc606 100644 --- a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java +++ b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java @@ -76,6 +76,7 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.ExternalSolver; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.SolverMode; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.SolverSettings; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.invariantsynthesis.preferences.InvariantSynthesisPreferenceInitializer; import de.uni_freiburg.informatik.ultimate.plugins.generator.invariantsynthesis.preferences.InvariantSynthesisPreferenceInitializer.IncreasingStrategy; @@ -92,7 +93,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.pathinvariants.internal.ExponentialConjunctsTemplateIncreasingDimensionsStrategy; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.pathinvariants.internal.KindOfInvariant; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.pathinvariants.internal.MediumTemplateIncreasingDimensionsStrategy; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.HoareAnnotationChecker; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.StatisticsData; @@ -315,7 +315,7 @@ private InvariantSynthesisSettings constructSettings(final String cfgIdentifier) private void createInvariantResults(final IIcfg icfg, final CfgSmtToolkit csToolkit, final IBacktranslationService backTranslatorService) { - assert new HoareAnnotationChecker(mServices, icfg, csToolkit).isInductive() : "incorrect Hoare annotation"; + assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, true).getResult() : "incorrect Hoare annotation"; final Term trueterm = csToolkit.getManagedScript().getScript().term("true"); diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareValidityCheck.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareValidityCheck.java new file mode 100644 index 00000000000..4af18dfa48c --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareValidityCheck.java @@ -0,0 +1,286 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; + +import java.util.ArrayDeque; +import java.util.HashSet; +import java.util.Set; + +import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; +import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.ICallAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IInternalAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IReturnAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.MonolithicImplicationChecker; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Triple; + +/** + * Performs validity checks of {@link IFloydHoareAnnotation}s. + * + * This is an abstract base class which must be specialized depending on what is annotated, e.g. for nested word + * automata (see {@link NwaFloydHoareValidityCheck}) or interprocedural control flow graphs (see + * {@link IcfgFloydHoareValidityCheck}). + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + * @param + * The type of states which are annotated + */ +public abstract class FloydHoareValidityCheck { + protected final ILogger mLogger; + private final MonolithicImplicationChecker mImplChecker; + private final IHoareTripleChecker mHoareTripleChecker; + + private final IFloydHoareAnnotation mAnnotation; + + private final boolean mAssertValidity; + private final MissingAnnotationBehaviour mMissingAnnotations; + private final boolean mCheckSafety; + + private int mProven; + private int mRefuted; + private int mUnknown; + private int mMissing; + + private final ArrayDeque mWorklist = new ArrayDeque<>(); + private final Set mVisited = new HashSet<>(); + + private Validity mIsInitial; + private Validity mIsInductive; + private Validity mIsSafe = Validity.VALID; + + /** + * Specifies how to proceed for states that do not have an annotation. + */ + public enum MissingAnnotationBehaviour { + IGNORE, THROW, UNKNOWN + } + + private interface ISimpleHoareCheck { + Validity check(IPredicate pre, A action, IPredicate post); + } + + protected FloydHoareValidityCheck(final IUltimateServiceProvider services, final ManagedScript mgdScript, + final IHoareTripleChecker hoareTripleChecker, final IFloydHoareAnnotation annotation, + final boolean assertValidity, final MissingAnnotationBehaviour missingAnnotations, + final boolean checkSafety) { + mLogger = services.getLoggingService().getLogger(FloydHoareValidityCheck.class); + mImplChecker = new MonolithicImplicationChecker(services, mgdScript); + mHoareTripleChecker = hoareTripleChecker; + + mAnnotation = annotation; + + mAssertValidity = assertValidity; + mMissingAnnotations = missingAnnotations; + mCheckSafety = checkSafety; + if (!mCheckSafety) { + mIsSafe = Validity.NOT_CHECKED; + } + } + + protected final void performCheck() { + mIsInitial = checkInitial(); + mIsInductive = checkInductivity(); + // NOTE: checkInductivity() also determines mIsSafe + } + + public Validity isInitial() { + return mIsInitial; + } + + public Validity isInductive() { + return mIsInductive; + } + + public Validity isSafe() { + return mIsSafe; + } + + public Validity isValid() { + if (mCheckSafety) { + return mIsInitial.and(mIsInductive).and(mIsSafe); + } + return mIsInitial.and(mIsInductive); + } + + public boolean getResult() { + return isValid() != Validity.INVALID; + } + + protected abstract Iterable getInitialStates(); + + protected abstract boolean isPostState(S state); + + protected abstract Iterable> getInternalSuccessors(S state); + + protected abstract Iterable> getCallSuccessors(S state); + + protected abstract Iterable> getReturnSuccessors(S state); + + private Validity checkInitial() { + Validity result = Validity.VALID; + for (final var initial : getInitialStates()) { + // check initial states are labeled with precondition (or weaker) + final IPredicate pred = getAnnotation(initial); + if (pred != null) { + final var check = mImplChecker.checkImplication(mAnnotation.getPrecondition(), false, pred, false); + assert !mAssertValidity || check != Validity.INVALID : "initial condition violated"; + result = result.and(check); + } + + // initialize data structures for DFS performed by inductivity check + mWorklist.add(initial); + mVisited.add(initial); + } + + return result; + } + + private Validity checkInductivity() { + Validity result = Validity.VALID; + while (!mWorklist.isEmpty()) { + final S state = mWorklist.pop(); + final IPredicate pre = getAnnotation(state); + checkSafe(state, pre); + + for (final var outTrans : getInternalSuccessors(state)) { + final Validity inductivity = checkInductivity(state, pre, outTrans, mHoareTripleChecker::checkInternal); + result = result.and(inductivity); + } + for (final var outTrans : getCallSuccessors(state)) { + final Validity inductivity = checkInductivity(state, pre, outTrans, mHoareTripleChecker::checkCall); + result = result.and(inductivity); + } + for (final var outTrans : getReturnSuccessors(state)) { + final Validity inductivity = checkReturnInductivity(state, pre, outTrans); + result = result.and(inductivity); + } + } + if (mHoareTripleChecker instanceof IncrementalHoareTripleChecker) { + ((IncrementalHoareTripleChecker) mHoareTripleChecker).clearAssertionStack(); + } + mLogger.info( + "Floyd-Hoare annotation has %d edges. %d inductive. %d not inductive. " + + "%d times theorem prover too weak to decide inductivity. %d times interpolants missing.", + mProven + mRefuted + mUnknown + mMissing, mProven, mRefuted, mUnknown, mMissing); + return result; + } + + private Validity checkInductivity(final S state, final IPredicate pre, + final Pair transition, final ISimpleHoareCheck checker) { + final var succ = transition.getSecond(); + if (mVisited.add(succ)) { + mWorklist.push(succ); + } + + final IPredicate post = getAnnotation(succ); + if (pre == null || post == null) { + mMissing++; + return mMissingAnnotations == MissingAnnotationBehaviour.IGNORE ? Validity.VALID : Validity.UNKNOWN; + } + + final Validity inductivity = checker.check(pre, transition.getFirst(), post); + evaluateInductivityResult(inductivity, state, transition.getFirst(), succ, null); + return inductivity; + } + + private Validity checkReturnInductivity(final S state, final IPredicate pre, + final Triple transition) { + final var succ = transition.getSecond(); + if (mVisited.add(succ)) { + mWorklist.push(succ); + } + + final IPredicate post = getAnnotation(succ); + final IPredicate hier = getAnnotation(transition.getThird()); + if (pre == null || post == null || hier == null) { + mMissing++; + return mMissingAnnotations == MissingAnnotationBehaviour.IGNORE ? Validity.VALID : Validity.UNKNOWN; + } + + final Validity inductivity = mHoareTripleChecker.checkReturn(pre, hier, transition.getFirst(), post); + evaluateInductivityResult(inductivity, state, transition.getFirst(), succ, transition.getThird()); + return inductivity; + } + + private void evaluateInductivityResult(final Validity inductivity, final S state, final IAction trans, final S succ, + final S hier) { + switch (inductivity) { + case VALID: + mProven++; + break; + case INVALID: + mRefuted++; + final String hierString = hier == null ? "" : (" (hier: " + hier + ")"); + mLogger.warn("Transition %s %s %s%s not inductive", state, trans, succ, hierString); + assert !mAssertValidity : "inductivity violated"; + break; + case UNKNOWN: + mUnknown++; + break; + default: + throw new IllegalArgumentException("unexpected validity: " + inductivity); + } + } + + private void checkSafe(final S state, final IPredicate pred) { + if (!mCheckSafety) { + return; + } + + if (pred == null && mMissingAnnotations == MissingAnnotationBehaviour.UNKNOWN) { + mIsSafe = mIsSafe.and(Validity.UNKNOWN); + return; + } + + if (pred == null || !isPostState(state)) { + return; + } + + final var check = mImplChecker.checkImplication(pred, false, mAnnotation.getPostcondition(), false); + assert !mAssertValidity || check != Validity.INVALID : "safety condition violated"; + mIsSafe = mIsSafe.and(check); + } + + private IPredicate getAnnotation(final S state) { + final var predicate = mAnnotation.getAnnotation(state); + if (predicate == null) { + mLogger.warn("%s has no Hoare annotation", state); + if (mMissingAnnotations == MissingAnnotationBehaviour.THROW) { + throw new IllegalArgumentException(state + " has no Hoare annotation"); + } + } + return predicate; + } +} diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java new file mode 100644 index 00000000000..501f57f5125 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java @@ -0,0 +1,110 @@ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; + +import java.util.Set; +import java.util.stream.Collectors; + +import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.ICallAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgReturnTransition; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IInternalAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IReturnAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.MonolithicHoareTripleChecker; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Triple; + +public class IcfgFloydHoareValidityCheck extends FloydHoareValidityCheck { + private final IIcfg mIcfg; + private final Set mErrorLocs; + + public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final IIcfg icfg, + final boolean assertValidity) { + this(services, icfg, new IcfgHoareAnnotation<>(), assertValidity, MissingAnnotationBehaviour.IGNORE, false); + } + + public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final IIcfg icfg, + final IFloydHoareAnnotation annotation, final boolean assertValidity, + final MissingAnnotationBehaviour missingAnnotations, final boolean checkSafety) { + this(services, new MonolithicHoareTripleChecker(icfg.getCfgSmtToolkit()), icfg, annotation, assertValidity, + missingAnnotations, checkSafety); + } + + public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, + final IHoareTripleChecker hoareTripleChecker, final IIcfg icfg, + final IFloydHoareAnnotation annotation, final boolean assertValidity, + final MissingAnnotationBehaviour missingAnnotations, final boolean checkSafety) { + this(services, icfg.getCfgSmtToolkit().getManagedScript(), hoareTripleChecker, icfg, annotation, assertValidity, + missingAnnotations, checkSafety); + } + + public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final ManagedScript mgdScript, + final IHoareTripleChecker hoareTripleChecker, final IIcfg icfg, + final IFloydHoareAnnotation annotation, final boolean assertValidity, + final MissingAnnotationBehaviour missingAnnotations, final boolean checkSafety) { + super(services, mgdScript, hoareTripleChecker, annotation, assertValidity, missingAnnotations, checkSafety); + mIcfg = icfg; + mErrorLocs = icfg.getProcedureErrorNodes().values().stream().flatMap(Set::stream).collect(Collectors.toSet()); + + if (icfg.getInitialNodes().isEmpty()) { + mLogger.warn("There was no procedure with an implementation"); + } + + performCheck(); + } + + @Override + protected Iterable getInitialStates() { + return mIcfg.getInitialNodes(); + } + + @Override + protected boolean isPostState(final LOC state) { + return mErrorLocs.contains(state); + } + + @Override + protected Iterable> getInternalSuccessors(final LOC state) { + return getSuccessors(state, IInternalAction.class); + } + + @Override + protected Iterable> getCallSuccessors(final LOC state) { + return getSuccessors(state, ICallAction.class); + } + + @Override + protected Iterable> getReturnSuccessors(final LOC state) { + return state.getIncomingEdges().stream().filter(IIcfgReturnTransition.class::isInstance) + .map(e -> new Triple<>((IReturnAction) e, (LOC) e.getTarget(), + ((IIcfgReturnTransition) e).getCallerProgramPoint())) + .collect(Collectors.toList()); + } + + private Iterable> getSuccessors(final LOC state, final Class clazz) { + return state.getIncomingEdges().stream().filter(clazz::isInstance) + .map(e -> new Pair<>(clazz.cast(e), (LOC) e.getTarget())).collect(Collectors.toList()); + } + + private static final class IcfgHoareAnnotation implements IFloydHoareAnnotation { + @Override + public IPredicate getPrecondition() { + return null; + } + + @Override + public IPredicate getPostcondition() { + return null; + } + + @Override + public IPredicate getAnnotation(final LOC state) { + return HoareAnnotation.getAnnotation(state); + } + } +} \ No newline at end of file diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java new file mode 100644 index 00000000000..b2853b1a2f8 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java @@ -0,0 +1,72 @@ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.IOutgoingTransitionlet; +import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.ICallAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IInternalAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IReturnAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.TransformIterator; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Triple; + +public class NwaFloydHoareValidityCheck extends FloydHoareValidityCheck { + private final INestedWordAutomaton mAutomaton; + + public NwaFloydHoareValidityCheck(final IUltimateServiceProvider services, final ManagedScript mgdScript, + final IHoareTripleChecker hoareTripleChecker, final INestedWordAutomaton automaton, + final IFloydHoareAnnotation annotation, final boolean assertValidity, + final MissingAnnotationBehaviour missingAnnotations, final boolean checkSafety) { + super(services, mgdScript, hoareTripleChecker, annotation, assertValidity, missingAnnotations, checkSafety); + mAutomaton = automaton; + + mLogger.info("Starting Floyd-Hoare check of an automaton with " + automaton.sizeInformation()); + performCheck(); + } + + public static NwaFloydHoareValidityCheck forInterpolantAutomaton( + final IUltimateServiceProvider services, final ManagedScript mgdScript, + final IHoareTripleChecker hoareTripleChecker, final IPredicateUnifier unifier, + final INestedWordAutomaton automaton, final boolean assertValidity) { + return new NwaFloydHoareValidityCheck<>(services, mgdScript, hoareTripleChecker, automaton, + new FloydHoareForInterpolantAutomaton(unifier), assertValidity, MissingAnnotationBehaviour.THROW, true); + } + + @Override + protected Iterable getInitialStates() { + return mAutomaton.getInitialStates(); + } + + @Override + protected boolean isPostState(final S state) { + return mAutomaton.isFinal(state); + } + + @Override + protected Iterable> getInternalSuccessors(final S state) { + return successors(mAutomaton.internalSuccessors(state), IInternalAction.class); + } + + @Override + protected Iterable> getCallSuccessors(final S state) { + return successors(mAutomaton.callSuccessors(state), ICallAction.class); + } + + @Override + protected Iterable> getReturnSuccessors(final S state) { + final var retSuccs = mAutomaton.returnSuccessors(state); + return () -> new TransformIterator<>(retSuccs.iterator(), + t -> new Triple<>((IReturnAction) t.getLetter(), t.getSucc(), t.getHierPred())); + } + + private Iterable> successors(final Iterable> successors, + final Class clazz) { + return () -> new TransformIterator<>(successors.iterator(), + t -> new Pair<>(clazz.cast(t.getLetter()), t.getSucc())); + } +} \ No newline at end of file diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 552ab256a45..7afcaed9225 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -86,11 +86,11 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.NwaFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.logic.Script; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences.Artifact; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.FloydHoareAutomataReuse; @@ -498,8 +498,9 @@ private void refineAbstractionInternal(final AutomatonType automatonType) // TODO #proofRefactor if (mComputeHoareAnnotation && mPref.getHoareAnnotationPositions() == HoareAnnotationPositions.All) { - assert new InductivityCheck<>(getServices(), (INestedWordAutomaton) mAbstraction, false, - true, new IncrementalHoareTripleChecker(mCsToolkit, false)).getResult() : "Not inductive"; + assert NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, mCsToolkit.getManagedScript(), + new IncrementalHoareTripleChecker(mCsToolkit, false), null, + (INestedWordAutomaton) mAbstraction, true).getResult() : "Not inductive"; } if (mIteration <= mPref.watchIteration() && mPref.artifact() == Artifact.ABSTRACTION) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index 5e4055a2923..95b1eb073a7 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -95,6 +95,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult.BasicRefinementEngineResult; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.NwaFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheckUtils; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; @@ -106,7 +107,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.NondeterministicInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences.Artifact; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences.InterpolantAutomatonEnhancement; @@ -403,9 +403,7 @@ protected void constructInterpolantAutomaton() throws AutomataOperationCanceledE assert isInterpolantAutomatonOfSingleStateType(mInterpolAutomaton); if (NON_EA_INDUCTIVITY_CHECK) { - final boolean inductive = new InductivityCheck<>(getServices(), mInterpolAutomaton, false, true, - new IncrementalHoareTripleChecker(super.mCsToolkit, false)).getResult(); - + final boolean inductive = checkInterpolantAutomatonInductivity(mInterpolAutomaton); if (!inductive) { throw new AssertionError("not inductive"); } @@ -415,12 +413,11 @@ assert accepts(getServices(), mInterpolAutomaton, mCounterexample.getWord(), false) : "Interpolant automaton broken!: " + mCounterexample.getWord() + " not accepted"; // FIXME (Dominik 2020-12-19): The assertion below is problematic, because it has side-effects! - // In particular, InductivityCheck calls IncrementalHoareTripleChecker, which in the method unAssertCodeBlock - // unlocks a ManagedScript. If assertions are disabled, this remains locked. This leads to exceptions if other - // callers try to lock it. With assertions enabled, the line below causes the ManagedScript to be unlocked and - // no exceptions occur. - assert new InductivityCheck<>(getServices(), mInterpolAutomaton, false, true, - new IncrementalHoareTripleChecker(super.mCsToolkit, false)).getResult(); + // In particular, NwaFloydHoareValidityCheck calls IncrementalHoareTripleChecker, which in the method + // unAssertCodeBlock unlocks a ManagedScript. If assertions are disabled, this remains locked. This leads to + // exceptions if other callers try to lock it. With assertions enabled, the line below causes the ManagedScript + // to be unlocked and no exceptions occur. + assert checkInterpolantAutomatonInductivity(mInterpolAutomaton); } protected static boolean @@ -574,9 +571,8 @@ protected void checkEnhancement( } assert isInterpolantAutomatonOfSingleStateType( new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), interpolantAutomaton).getResult()); - assert new InductivityCheck<>(getServices(), - new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), interpolantAutomaton).getResult(), - false, true, new IncrementalHoareTripleChecker(super.mCsToolkit, false)).getResult(); + assert checkInterpolantAutomatonInductivity( + new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), interpolantAutomaton).getResult()); } private void debugLogBrokenInterpolantAutomaton( @@ -687,6 +683,12 @@ public Set, IPredicateUnifier>> getFloydHoa throw new IllegalStateException("Floyd-Hoare automata have not been stored"); } + protected boolean checkInterpolantAutomatonInductivity(final INestedWordAutomaton automaton) { + return NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, mCsToolkit.getManagedScript(), + new IncrementalHoareTripleChecker(mCsToolkit, false), mRefinementResult.getPredicateUnifier(), + automaton, true).getResult(); + } + public IPreconditionProvider getPreconditionProvider() { return IPreconditionProvider.constructDefaultPreconditionProvider(); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 4c4c2414791..ebf404c6be1 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -59,7 +59,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; @@ -70,7 +69,6 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheck; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.Minimization; @@ -332,8 +330,7 @@ protected void constructInterpolantAutomaton() throws AutomataOperationCanceledE mLogger.debug("Epimorphism:"); mEpimorphism.print(); - assert new InductivityCheck<>(getServices(), mInterpolAutomaton, false, true, - new IncrementalHoareTripleChecker(mCsToolkit, false)).getResult() : "Not inductive"; + assert checkInterpolantAutomatonInductivity(mInterpolAutomaton) : "Not inductive"; mnofStates.add(mAbstraction.size()); int ii = 0; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index 89c64c705ad..5fff247a096 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -45,7 +45,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; @@ -53,7 +52,6 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; @@ -149,9 +147,8 @@ private void computeDifferenceForReuseAutomaton(final int iteration, } // Check if all edges of the Floyd-Hoare automaton are indeed inductive. - assert new InductivityCheck<>(getServices(), - new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), reuseAut).getResult(), false, true, - new IncrementalHoareTripleChecker(super.mCsToolkit, false)).getResult(); + assert checkInterpolantAutomatonInductivity( + new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), reuseAut).getResult()); if (mPref.dumpAutomata()) { final String filename = "DiffAfterEagerReuse" + oneBasedi; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index 02fadc606bf..a461853e9f3 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -62,7 +62,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.HoareTripleCheckerUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.HoareTripleCheckerUtils.HoareTripleChecks; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; @@ -72,7 +71,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.NondeterministicInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences.InterpolantAutomatonEnhancement; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.LanguageOperation; @@ -248,8 +246,8 @@ protected boolean refineAbstraction() throws AutomataLibraryException { switchAllInterpolantAutomataToReadOnlyMode(); final INestedWordAutomaton test = new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), determinized).getResult(); - assert new InductivityCheck<>(getServices(), test, false, true, - new IncrementalHoareTripleChecker(mIcfg.getCfgSmtToolkit(), false)).getResult(); + assert checkInterpolantAutomatonInductivity(test); + progress = true; break; } @@ -270,8 +268,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { switchAllInterpolantAutomataToReadOnlyMode(); final INestedWordAutomaton test = new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), nondet).getResult(); - assert new InductivityCheck<>(getServices(), test, false, true, - new IncrementalHoareTripleChecker(mIcfg.getCfgSmtToolkit(), false)).getResult(); + assert checkInterpolantAutomatonInductivity(test); progress = true; break; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index 5e1ad33503c..12360955a5f 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -49,7 +49,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; @@ -59,7 +58,6 @@ import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; @@ -185,9 +183,8 @@ protected boolean refineAbstraction() throws AutomataLibraryException { } // Check if all edges of the Floyd-Hoare automaton are indeed inductive. - assert new InductivityCheck<>(getServices(), - new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), reuseAut).getResult(), false, - true, new IncrementalHoareTripleChecker(super.mCsToolkit, false)).getResult(); + assert checkInterpolantAutomatonInductivity( + new RemoveUnreachable<>(new AutomataLibraryServices(getServices()), reuseAut).getResult()); dumpOrAppendAutomatonForReuseIfEnabled(reuseAut, reuseAutPair.getSecond()); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java index 9f6dfa2e929..416ac50227c 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java @@ -73,13 +73,13 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.transformations.BlockEncodingBacktranslator; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.abstraction.ICopyActionFactory; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.PetriNetLargeBlockEncoding.IPLBECompositionFactory; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.BoogieIcfgLocation; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.AbstractCegarLoop.Result; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.HoareAnnotationChecker; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.FloydHoareAutomataReuse; @@ -429,7 +429,7 @@ private CegarLoopResult executeCegarLoop(final IUltimateServiceProvider servi private void createInvariantResults(final IIcfg icfg, final IBacktranslationService backTranslatorService) { final CfgSmtToolkit csToolkit = icfg.getCfgSmtToolkit(); - assert new HoareAnnotationChecker(mServices, icfg, csToolkit).isInductive() : "incorrect Hoare annotation"; + assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, true).getResult() : "incorrect Hoare annotation"; final Term trueterm = csToolkit.getManagedScript().getScript().term("true"); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index f9fb2b1af78..2aedb1df18a 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -75,7 +75,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateCoverageChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; @@ -89,7 +88,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.PredicateFactoryRefinement; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimizationStatisticsGenerator; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences.Artifact; import de.uni_freiburg.informatik.ultimate.util.HistogramOfIterable; @@ -524,8 +522,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // TODO #proofRefactor if (mComputeHoareAnnotation) { - assert new InductivityCheck<>(getServices(), dia, false, true, - new IncrementalHoareTripleChecker(super.mCsToolkit, false)).getResult() : "Not inductive"; + assert checkInterpolantAutomatonInductivity(dia) : "Not inductive"; } if (mPref.dumpAutomata()) { final String filename = "InterpolantAutomatonDeterminized_Iteration" + mIteration; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/HoareAnnotationChecker.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/HoareAnnotationChecker.java deleted file mode 100644 index b087ca45de2..00000000000 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/HoareAnnotationChecker.java +++ /dev/null @@ -1,177 +0,0 @@ -/* - * Copyright (C) 2012-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) - * Copyright (C) 2015 University of Freiburg - * - * This file is part of the ULTIMATE TraceAbstraction plug-in. - * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission - * to convey the resulting work. - */ - -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates; - -import java.util.ArrayDeque; -import java.util.ArrayList; -import java.util.Deque; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; -import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.ICallAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgInternalTransition; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgReturnTransition; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IInternalAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IReturnAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgEdge; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.MonolithicHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; -import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.Summary; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.Activator; - -/** - * Check inductivity of a CFG's Hoare annotation. - * - * @author Matthias Heizmann (heizmann@informatik.uni-freiburg.de) - * - */ -public class HoareAnnotationChecker { - - private final IUltimateServiceProvider mServices; - private final ILogger mLogger; - private final IHoareTripleChecker mHoareTripleChecker; - private final IIcfg mRootNode; - private final boolean mIsInductive; - - public HoareAnnotationChecker(final IUltimateServiceProvider services, final IIcfg rootNode, - final CfgSmtToolkit csToolkit) { - super(); - mServices = services; - mLogger = mServices.getLoggingService().getLogger(Activator.PLUGIN_ID); - mRootNode = rootNode; - mHoareTripleChecker = new MonolithicHoareTripleChecker(csToolkit); - mIsInductive = cfgInductive(mRootNode); - } - - private boolean cfgInductive(final IIcfg rootNode) { - boolean result = true; - // yield[0] is the number of edges whose inductiveness could be - // proven - // yield[1] is the number of edges whose inductiveness could be - // refuted - // yield[2] is the number of edges whose inductiveness could be - // neither proven nor refuted because theorem prover too weak - // yield[3] is the number of edges whose inductiveness could be - // neither proven nor refuted because there were no interpolants - final int[] yield = new int[4]; - - final List initialNodes = new ArrayList<>(rootNode.getProcedureEntryNodes().values()); - final Set visited = new HashSet<>(); - final Deque worklist = new ArrayDeque<>(); - - if (initialNodes.isEmpty()) { - mLogger.warn("There was no procedure with an implementation"); - } - - for (final IcfgLocation initialNode : initialNodes) { - visited.add(initialNode); - worklist.add(initialNode); - } - - while (!worklist.isEmpty()) { - final IcfgLocation sourceLoc = worklist.removeFirst(); - for (final IcfgEdge outEdge : sourceLoc.getOutgoingEdges()) { - final IcfgLocation targetLoc = outEdge.getTarget(); - if (visited.add(targetLoc)) { - worklist.add(targetLoc); - } - - final IPredicate pre = HoareAnnotation.getAnnotation(sourceLoc); - if (pre == null) { - warnNoAnnotation(sourceLoc); - continue; - } - - final IPredicate post = HoareAnnotation.getAnnotation(targetLoc); - if (post == null) { - warnNoAnnotation(targetLoc); - continue; - } - - final Validity inductivity; - if (outEdge instanceof IIcfgInternalTransition) { - if (outEdge instanceof Summary && ((Summary) outEdge).calledProcedureHasImplementation()) { - continue; - } - inductivity = mHoareTripleChecker.checkInternal(pre, (IInternalAction) outEdge, post); - } else if (outEdge instanceof ICallAction) { - inductivity = mHoareTripleChecker.checkCall(pre, (ICallAction) outEdge, post); - } else if (outEdge instanceof IIcfgReturnTransition) { - final IcfgLocation callerNode = ((IIcfgReturnTransition) outEdge).getCallerProgramPoint(); - final IPredicate hierPre = HoareAnnotation.getAnnotation(callerNode); - if (hierPre == null) { - warnNoAnnotation(callerNode); - continue; - } - inductivity = mHoareTripleChecker.checkReturn(pre, hierPre, (IReturnAction) outEdge, post); - } else { - continue; - } - - switch (inductivity) { - case VALID: - yield[0]++; - break; - case INVALID: - yield[1]++; - mLogger.warn( - "Transition " + outEdge + " from " + pre + " to " + post + " not inductive"); - result = false; - break; - case UNKNOWN: - yield[2]++; - break; - default: - throw new IllegalArgumentException(); - } - } - } - mLogger.info("CFG has " + (yield[0] + yield[1] + yield[2] + yield[3]) + " edges. " + yield[0] + " inductive. " - + yield[1] + " not inductive. " + yield[2] + " times theorem prover too" - + " weak to decide inductivity. " + yield[3] + " times interpolants" + " missing."); - return result; - } - - private void warnNoAnnotation(final IcfgLocation sourceLoc) { - mLogger.warn(sourceLoc + " has no Hoare annotation"); - } - - public boolean isInductive() { - return mIsInductive; - } - -} diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java deleted file mode 100644 index e194c494078..00000000000 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/predicates/InductivityCheck.java +++ /dev/null @@ -1,159 +0,0 @@ -/* - * Copyright (C) 2014-2015 Daniel Dietsch (dietsch@informatik.uni-freiburg.de) - * Copyright (C) 2013-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) - * Copyright (C) 2015 University of Freiburg - * - * This file is part of the ULTIMATE TraceAbstraction plug-in. - * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission - * to convey the resulting work. - */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates; - -import de.uni_freiburg.informatik.ultimate.automata.LibraryIdentifiers; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.OutgoingCallTransition; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.OutgoingInternalTransition; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.OutgoingReturnTransition; -import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; -import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.ICallAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IInternalAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IReturnAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; - -/** - * Check if each edge of automaton is inductive (resp. if inductivity can be refuted if antiInductivity is set). - * - * @param antiInductivity - * if false, we check if each edge is inductive, if true we check if inductivity of each edge can be refuted. - * @param assertInductivity - * if true, assert statements require inductivity (resp. anti-inductivity) - */ -// TODO #proofRefactor : Make full-blown validity checker for IFloydHoareAnnotation -public class InductivityCheck { - - private final IUltimateServiceProvider mServices; - private final ILogger mLogger; - - private final IHoareTripleChecker mHoareTripleChecker; - private final boolean mAntiInductivity; - private final boolean mAssertInductivity; - private final int[] mYield; - private final boolean mResult; - - public InductivityCheck(final IUltimateServiceProvider services, final INestedWordAutomaton nwa, - final boolean antiInductivity, final boolean assertInductivity, - final IHoareTripleChecker hoareTripleChecker) { - super(); - mServices = services; - mLogger = mServices.getLoggingService().getLogger(LibraryIdentifiers.PLUGIN_ID); - mHoareTripleChecker = hoareTripleChecker; - mYield = new int[3]; - mAntiInductivity = antiInductivity; - mAssertInductivity = assertInductivity; - mResult = checkInductivity(nwa); - } - - public boolean getResult() { - return mResult; - } - - private boolean checkInductivity(final INestedWordAutomaton nwa) { - if (mAntiInductivity) { - mLogger.info("Starting anti-inductivity check of a Floyd-Hoare automaton with " + nwa.sizeInformation()); - } else { - mLogger.info("Starting inductivity check of a Floyd-Hoare automaton with " + nwa.sizeInformation()); - } - - boolean result = true; - // yield[0] is the number of edges whose inductiveness could be - // proven - // yield[1] is the number of edges whose inductiveness could be - // refuted - // yield[2] is the number of edges whose inductiveness could be - // neither proven nor refuted because theorem prover too weak - // yield[3] is the number of edges whose inductiveness could be - // neither proven nor refuted because there were no interpolants - - for (final IPredicate state : nwa.getStates()) { - for (final OutgoingInternalTransition outTrans : nwa.internalSuccessors(state)) { - final Validity inductivity = mHoareTripleChecker.checkInternal(state, - (IInternalAction) outTrans.getLetter(), outTrans.getSucc()); - final boolean newResult = evaluateResult(inductivity, state, outTrans); - result = result && newResult; - } - for (final OutgoingCallTransition outTrans : nwa.callSuccessors(state)) { - final Validity inductivity = mHoareTripleChecker.checkCall(state, (ICallAction) outTrans.getLetter(), - outTrans.getSucc()); - final boolean newResult = evaluateResult(inductivity, state, outTrans); - result = result && newResult; - } - for (final OutgoingReturnTransition outTrans : nwa.returnSuccessors(state)) { - final Validity inductivity = mHoareTripleChecker.checkReturn(state, outTrans.getHierPred(), - (IReturnAction) outTrans.getLetter(), outTrans.getSucc()); - final boolean newResult = evaluateResult(inductivity, state, outTrans); - result = result && newResult; - } - } - if (mHoareTripleChecker instanceof IncrementalHoareTripleChecker) { - ((IncrementalHoareTripleChecker) mHoareTripleChecker).clearAssertionStack(); - } - mLogger.info("Floyd-Hoare automaton has " + (mYield[0] + mYield[1] + mYield[2]) + " edges. " + mYield[0] - + " inductive. " + mYield[1] + " not inductive. " + mYield[2] + " times theorem prover too" - + " weak to decide inductivity. "); - return result; - } - - private boolean evaluateResult(final Validity inductivity, final IPredicate state, final Object trans) { - boolean result = true; - switch (inductivity) { - case VALID: { - mYield[0]++; - if (mAntiInductivity) { - mLogger.warn("Transition " + state + " " + trans + " not anti inductive"); - result = false; - assert !mAssertInductivity || result : "anti inductivity failed"; - } - break; - } - case INVALID: { - mYield[1]++; - if (!mAntiInductivity) { - mLogger.warn("Transition " + state + " " + trans + " not inductive"); - result = false; - assert !mAssertInductivity || result : "inductivity failed"; - } - break; - } - case UNKNOWN: { - mYield[2]++; - break; - } - default: - throw new IllegalArgumentException(); - } - return result; - } -} diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index c7b6a2322ea..7a008d3c25c 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -60,6 +60,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.NwaFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.CegarLoopStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.NwaCegarLoop; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.PredicateFactoryForInterpolantAutomata; @@ -68,7 +69,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimization; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimization.AutomataMinimizationTimeout; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.Minimization; @@ -180,8 +180,9 @@ protected boolean refineAbstraction() throws AutomataLibraryException { } determinized.switchToReadonlyMode(); assert !mCsToolkit.getManagedScript().isLocked(); - assert new InductivityCheck<>(getServices(), mInterpolAutomaton, false, true, - new IncrementalHoareTripleChecker(mCsToolkit, false)).getResult(); + assert NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, mCsToolkit.getManagedScript(), + new IncrementalHoareTripleChecker(mCsToolkit, false), mRefinementResult.getPredicateUnifier(), + mInterpolAutomaton, true).getResult(); // do the following check only to obtain logger messages of // checkInductivity diff --git a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java index 15990a318d4..cd57e9824b5 100644 --- a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java +++ b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java @@ -61,7 +61,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.HoareTripleCheckerUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.MonolithicHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; @@ -82,7 +81,6 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.CegarLoopStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.PredicateFactoryRefinement; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.predicates.InductivityCheck; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.Minimization; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstractionconcurrent.CegarLoopConcurrentAutomata; @@ -469,7 +467,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // copie // TODO #proofRefactor final boolean explointSigmaStarConcatOfIA = !mComputeHoareAnnotation; - final INestedWordAutomaton oldAbstraction = (INestedWordAutomaton) mAbstraction; + final INestedWordAutomaton oldAbstraction = mAbstraction; final IHoareTripleChecker htc = getEfficientHoareTripleChecker(); // change to CegarLoopConcurrentAutomata mLogger.debug("Start constructing difference"); assert oldAbstraction.getStateFactory() == mInterpolAutomaton.getStateFactory(); @@ -492,8 +490,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // copie oldAbstraction, determinized, psd2, explointSigmaStarConcatOfIA); } assert !mCsToolkit.getManagedScript().isLocked(); - assert new InductivityCheck<>(getServices(), mInterpolAutomaton, false, true, - new IncrementalHoareTripleChecker(mCsToolkit, false)).getResult(); + assert checkInterpolantAutomatonInductivity(mInterpolAutomaton); // do the following check only to obtain logger messages of // checkInductivity From 2032d1ff9d902560bb1dd2553d167a8fb942e5f3 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sat, 2 Dec 2023 10:08:00 +0100 Subject: [PATCH 23/91] remove duplicate stopwatch stopping --- .../plugins/generator/traceabstraction/NwaCegarLoop.java | 1 - 1 file changed, 1 deletion(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 328f2299fa3..40aa07f7ac6 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -571,7 +571,6 @@ protected void computeIcfgHoareAnnotation() { final HoareAnnotationWriter writer = new HoareAnnotationWriter(mIcfg, mCsToolkit, mPredicateFactory, clha, mServices, mSimplificationTechnique, mXnfConversionTechnique); // writer.addHoareAnnotationToCFG(); - mCegarLoopBenchmark.stop(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); mCegarLoopBenchmark.addHoareAnnotationData(clha.getHoareAnnotationStatisticsGenerator()); } finally { mCegarLoopBenchmark.stop(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); From 54d37232f194d6898a9a6c72912021ffcf9f9764 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 3 Dec 2023 10:59:56 +0100 Subject: [PATCH 24/91] fix failures due to FloydHoare checking --- .../floydhoare/NwaFloydHoareValidityCheck.java | 3 ++- .../generator/traceabstraction/AbstractCegarLoop.java | 5 ++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java index b2853b1a2f8..296a2e15878 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java @@ -34,7 +34,8 @@ public static NwaFloydHoareValidityCheck forI final IHoareTripleChecker hoareTripleChecker, final IPredicateUnifier unifier, final INestedWordAutomaton automaton, final boolean assertValidity) { return new NwaFloydHoareValidityCheck<>(services, mgdScript, hoareTripleChecker, automaton, - new FloydHoareForInterpolantAutomaton(unifier), assertValidity, MissingAnnotationBehaviour.THROW, true); + new FloydHoareForInterpolantAutomaton(unifier), assertValidity, MissingAnnotationBehaviour.THROW, + false); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 7afcaed9225..06587659f87 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -80,6 +80,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskFileIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.TaskIdentifier; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; @@ -498,8 +499,10 @@ private void refineAbstractionInternal(final AutomatonType automatonType) // TODO #proofRefactor if (mComputeHoareAnnotation && mPref.getHoareAnnotationPositions() == HoareAnnotationPositions.All) { + final var unifier = new PredicateUnifier(mLogger, mServices, mCsToolkit.getManagedScript(), + mPredicateFactory, mCsToolkit.getSymbolTable(), mSimplificationTechnique, mXnfConversionTechnique); assert NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, mCsToolkit.getManagedScript(), - new IncrementalHoareTripleChecker(mCsToolkit, false), null, + new IncrementalHoareTripleChecker(mCsToolkit, false), unifier, (INestedWordAutomaton) mAbstraction, true).getResult() : "Not inductive"; } From b4501bdf236c5e5d9180b447b3877ec124f75bfd Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Tue, 12 Dec 2023 12:07:02 +0100 Subject: [PATCH 25/91] small simplifications in Hoare annotation classes --- .../floydhoare/HoareAnnotationExtractor.java | 5 ++--- .../floydhoare/HoareAnnotationFragments.java | 4 +--- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java index 0d2d435c7fa..ee6c877b33f 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java @@ -42,7 +42,7 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.OutgoingInternalTransition; import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.OutgoingReturnTransition; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.MLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.SPredicate; @@ -53,8 +53,7 @@ * @author heizmann@informatik.uni-freiburg.de * */ -public class HoareAnnotationExtractor> - extends DoubleDeckerVisitor { +public class HoareAnnotationExtractor extends DoubleDeckerVisitor { Set> mReportedDoubleDeckers = new HashSet<>(); diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java index 52832548c82..86eb79be8ae 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java @@ -37,7 +37,6 @@ import java.util.Map.Entry; import java.util.Set; -import de.uni_freiburg.informatik.ultimate.automata.AutomataOperationCanceledException; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingLetterAndTransitionProvider; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.IntersectNwa; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.oldapi.IOpWithDelayedDeadEndRemoval; @@ -297,8 +296,7 @@ void addContextEntryPair(final IPredicate context, final IPredicate entry) { * Add all DoubleDeckers dd for which holds. - dd was in the automaton directly after the automaton operation op - * after dead ends where removed from op dd was no double decker of the automaton any more. */ - public void addDeadEndDoubleDeckers(final IOpWithDelayedDeadEndRemoval op) - throws AutomataOperationCanceledException { + public void addDeadEndDoubleDeckers(final IOpWithDelayedDeadEndRemoval op) { final IPredicate emtpyStack = op.getResult().getEmptyStackState(); for (final UpDownEntry upDownEntry : op.getRemovedUpDownEntry()) { addDoubleDecker(upDownEntry.getDown(), upDownEntry.getUp(), emtpyStack); From b37babc788d3a946b1ce35d329b1d4f50843ce7e Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Tue, 12 Dec 2023 12:12:42 +0100 Subject: [PATCH 26/91] continue refactoring from hard-coded Hoare annotations to proof producers --- .../cegar/BuchiCegarLoopFactory.java | 3 +- .../HoareProofSettings.java | 65 +++++++++++ .../NwaHoareProofProducer.java | 106 ++++++++++++++---- .../NwaInitialAbstractionProvider.java | 29 ++++- .../proofs/IFinishWithFinalAbstraction.java | 31 +++++ .../traceabstraction/AbstractCegarLoop.java | 21 ++-- .../traceabstraction/CegarLoopFactory.java | 5 +- .../traceabstraction/CegarLoopResult.java | 4 + .../CegarLoopSWBnonRecursive.java | 3 +- .../traceabstraction/EagerReuseCegarLoop.java | 25 ++--- .../IncrementalInclusionCegarLoop.java | 8 +- .../traceabstraction/LazyReuseCegarLoop.java | 25 ++--- .../traceabstraction/NwaCegarLoop.java | 91 ++++----------- .../traceabstraction/ReuseCegarLoop.java | 13 ++- .../concurrency/CegarLoopForPetriNet.java | 5 - .../concurrency/PartialOrderCegarLoop.java | 5 - .../preferences/TAPreferences.java | 5 + .../CegarLoopConcurrentAutomata.java | 24 ++-- .../TAwAFAsCegarLoop.java | 15 +-- 19 files changed, 298 insertions(+), 185 deletions(-) create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IFinishWithFinalAbstraction.java diff --git a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java index e647597966a..6cfdc1b62ab 100644 --- a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java +++ b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java @@ -107,7 +107,8 @@ public BuchiCegarLoopFactory(final IUltimateServiceProvider services, final TAPr Collections.emptySet()); if (!IcfgUtils.isConcurrent(icfg)) { final IInitialAbstractionProvider> automatonProvider = - new NwaInitialAbstractionProvider<>(mServices, stateFactoryForRefinement, true, predicateFactory); + new NwaInitialAbstractionProvider<>(mServices, stateFactoryForRefinement, true, predicateFactory, + mPrefs.getHoareSettings()); return createBuchiAutomatonCegarLoop(icfg, rankVarConstructor, predicateFactory, witnessAutomaton, stateFactoryForRefinement, automatonProvider); } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java new file mode 100644 index 00000000000..2fbb701abf2 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction; + +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; + +public class HoareProofSettings { + // TODO: Add HoareAnnotationPositions.NONE in place of this boolean + private final boolean mComputeHoareAnnotation; + + private final HoareAnnotationPositions mHoarePositions; + private final SimplificationTechnique mSimplificationTechnique; + private final XnfConversionTechnique mXnfConversionTechnique; + + public HoareProofSettings(final boolean computeHoareAnnotation, final HoareAnnotationPositions hoarePositions, + final SimplificationTechnique simplificationTechnique, + final XnfConversionTechnique xnfConversionTechnique) { + mComputeHoareAnnotation = computeHoareAnnotation; + mHoarePositions = hoarePositions; + mSimplificationTechnique = simplificationTechnique; + mXnfConversionTechnique = xnfConversionTechnique; + } + + public boolean computeHoareAnnotation() { + return mComputeHoareAnnotation; + } + + public HoareAnnotationPositions getHoarePositions() { + return mHoarePositions; + } + + public SimplificationTechnique getSimplificationTechnique() { + return mSimplificationTechnique; + } + + public XnfConversionTechnique getXnfConversionTechnique() { + return mXnfConversionTechnique; + } +} diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java index ea513dea106..84351e01636 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java @@ -27,45 +27,72 @@ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction; import java.util.Map; +import java.util.Set; import de.uni_freiburg.informatik.ultimate.automata.nestedword.IDoubleDeckerAutomaton; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingLetterAndTransitionProvider; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.ProductNwa; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.oldapi.IOpWithDelayedDeadEndRemoval; +import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofPostProcessor; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationComposer; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationExtractor; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationFragments; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IFloydHoareAnnotation; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; -final class NwaHoareProofProducer - implements IProofProducer, IUpdateOnMinimization, IUpdateOnDifference { +final class NwaHoareProofProducer + implements IProofProducer, IUpdateOnMinimization, IUpdateOnDifference, + IFinishWithFinalAbstraction> { - private final INestedWordAutomaton mProgram; - // private final Set mHoareAnnotationStates; - private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; + private final IUltimateServiceProvider mServices; - private NwaHoareProofProducer(final INestedWordAutomaton program, // final Set hoareAnnotationStates, - final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { + private final INestedWordAutomaton mProgram; + private final CfgSmtToolkit mCsToolkit; + private final PredicateFactory mPredicateFactory; + + private final HoareProofSettings mPrefs; + private final Set mHoareAnnotationStates; + + private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; + + private final HoareAnnotationFragments mHaf; + + private INestedWordAutomaton mFinalAbstraction; + + private NwaHoareProofProducer(final IUltimateServiceProvider services, + final INestedWordAutomaton program, final CfgSmtToolkit csToolkit, + final PredicateFactory predicateFactory, final HoareProofSettings prefs, + final Set hoareAnnotationStates, + final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { + mServices = services; mProgram = program; - // mHoareAnnotationStates = hoareAnnotationStates; - // mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates); + mCsToolkit = csToolkit; + mPredicateFactory = predicateFactory; + mPrefs = prefs; + mHoareAnnotationStates = hoareAnnotationStates; + mHaf = new HoareAnnotationFragments<>(services.getLoggingService().getLogger(getClass()), + hoareAnnotationStates); mPost = postProcessor; assert postProcessor.getOriginalProgram() == mProgram; } - public static - NwaHoareProofProducer, IFloydHoareAnnotation> - create(final INestedWordAutomaton program - // , final Set hoareAnnotationStates - ) { - return new NwaHoareProofProducer<>(program, - // hoareAnnotationStates, + public static + NwaHoareProofProducer, IFloydHoareAnnotation> + create(final IUltimateServiceProvider services, final INestedWordAutomaton program, + final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, + final HoareProofSettings prefs, final Set hoareAnnotationStates) { + return new NwaHoareProofProducer<>(services, program, csToolkit, predicateFactory, prefs, hoareAnnotationStates, IProofPostProcessor.identity(program)); } @@ -82,16 +109,45 @@ public boolean hasProof() { @Override public PROOF getOrComputeProof() { + // TODO measure time + // mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); + try { + final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); + + // TODO extract data to IFloydHoareAnnotation + // final HoareAnnotationWriter writer = new HmComputeHoareAnnotationoareAnnotationWriter(mIcfg, mCsToolkit, + // mPredicateFactory, + // clha, + // mServices, mSimplificationTechnique, mXnfConversionTechnique); + // writer.addHoareAnnotationToCFG(); + + // TODO forward statistics + // mCegarLoopBenchmark.addHoareAnnotationData(clha.getHoareAnnotationStatisticsGenerator()); + } finally { + // mCegarLoopBenchmark.stop(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); + } + // TODO final IFloydHoareAnnotation floydHoare = null; return mPost.processProof(floydHoare); } + private HoareAnnotationComposer computeHoareAnnotationComposer() { + if (mCsToolkit.getManagedScript().isLocked()) { + throw new AssertionError( + "ManagedScript must not be locked at the beginning of Hoare annotation computation"); + } + new HoareAnnotationExtractor<>(mServices, mFinalAbstraction, mHaf); + final HoareAnnotationComposer clha = new HoareAnnotationComposer(mCsToolkit, mPredicateFactory, mHaf, mServices, + mPrefs.getSimplificationTechnique(), mPrefs.getXnfConversionTechnique()); + return clha; + } + @Override - public NwaHoareProofProducer + public NwaHoareProofProducer withPostProcessor(final IProofPostProcessor postProcessor) { - return new NwaHoareProofProducer<>(mProgram, // mHoareAnnotationStates, - IProofPostProcessor.compose(mPost, postProcessor)); + return new NwaHoareProofProducer<>(mServices, mProgram, mCsToolkit, mPredicateFactory, mPrefs, + mHoareAnnotationStates, IProofPostProcessor.compose(mPost, postProcessor)); } @Override @@ -109,20 +165,22 @@ public boolean exploitSigmaStarConcatOfIa() { public void updateOnIntersection( final Map.ProductState>> fst2snd2res, final IDoubleDeckerAutomaton result) { - // TODO Auto-generated method stub - + mHaf.updateOnIntersection(fst2snd2res, result); } @Override public void addDeadEndDoubleDeckers(final IOpWithDelayedDeadEndRemoval diff) { - // TODO Auto-generated method stub - + mHaf.addDeadEndDoubleDeckers(diff); } @Override public void updateOnMinimization(final Map old2New, final INwaOutgoingLetterAndTransitionProvider abstraction) { - // TODO Auto-generated method stub + mHaf.updateOnMinimization(old2New, abstraction); + } + @Override + public void finish(final INestedWordAutomaton finalAbstraction) { + mFinalAbstraction = finalAbstraction; } } \ No newline at end of file diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index 06a679f71c0..cc1ca2ec211 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -31,6 +31,7 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.statefactory.IEmptyStackStateFactory; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; @@ -57,8 +58,14 @@ public class NwaInitialAbstractionProvider> private final IEmptyStackStateFactory mStateFactory; private final boolean mInterprocedural; private final PredicateFactory mPredicateFactory; + private CfgSmtToolkit mCsToolkit; + // settings for proofs + private final HoareProofSettings mPrefs; + + // generated by the instance itself private INestedWordAutomaton mAbstraction; + private Set mHoareStates; /** * Create a new instance. For documentation of the parameters, see the corresponding parameters in @@ -66,14 +73,12 @@ public class NwaInitialAbstractionProvider> */ public NwaInitialAbstractionProvider(final IUltimateServiceProvider services, final IEmptyStackStateFactory stateFactory, final boolean interprocedural, - final PredicateFactory predicateFactory // , - // TODO: Add HoareAnnotationPositions.NONE in place of this boolean - // final boolean computeHoareAnnotation, final HoareAnnotationPositions hoarePositions - ) { + final PredicateFactory predicateFactory, final HoareProofSettings prefs) { mServices = services; mStateFactory = stateFactory; mInterprocedural = interprocedural; mPredicateFactory = predicateFactory; + mPrefs = prefs; } @Override @@ -82,14 +87,24 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg computeHoareStates(final IIcfg icfg, + final INestedWordAutomaton abstraction) { + // TODO Auto-generated method stub + return null; + } + @Override public IProofProducer, PROOF> getProofProducer(final Class proofType, final Class proofUpdates) { - // TODO if hoareAnnotationStates.isEmpty() return null + if (!mPrefs.computeHoareAnnotation()) { + return null; + } if (proofUpdates == null || proofUpdates.isAssignableFrom(NwaHoareProofProducer.class)) { // TODO implement retrieval of suitable proof converter, if one exists @@ -97,7 +112,9 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg. + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; + +public interface IFinishWithFinalAbstraction { + void finish(A finalAbstraction); +} diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 06587659f87..472021ed488 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -293,12 +293,6 @@ protected abstract Pair> isCounterexampleFeasi */ protected abstract boolean refineAbstraction() throws AutomataLibraryException; - /** - * Add Hoare annotation to the control flow graph. Use the information computed so far annotate the ProgramPoints of - * the control flow graph with invariants. - */ - protected abstract void computeIcfgHoareAnnotation(); - protected abstract Set, IPredicateUnifier>> getFloydHoareAutomata(); /** @@ -498,6 +492,7 @@ private void refineAbstractionInternal(final AutomatonType automatonType) } // TODO #proofRefactor + // TODO should proof updaters have methods for sanity checks like this? if (mComputeHoareAnnotation && mPref.getHoareAnnotationPositions() == HoareAnnotationPositions.All) { final var unifier = new PredicateUnifier(mLogger, mServices, mCsToolkit.getManagedScript(), mPredicateFactory, mCsToolkit.getSymbolTable(), mSimplificationTechnique, mXnfConversionTechnique); @@ -875,12 +870,14 @@ public CegarLoopResult getResult() { } // TODO #proofRefactor - if (mComputeHoareAnnotation && mResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE)) { - computeIcfgHoareAnnotation(); - writeHoareAnnotationToLogger(); - } else { - mLogger.debug("Omitting computation of Hoare annotation"); - } + // TODO make sure CEGAR loops transmit necessary info to proof producers (e.g. in finish() or isAbsEmpty()) + // TODO let callers decide if they want to extract proofs using CegarLoopResult::hasProvenAnything() + // if (mComputeHoareAnnotation && mResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE)) { + // computeIcfgHoareAnnotation(); + // writeHoareAnnotationToLogger(); + // } else { + // mLogger.debug("Omitting computation of Hoare annotation"); + // } return new CegarLoopResult<>(mResults, cegarLoopBenchmarkGenerator, getArtifact(), floydHoareAutomata); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index ff8809865cb..be4aaec2daa 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -138,8 +138,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr final Set hoareAnnotationLocs; if (mComputeHoareAnnotation) { - hoareAnnotationLocs = - mPrefs.getHoareAnnotationPositions().getLocations(root); + hoareAnnotationLocs = mPrefs.getHoareAnnotationPositions().getLocations(root); } else { hoareAnnotationLocs = Collections.emptySet(); } @@ -263,7 +262,7 @@ private INestedWordAutomaton createAutomataAbstraction(final IUlt if (!isConcurrent) { final IInitialAbstractionProvider> provider = new NwaInitialAbstractionProvider<>(services, stateFactory, mPrefs.interprocedural(), - predicateFactory); + predicateFactory, mPrefs.getHoareSettings()); if (witnessAutomaton == null) { return provider; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java index a39883fe96f..ad633e640ec 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java @@ -74,4 +74,8 @@ public IElement getArtifact() { public List, IPredicateUnifier>> getFloydHoareAutomata() { return mFloydHoareAutomata; } + + public boolean hasProvenAnything() { + return mLocalResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE); + } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index ebf404c6be1..9fe4e0ddf34 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -63,6 +63,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.tracecheck.ITraceCheckPreferences.AssertCodeBlockOrder; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheckCraig; @@ -170,7 +171,7 @@ public class CegarLoopSWBnonRecursive> extends NwaC * @param services * @param transitionClazz */ - public & IUpdateOnMinimization> CegarLoopSWBnonRecursive( + public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> CegarLoopSWBnonRecursive( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg icfg, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index 5fff247a096..ffe8cb4d40d 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -48,6 +48,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; @@ -76,12 +77,12 @@ private enum MinimizeInitially { private static final boolean IDENTIFY_USELESS_FLOYDHOARE_AUTOMATA = false; // TODO can this method be removed? - public & IUpdateOnMinimization> EagerReuseCegarLoop(final DebugIdentifier name, - final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, - final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final InterpolationTechnique interpolation, - final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, - final IUltimateServiceProvider services, + public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> EagerReuseCegarLoop( + final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, + final TAPreferences taPrefs, final Set errorLocs, + final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { @@ -158,17 +159,13 @@ assert checkInterpolantAutomatonInductivity( dumpOrAppendAutomatonForReuseIfEnabled(reuseAut, predicateUnifier); if (REMOVE_DEAD_ENDS) { - // TODO #proofRefactor - if (mComputeHoareAnnotation) { + if (mProofUpdater != null) { final Difference difference = (Difference) diff; - mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); + mProofUpdater.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } - diff.removeDeadEnds(); - - // TODO #proofRefactor - if (mComputeHoareAnnotation) { - mHaf.addDeadEndDoubleDeckers(diff); + if (mProofUpdater != null) { + mProofUpdater.addDeadEndDoubleDeckers(diff); } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index a461853e9f3..87273c34017 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -65,6 +65,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; @@ -82,7 +83,7 @@ public class IncrementalInclusionCegarLoop> extends protected final List> mInterpolantAutomata = new ArrayList<>(); protected final List mHoareTripleChecker = new ArrayList<>(); - public & IUpdateOnMinimization> IncrementalInclusionCegarLoop( + public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> IncrementalInclusionCegarLoop( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, @@ -95,10 +96,9 @@ public & IUpdateOnMinimization> Incremental stateFactoryForRefinement); mLanguageOperation = languageOperation; - // TODO #proofRefactor - if (mComputeHoareAnnotation) { + if (proofUpdater != null) { throw new UnsupportedOperationException( - "while using this CEGAR loop computation of Hoare annotation is unsupported "); + "while using this CEGAR loop computation of proofs is unsupported "); } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index 12360955a5f..8f1f8fd08ba 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -52,6 +52,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; @@ -75,12 +76,12 @@ public class LazyReuseCegarLoop> extends ReuseCegar private Pair, IPredicateUnifier> mAutomatonAcceptingCounterexample; - public & IUpdateOnMinimization> LazyReuseCegarLoop(final DebugIdentifier name, - final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, - final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final InterpolationTechnique interpolation, - final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, - final IUltimateServiceProvider services, + public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> LazyReuseCegarLoop( + final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, + final TAPreferences taPrefs, final Set errorLocs, + final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFiles, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { @@ -189,17 +190,13 @@ assert checkInterpolantAutomatonInductivity( dumpOrAppendAutomatonForReuseIfEnabled(reuseAut, reuseAutPair.getSecond()); if (REMOVE_DEAD_ENDS) { - // TODO #proofRefactor - if (mComputeHoareAnnotation) { + if (mProofUpdater != null) { final Difference difference = (Difference) diff; - mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); + mProofUpdater.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } - diff.removeDeadEnds(); - - // TODO #proofRefactor - if (mComputeHoareAnnotation) { - mHaf.addDeadEndDoubleDeckers(diff); + if (mProofUpdater != null) { + mProofUpdater.addDeadEndDoubleDeckers(diff); } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 40aa07f7ac6..4429f352f9e 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -87,9 +87,7 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SMTFeatureExtractionTermClassifier.ScoringMethod; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationComposer; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationExtractor; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationFragments; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; @@ -138,21 +136,18 @@ public class NwaCegarLoop> extends BasicCegarLoop mProofUpdater; - protected HoareAnnotationFragments mHaf; - - public & IUpdateOnMinimization> NwaCegarLoop(final DebugIdentifier name, - final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, - final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final InterpolationTechnique interpolation, - final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, - final IUltimateServiceProvider services, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { + protected final ProofUpdater mProofUpdater; + + public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> NwaCegarLoop( + final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, + final TAPreferences taPrefs, final Set errorLocs, + final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mProofUpdater = proofUpdater == null ? null : new ProofUpdater<>(proofUpdater); - mHaf = new HoareAnnotationFragments<>(mLogger, hoareAnnotationStates); mErrorGeneralizationEngine = new ErrorGeneralizationEngine<>(services); @@ -327,9 +322,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { } else { automatonType = AutomatonType.FLOYD_HOARE; useErrorAutomaton = false; - // TODO #proofRefactor - exploitSigmaStarConcatOfIa = - !mComputeHoareAnnotation && (mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa()); + exploitSigmaStarConcatOfIa = mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa(); subtrahendBeforeEnhancement = mInterpolAutomaton; enhanceMode = mPref.interpolantAutomatonEnhancement(); subtrahend = enhanceInterpolantAutomaton(enhanceMode, predicateUnifier, htc, subtrahendBeforeEnhancement); @@ -407,22 +400,11 @@ private void computeAutomataDifference(final INestedWordAutomaton } if (REMOVE_DEAD_ENDS) { - // TODO #proofRefactor - if (mComputeHoareAnnotation) { - final Difference difference = (Difference) diff; - mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); - } if (mProofUpdater != null) { final Difference difference = (Difference) diff; mProofUpdater.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } - diff.removeDeadEnds(); - - // TODO #proofRefactor - if (mComputeHoareAnnotation) { - mHaf.addDeadEndDoubleDeckers(diff); - } if (mProofUpdater != null) { mProofUpdater.addDeadEndDoubleDeckers(diff); } @@ -514,8 +496,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac : new HashSet<>(Arrays.asList(((IMLPredicate) x).getProgramPoints()))); AutomataMinimization, IPredicate, L> am; try { - // TODO #proofRefactor - final boolean computeOld2New = mComputeHoareAnnotation || mProofUpdater != null; + final boolean computeOld2New = mProofUpdater != null; am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, mIteration, predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, lcsProvider, true); @@ -530,15 +511,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac // postprocessing after minimization final IDoubleDeckerAutomaton newAbstraction = am.getMinimizedAutomaton(); - // extract Hoare annotation - // TODO #proofRefactor - if (mComputeHoareAnnotation) { - final Map oldState2newState = am.getOldState2newStateMapping(); - if (oldState2newState == null) { - throw new AssertionError("Hoare annotation and " + minimization + " incompatible"); - } - mHaf.updateOnMinimization(oldState2newState, newAbstraction); - } + // update proof if (mProofUpdater != null) { final Map oldState2newState = am.getOldState2newStateMapping(); if (oldState2newState == null) { @@ -559,35 +532,13 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac @Override protected void finish() { + if (mProofUpdater != null) { + mProofUpdater.finish(mAbstraction); + } mErrorGeneralizationEngine.reportErrorGeneralizationBenchmarks(); super.finish(); } - @Override - protected void computeIcfgHoareAnnotation() { - mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); - try { - final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); - final HoareAnnotationWriter writer = new HoareAnnotationWriter(mIcfg, mCsToolkit, mPredicateFactory, clha, - mServices, mSimplificationTechnique, mXnfConversionTechnique); - // writer.addHoareAnnotationToCFG(); - mCegarLoopBenchmark.addHoareAnnotationData(clha.getHoareAnnotationStatisticsGenerator()); - } finally { - mCegarLoopBenchmark.stop(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); - } - } - - protected HoareAnnotationComposer computeHoareAnnotationComposer() { - if (mCsToolkit.getManagedScript().isLocked()) { - throw new AssertionError("SMTManager must not be locked at the beginning of Hoare annotation computation"); - } - final INestedWordAutomaton abstraction = mAbstraction; - new HoareAnnotationExtractor<>(mServices, abstraction, mHaf); - final HoareAnnotationComposer clha = new HoareAnnotationComposer(mCsToolkit, mPredicateFactory, mHaf, mServices, - mSimplificationTechnique, mXnfConversionTechnique); - return clha; - } - private static final boolean checkStoreCounterExamples(final TAPreferences pref) { return pref.getMinimization() == Minimization.NWA_OVERAPPROXIMATION; } @@ -606,8 +557,9 @@ private static SearchStrategy getSearchStrategy(final IPreferenceProvider mPrefs // Annoyingly, this wrapper seems currently necessary due to Java's limited support for intersection types. // The alternative is including a type parameter as below in the NwaCegarLoop itself. - private static final class ProofUpdater & IUpdateOnDifference> - implements IUpdateOnMinimization, IUpdateOnDifference { + protected static final class ProofUpdater & IUpdateOnDifference & IFinishWithFinalAbstraction>> + implements IUpdateOnMinimization, IUpdateOnDifference, + IFinishWithFinalAbstraction> { private final T mUpdater; public ProofUpdater(final T updater) { @@ -636,5 +588,10 @@ public void updateOnMinimization(final Map old2New, final INwaOutgoingLetterAndTransitionProvider abstraction) { mUpdater.updateOnMinimization(old2New, abstraction); } + + @Override + public void finish(final INestedWordAutomaton finalAbstraction) { + mUpdater.finish(finalAbstraction); + } } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java index fd25ecdf506..cb32bccd9a9 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java @@ -69,6 +69,7 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; @@ -107,12 +108,12 @@ public class ReuseCegarLoop> extends NwaCegarLoop & IUpdateOnMinimization> ReuseCegarLoop(final DebugIdentifier name, - final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, - final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final InterpolationTechnique interpolation, - final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, - final IUltimateServiceProvider services, + public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> ReuseCegarLoop( + final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, + final TAPreferences taPrefs, final Set errorLocs, + final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, + final Set hoareAnnotationStates, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index 2aedb1df18a..78623a36d56 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -561,11 +561,6 @@ private Set determineUniversalSubtrahendLoopers(final Set alphabet, final .collect(Collectors.toSet()); } - @Override - protected void computeIcfgHoareAnnotation() { - throw new UnsupportedOperationException("Petri net based analysis cannot compute Hoare annotation."); - } - @Override protected void constructErrorAutomaton() throws AutomataOperationCanceledException { throw new UnsupportedOperationException("Error automata not supported for " + CegarLoopForPetriNet.class); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java index 61c8fffa24b..2fe765aa1e9 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java @@ -428,11 +428,6 @@ protected void constructErrorAutomaton() throws AutomataOperationCanceledExcepti throw new UnsupportedOperationException("Error automata not supported for " + PartialOrderCegarLoop.class); } - @Override - protected void computeIcfgHoareAnnotation() { - throw new UnsupportedOperationException("Hoare annotation not supported for " + PartialOrderCegarLoop.class); - } - private IDeadEndStore createDeadEndStore(final StateSplitter splitter) { assert mDeadEndStore == null : "Already created -- should only be called once"; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java index c5beadb4ab2..369a473da16 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java @@ -41,6 +41,7 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.ExternalSolver; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.SolverMode; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; +import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.HoareProofSettings; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderMode; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderReductionFacade.OrderType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings; @@ -558,4 +559,8 @@ public McrInterpolantMethod getMcrInterpolantMethod() { return mMcrInterpolantMethod; } + public HoareProofSettings getHoareSettings() { + return new HoareProofSettings(computeHoareAnnotation(), getHoareAnnotationPositions(), + getSimplificationTechnique(), getXnfConversionTechnique()); + } } diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 7a008d3c25c..424dc3eced6 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -104,9 +104,9 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac final Function> lcsProvider = x -> asHashSet(x.getProgramPoints()); AutomataMinimization, IMLPredicate, L> am; try { - // TODO #proofRefactor - am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, mComputeHoareAnnotation, - mIteration, predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, + final boolean computeOld2New = mProofUpdater != null; + am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, mIteration, + predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, lcsProvider, false); } catch (final AutomataMinimizationTimeout e) { mCegarLoopBenchmark.addAutomataMinimizationData(e.getStatistics()); @@ -120,14 +120,13 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac // postprocessing after minimization final IDoubleDeckerAutomaton newAbstraction = am.getMinimizedAutomaton(); - // extract Hoare annotation - // TODO #proofRefactor - if (mComputeHoareAnnotation) { + // update proof + if (mProofUpdater != null) { final Map oldState2newState = am.getOldState2newStateMapping(); if (oldState2newState == null) { throw new AssertionError("Hoare annotation and " + minimization + " incompatible"); } - mHaf.updateOnMinimization(oldState2newState, newAbstraction); + mProofUpdater.updateOnMinimization(oldState2newState, newAbstraction); } // statistics @@ -137,7 +136,6 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac // use result mAbstraction = newAbstraction; - } } @@ -148,7 +146,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); // TODO #proofRefactor - final boolean explointSigmaStarConcatOfIA = !mComputeHoareAnnotation; + final boolean explointSigmaStarConcatOfIA = mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa(); final INestedWordAutomaton oldAbstraction = mAbstraction; final IPredicateUnifier predicateUnifier = mRefinementResult.getPredicateUnifier(); @@ -187,13 +185,13 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // checkInductivity if (REMOVE_DEAD_ENDS) { - if (mComputeHoareAnnotation) { + if (mProofUpdater != null) { final Difference difference = (Difference) diff; - mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); + mProofUpdater.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } diff.removeDeadEnds(); - if (mComputeHoareAnnotation) { - mHaf.addDeadEndDoubleDeckers(diff); + if (mProofUpdater != null) { + mProofUpdater.addDeadEndDoubleDeckers(diff); } } diff --git a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java index cd57e9824b5..e2dd9a5e567 100644 --- a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java +++ b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java @@ -464,8 +464,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // copie mStateFactoryForRefinement.setIteration(super.mIteration); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); - // TODO #proofRefactor - final boolean explointSigmaStarConcatOfIA = !mComputeHoareAnnotation; + final boolean explointSigmaStarConcatOfIA = mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa(); final INestedWordAutomaton oldAbstraction = mAbstraction; final IHoareTripleChecker htc = getEfficientHoareTripleChecker(); // change to CegarLoopConcurrentAutomata @@ -495,17 +494,13 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // copie // checkInductivity if (REMOVE_DEAD_ENDS) { - // TODO #proofRefactor - if (mComputeHoareAnnotation) { + if (mProofUpdater != null) { final Difference difference = (Difference) diff; - mHaf.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); + mProofUpdater.updateOnIntersection(difference.getFst2snd2res(), difference.getResult()); } - diff.removeDeadEnds(); - - // TODO #proofRefactor - if (mComputeHoareAnnotation) { - mHaf.addDeadEndDoubleDeckers(diff); + if (mProofUpdater != null) { + mProofUpdater.addDeadEndDoubleDeckers(diff); } } From 9080e3b27905cdf86dede1f8cefe75925674ead7 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 14 Dec 2023 11:08:53 +0100 Subject: [PATCH 27/91] simplify settings (will be modified further) --- .../initialabstraction/HoareProofSettings.java | 8 ++------ .../traceabstraction/CegarLoopFactory.java | 7 +------ .../preferences/TAPreferences.java | 14 ++++++-------- .../TraceAbstractionPreferenceInitializer.java | 5 ----- 4 files changed, 9 insertions(+), 25 deletions(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java index 2fbb701abf2..b94471a335b 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java @@ -31,24 +31,20 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; public class HoareProofSettings { - // TODO: Add HoareAnnotationPositions.NONE in place of this boolean - private final boolean mComputeHoareAnnotation; - private final HoareAnnotationPositions mHoarePositions; private final SimplificationTechnique mSimplificationTechnique; private final XnfConversionTechnique mXnfConversionTechnique; - public HoareProofSettings(final boolean computeHoareAnnotation, final HoareAnnotationPositions hoarePositions, + public HoareProofSettings(final HoareAnnotationPositions hoarePositions, final SimplificationTechnique simplificationTechnique, final XnfConversionTechnique xnfConversionTechnique) { - mComputeHoareAnnotation = computeHoareAnnotation; mHoarePositions = hoarePositions; mSimplificationTechnique = simplificationTechnique; mXnfConversionTechnique = xnfConversionTechnique; } public boolean computeHoareAnnotation() { - return mComputeHoareAnnotation; + return mHoarePositions != HoareAnnotationPositions.None; } public HoareAnnotationPositions getHoarePositions() { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index be4aaec2daa..34f9c6b2c78 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -136,12 +136,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr final CfgSmtToolkit csToolkit = root.getCfgSmtToolkit(); final PredicateFactory predicateFactory = constructPredicateFactory(services, csToolkit); - final Set hoareAnnotationLocs; - if (mComputeHoareAnnotation) { - hoareAnnotationLocs = mPrefs.getHoareAnnotationPositions().getLocations(root); - } else { - hoareAnnotationLocs = Collections.emptySet(); - } + final Set hoareAnnotationLocs = mPrefs.getHoareAnnotationPositions().getLocations(root); final PredicateFactoryRefinement stateFactoryForRefinement = new PredicateFactoryRefinement(services, csToolkit.getManagedScript(), predicateFactory, mComputeHoareAnnotation, hoareAnnotationLocs); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java index 369a473da16..507ebc335ee 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java @@ -74,7 +74,6 @@ public final class TAPreferences { private final String mDumpPath; private final InterpolantAutomatonEnhancement mDeterminiation; private final Minimization mMinimize; - private final boolean mHoare; private final Concurrency mAutomataTypeConcurrency; private final HoareTripleChecks mHoareTripleChecks; @Reflected(excluded = true) @@ -125,10 +124,8 @@ public TAPreferences(final IUltimateServiceProvider services) { mArtifact = mPrefs.getEnum(TraceAbstractionPreferenceInitializer.LABEL_ARTIFACT, Artifact.class); - mHoare = mPrefs.getBoolean(TraceAbstractionPreferenceInitializer.LABEL_HOARE); - - mHoareAnnotationPositions = mHoare ? mPrefs.getEnum(TraceAbstractionPreferenceInitializer.LABEL_HOARE_POSITIONS, - HoareAnnotationPositions.class) : HoareAnnotationPositions.None; + mHoareAnnotationPositions = mPrefs.getEnum(TraceAbstractionPreferenceInitializer.LABEL_HOARE_POSITIONS, + HoareAnnotationPositions.class); mInterpolation = mPrefs.getEnum(TraceAbstractionPreferenceInitializer.LABEL_INTERPOLATED_LOCS, InterpolationTechnique.class); @@ -348,9 +345,10 @@ public Concurrency getAutomataTypeConcurrency() { } // TODO #proofRefactor + // TODO #proofRefactor update all settings files to reflect the removal / changes to the corresponding settings @Deprecated public boolean computeHoareAnnotation() { - return mHoare; + return mHoareAnnotationPositions != HoareAnnotationPositions.None; } public HoareAnnotationPositions getHoareAnnotationPositions() { @@ -560,7 +558,7 @@ public McrInterpolantMethod getMcrInterpolantMethod() { } public HoareProofSettings getHoareSettings() { - return new HoareProofSettings(computeHoareAnnotation(), getHoareAnnotationPositions(), - getSimplificationTechnique(), getXnfConversionTechnique()); + return new HoareProofSettings(getHoareAnnotationPositions(), getSimplificationTechnique(), + getXnfConversionTechnique()); } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java index d6ac21e172a..63526102008 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TraceAbstractionPreferenceInitializer.java @@ -256,10 +256,6 @@ public enum CoinflipMode { public static final String LABEL_WATCHITERATION = "Number of iteration whose artifact is visualized"; private static final int DEF_WATCHITERATION = 1_000_000; - public static final String LABEL_HOARE = - "Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG"; - private static final boolean DEF_HOARE = false; - public static final String LABEL_HOARE_POSITIONS = "Positions where we compute the Hoare Annotation"; private static final HoareAnnotationPositions DEF_HOARE_POSITIONS = HoareAnnotationPositions.All; @@ -544,7 +540,6 @@ protected BaseUltimatePreferenceItem[] initDefaultPreferences() { new UltimatePreferenceItem<>(LABEL_ARTIFACT, Artifact.RCFG, PreferenceType.Combo, Artifact.values()), new UltimatePreferenceItem<>(LABEL_WATCHITERATION, DEF_WATCHITERATION, PreferenceType.Integer, new IUltimatePreferenceItemValidator.IntegerValidator(0, 1_0000_000)), - new UltimatePreferenceItem<>(LABEL_HOARE, DEF_HOARE, PreferenceType.Boolean), new UltimatePreferenceItem<>(LABEL_HOARE_POSITIONS, DEF_HOARE_POSITIONS, PreferenceType.Combo, HoareAnnotationPositions.values()), From eb2b75cc26c5d39c78ae27514261c2b6678abd43 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 14 Dec 2023 12:01:06 +0100 Subject: [PATCH 28/91] add missing statistics result to initial abstraction providers --- .../cegar/BuchiCegarLoopFactory.java | 3 +- .../ChcProviderConcurrentWithLbe.java | 7 +-- .../IInitialAbstractionProvider.java | 8 ++- .../PartialOrderAbstractionProvider.java | 32 +++++++++-- ...ri2FiniteAutomatonAbstractionProvider.java | 6 ++ .../PetriLbeInitialAbstractionProvider.java | 35 +++++++++--- .../PartialOrderReductionFacade.java | 55 +++++++++---------- .../PetriNetLargeBlockEncoding.java | 5 +- .../PetriNetLargeBlockEncodingBenchmarks.java | 51 ----------------- .../AbstractStatisticsDataProvider.java | 11 ++++ .../traceabstraction/CegarLoopFactory.java | 4 +- .../WitnessAutomatonAbstractionProvider.java | 5 ++ .../concurrency/PartialOrderCegarLoop.java | 8 ++- ...ctConstraintHornClauseSolverTestSuite.java | 5 +- .../AbstractTraceAbstractionTestSuite.java | 3 - 15 files changed, 125 insertions(+), 113 deletions(-) delete mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncodingBenchmarks.java diff --git a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java index 6cfdc1b62ab..07dacd9cace 100644 --- a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java +++ b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiCegarLoopFactory.java @@ -144,8 +144,7 @@ public BuchiCegarLoopFactory(final IUltimateServiceProvider services, final TAPr } return new PetriLbeInitialAbstractionProvider<>(petriNetProvider, mServices, mTransitionClazz, mPrefs.lbeIndependenceSettings(), - (IPLBECompositionFactory) new IcfgCompositionFactory(mServices, icfg.getCfgSmtToolkit()), - Activator.PLUGIN_ID); + (IPLBECompositionFactory) new IcfgCompositionFactory(mServices, icfg.getCfgSmtToolkit())); } private BuchiAutomatonCegarLoop createBuchiAutomatonCegarLoop(final IIcfg icfg, diff --git a/trunk/source/IcfgToChc/src/de/uni_freiburg/informatik/ultimate/plugins/icfgtochc/concurrent/ChcProviderConcurrentWithLbe.java b/trunk/source/IcfgToChc/src/de/uni_freiburg/informatik/ultimate/plugins/icfgtochc/concurrent/ChcProviderConcurrentWithLbe.java index a6cbb9d0a77..eb4b6fac14e 100644 --- a/trunk/source/IcfgToChc/src/de/uni_freiburg/informatik/ultimate/plugins/icfgtochc/concurrent/ChcProviderConcurrentWithLbe.java +++ b/trunk/source/IcfgToChc/src/de/uni_freiburg/informatik/ultimate/plugins/icfgtochc/concurrent/ChcProviderConcurrentWithLbe.java @@ -28,7 +28,6 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.PetriLbeInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.IcfgCompositionFactory; -import de.uni_freiburg.informatik.ultimate.plugins.icfgtochc.Activator; import de.uni_freiburg.informatik.ultimate.plugins.icfgtochc.IcfgToChcObserver.IChcProvider; /** @@ -112,9 +111,9 @@ private static BoundedPetriNet getPetriNetWithLbe(final II new PredicateFactory(services, csToolkit.getManagedScript(), csToolkit.getSymbolTable()); final PetriInitialAbstractionProvider petriNetProvider = new PetriInitialAbstractionProvider<>(services, predicateFactory, true); - final PetriLbeInitialAbstractionProvider lbeProvider = new PetriLbeInitialAbstractionProvider<>( - petriNetProvider, services, IcfgEdge.class, new IndependenceSettings(), - new IcfgCompositionFactory(services, csToolkit), Activator.PLUGIN_ID); + final PetriLbeInitialAbstractionProvider lbeProvider = + new PetriLbeInitialAbstractionProvider<>(petriNetProvider, services, IcfgEdge.class, + new IndependenceSettings(), new IcfgCompositionFactory(services, csToolkit)); final Set inUseLocs = new HashSet<>(icfg.getCfgSmtToolkit().getConcurrencyInformation().getInUseErrorNodeMap().values()); final Set errors = icfg.getProcedureErrorNodes().values().stream().flatMap(Collection::stream) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java index f3da944864e..df06f0e0f19 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java @@ -35,6 +35,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; /** * Interface for the computation of the initial abstraction used by a CEGAR loop. @@ -96,5 +98,9 @@ default IProofProducer getProofProducer(final Class pro + " does not support producing proofs of type " + proofType.getSimpleName() + suffix); } - // TODO Add statistics support + default IStatisticsDataProvider getStatistics() { + return new AbstractStatisticsDataProvider() { + // by default, no statistics are reported + }; + } } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PartialOrderAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PartialOrderAbstractionProvider.java index 42d66532714..1507b2c3750 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PartialOrderAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PartialOrderAbstractionProvider.java @@ -44,6 +44,9 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderReductionFacade; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderReductionFacade.OrderType; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceBuilder; +import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; +import de.uni_freiburg.informatik.ultimate.util.statistics.StatisticsData; /** * Transforms an initial abstraction by applying one-shot Partial Order Reduction. @@ -63,7 +66,8 @@ public class PartialOrderAbstractionProvider> private final PartialOrderMode mPartialOrderMode; private final OrderType mOrderType; private final long mDfsOrderSeed; - private final String mPluginId; + + private final Statistics mStatistics = new Statistics(); /** * Create a new instance of the provider. @@ -89,7 +93,7 @@ public PartialOrderAbstractionProvider( final IInitialAbstractionProvider> underlying, final IUltimateServiceProvider services, final IEmptyStackStateFactory stateFactory, final PredicateFactory predicateFactory, final PartialOrderMode partialOrderMode, final OrderType orderType, - final long dfsOrderSeed, final String pluginId) { + final long dfsOrderSeed) { mUnderlying = underlying; mServices = services; mStateFactory = stateFactory; @@ -97,7 +101,6 @@ public PartialOrderAbstractionProvider( mPartialOrderMode = partialOrderMode; mOrderType = orderType; mDfsOrderSeed = dfsOrderSeed; - mPluginId = pluginId; } @Override @@ -116,8 +119,27 @@ IndependenceBuilder. semantic(mServices, icfg.getCfgSmtToolkit().getManagedSc // actually apply POR to automaton final NestedWordAutomaton result = por.constructReduction(input, mStateFactory); - // TODO add statistics support to IInitialAbstractionProvider - por.reportStatistics(mPluginId); + mStatistics.reportPORStatistics(por); return result; } + + @Override + public IStatisticsDataProvider getStatistics() { + return mStatistics; + } + + private class Statistics extends AbstractStatisticsDataProvider { + private static final String POR_STATISTICS = "Partial Order Reduction statistics"; + private static final String UNDERLYING_STATISTICS = "Statistics of underlying abstraction provider"; + + public Statistics() { + forward(UNDERLYING_STATISTICS, mUnderlying::getStatistics); + } + + private void reportPORStatistics(final PartialOrderReductionFacade por) { + final var data = new StatisticsData(); + data.aggregateBenchmarkData(por.getStatistics()); + include(POR_STATISTICS, () -> data); + } + } } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java index 5ce2f98325f..26065eee4f5 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java @@ -48,6 +48,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; /** * Transforms an initial abstraction in the form of a Petri net to a finite automaton. @@ -114,6 +115,11 @@ private static boolean isLocationHopeless(final Map hopel }); } + @Override + public IStatisticsDataProvider getStatistics() { + return mUnderlying.getStatistics(); + } + /** * Transforms an initial abstraction in the form of a Petri net to a finite automaton, by eagerly exploring and * explicitly constructing all reachable states of the reachability graph. diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java index bfebb852614..ed950c911e3 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java @@ -30,7 +30,6 @@ import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryException; import de.uni_freiburg.informatik.ultimate.automata.petrinet.netdatastructures.BoundedPetriNet; -import de.uni_freiburg.informatik.ultimate.core.lib.results.StatisticsResult; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; @@ -39,6 +38,9 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.PetriNetLargeBlockEncoding; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.PetriNetLargeBlockEncoding.IPLBECompositionFactory; +import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; +import de.uni_freiburg.informatik.ultimate.util.statistics.StatisticsData; /** * Transforms an initial abstraction by applying one-shot Petri LBE. @@ -56,7 +58,8 @@ public class PetriLbeInitialAbstractionProvider> private final IPLBECompositionFactory mCompositionFactory; private final Class mTransitionClazz; private final IndependenceSettings mIndependenceSettings; - private final String mPluginId; + + private final Statistics mStatistics = new Statistics(); /** * Create a new instance. @@ -77,14 +80,12 @@ public class PetriLbeInitialAbstractionProvider> public PetriLbeInitialAbstractionProvider( final IInitialAbstractionProvider> underlying, final IUltimateServiceProvider services, final Class transitionClazz, - final IndependenceSettings independenceSettings, final IPLBECompositionFactory compositionFactory, - final String pluginId) { + final IndependenceSettings independenceSettings, final IPLBECompositionFactory compositionFactory) { mUnderlying = underlying; mServices = services; mTransitionClazz = transitionClazz; mIndependenceSettings = independenceSettings; mCompositionFactory = compositionFactory; - mPluginId = pluginId; } @Override @@ -97,10 +98,28 @@ public BoundedPetriNet getInitialAbstraction(final IIcfg lbecfg = lbe.getResult(); mServices.getBacktranslationService().addTranslator(lbe.getBacktranslator()); - // TODO add statistics support to IInitialAbstractionProvider - mServices.getResultService().reportResult(mPluginId, - new StatisticsResult<>(mPluginId, "PetriNetLargeBlockEncoding benchmarks", lbe.getStatistics())); + mStatistics.reportLiptonStatistics(lbe); return lbecfg; } + + @Override + public IStatisticsDataProvider getStatistics() { + return mStatistics; + } + + private class Statistics extends AbstractStatisticsDataProvider { + private static final String LIPTON_STATISTICS = "PetriNetLargeBlockEncoding benchmarks"; + private static final String UNDERLYING_STATISTICS = "Statistics of underlying abstraction provider"; + + public Statistics() { + forward(UNDERLYING_STATISTICS, mUnderlying::getStatistics); + } + + private void reportLiptonStatistics(final PetriNetLargeBlockEncoding pnlbe) { + final var data = new StatisticsData(); + data.aggregateBenchmarkData(pnlbe.getStatistics()); + include(LIPTON_STATISTICS, () -> data); + } + } } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/PartialOrderReductionFacade.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/PartialOrderReductionFacade.java index 0c1f5a071b4..fae4d36328f 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/PartialOrderReductionFacade.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/PartialOrderReductionFacade.java @@ -65,7 +65,6 @@ import de.uni_freiburg.informatik.ultimate.automata.partialorder.visitors.IDfsVisitor; import de.uni_freiburg.informatik.ultimate.automata.partialorder.visitors.WrapperVisitor; import de.uni_freiburg.informatik.ultimate.automata.statefactory.IEmptyStackStateFactory; -import de.uni_freiburg.informatik.ultimate.core.lib.results.StatisticsResult; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; @@ -77,6 +76,8 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.LoopLockstepOrder.PredicateWithLastThread; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceBuilder; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; +import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.StatisticsData; /** @@ -118,8 +119,7 @@ public enum OrderType { private IPersistentSetChoice mPersistent; private final Function, IBudgetFunction> mGetBudget; - private final List mOldIndependenceStatistics = new ArrayList<>(); - private final List mOldPersistentSetStatistics = new ArrayList<>(); + private final Statistics mStatistics = new Statistics(); public PartialOrderReductionFacade(final IUltimateServiceProvider services, final PredicateFactory predicateFactory, final IIcfg icfg, final Collection errorLocs, final PartialOrderMode mode, @@ -161,14 +161,9 @@ public void replaceIndependence(final int index, final IIndependenceRelation createBuildVisitor(final VpAlphabet alphab return new DeadEndOptimizingSearchVisitor<>(visitor, mDeadEndStore, true); } - public void reportStatistics(final String pluginId) { - int i = 0; - for (final StatisticsData data : mOldIndependenceStatistics) { - mServices.getResultService().reportResult(pluginId, - new StatisticsResult<>(pluginId, "Independence relation #" + (i + 1) + " benchmarks", data)); - i++; + public IStatisticsDataProvider getStatistics() { + for (final var relation : mIndependenceRelations) { + mStatistics.reportIndependenceStatistics(relation); + } + if (mPersistent != null) { + mStatistics.reportPersistentSetStatistics(mPersistent); } + return mStatistics; + } - for (final var relation : mIndependenceRelations) { + private final class Statistics extends AbstractStatisticsDataProvider { + private int mIndependenceStatisticsCounter = 0; + private int mPersistentSetStatisticsCounter = 0; + + private void reportIndependenceStatistics(final IIndependenceRelation relation) { final StatisticsData data = new StatisticsData(); data.aggregateBenchmarkData(relation.getStatistics()); - mServices.getResultService().reportResult(pluginId, - new StatisticsResult<>(pluginId, "Independence relation #" + (i + 1) + " benchmarks", data)); - i++; - } - - for (final StatisticsData data : mOldPersistentSetStatistics) { - mServices.getResultService().reportResult(pluginId, - new StatisticsResult<>(pluginId, "Persistent set benchmarks", data)); + mIndependenceStatisticsCounter++; + include("Independence relation #" + mIndependenceStatisticsCounter + " benchmarks", () -> data); } - if (mPersistent != null) { - final StatisticsData persistentData = new StatisticsData(); - persistentData.aggregateBenchmarkData(mPersistent.getStatistics()); - mServices.getResultService().reportResult(pluginId, - new StatisticsResult<>(pluginId, "Persistent set benchmarks", persistentData)); + private void reportPersistentSetStatistics(final IPersistentSetChoice persistent) { + final StatisticsData data = new StatisticsData(); + data.aggregateBenchmarkData(persistent.getStatistics()); + mPersistentSetStatisticsCounter++; + include("Persistent sets #" + mPersistentSetStatisticsCounter + " benchmarks", () -> data); } } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncoding.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncoding.java index d726121a388..330413328ad 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncoding.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncoding.java @@ -59,6 +59,7 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.SyntacticIndependenceRelation; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.logic.TermVariable; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; /** * Performs a Large Block Encoding on Petri nets. This operation performs Lipton reduction ({@link LiptonReduction}) and @@ -186,8 +187,8 @@ public BlockEncodingBacktranslator getBacktranslator() { return mBacktranslator; } - public PetriNetLargeBlockEncodingBenchmarks getStatistics() { - return new PetriNetLargeBlockEncodingBenchmarks(mStatistics); + public IStatisticsDataProvider getStatistics() { + return mStatistics; } /** diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncodingBenchmarks.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncodingBenchmarks.java deleted file mode 100644 index 3c19ce2a117..00000000000 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/partialorder/petrinetlbe/PetriNetLargeBlockEncodingBenchmarks.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright (C) 2019 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) - * Copyright (C) 2019 University of Freiburg - * - * This file is part of the ULTIMATE TraceCheckerUtils Library. - * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission - * to convey the resulting work. - */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe; - -import de.uni_freiburg.informatik.ultimate.util.csv.ICsvProvider; -import de.uni_freiburg.informatik.ultimate.util.csv.ICsvProviderProvider; -import de.uni_freiburg.informatik.ultimate.util.statistics.StatisticsData; - -public class PetriNetLargeBlockEncodingBenchmarks implements ICsvProviderProvider { - - private final StatisticsData mStatisticsData; - - public PetriNetLargeBlockEncodingBenchmarks(final PetriNetLargeBlockEncodingStatisticsGenerator gen) { - mStatisticsData = new StatisticsData(); - mStatisticsData.aggregateBenchmarkData(gen); - } - - @Override - public String toString() { - return mStatisticsData.toString(); - } - - @Override - public ICsvProvider createCsvProvider() { - return mStatisticsData.createCsvProvider(); - } -} diff --git a/trunk/source/Library-UltimateUtil/src/de/uni_freiburg/informatik/ultimate/util/statistics/AbstractStatisticsDataProvider.java b/trunk/source/Library-UltimateUtil/src/de/uni_freiburg/informatik/ultimate/util/statistics/AbstractStatisticsDataProvider.java index 6a72c3b8549..81981a26cc6 100644 --- a/trunk/source/Library-UltimateUtil/src/de/uni_freiburg/informatik/ultimate/util/statistics/AbstractStatisticsDataProvider.java +++ b/trunk/source/Library-UltimateUtil/src/de/uni_freiburg/informatik/ultimate/util/statistics/AbstractStatisticsDataProvider.java @@ -87,6 +87,17 @@ protected final void forwardAll(final String key, final Iterable elems, Aggregate::appendList, PrettyPrint.list(PrettyPrint::keyColonData, Object::toString)); } + protected final void include(final String key, final Supplier getStatistics) { + declare(key, getStatistics::get, Aggregate::statisticsDataAggregate, PrettyPrint::keyColonData); + } + + protected final void includeAll(final String key, final Supplier> getStatistics) { + declare(key, + () -> StreamSupport.stream(getStatistics.get().spliterator(), false) + .collect(Collectors.toCollection(ArrayList::new)), + Aggregate::appendList, PrettyPrint.list(PrettyPrint::keyColonData, Object::toString)); + } + private static StatisticsData toStatisticsData(final IStatisticsDataProvider statistics) { final StatisticsData data = new StatisticsData(); data.aggregateBenchmarkData(statistics); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 34f9c6b2c78..110bae5c2a0 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -276,7 +276,7 @@ private INestedWordAutomaton createAutomataAbstraction(final IUlt new Petri2FiniteAutomatonAbstractionProvider.Lazy<>(netProvider, stateFactory, new AutomataLibraryServices(services)), services, stateFactory, predicateFactory, mPrefs.getPartialOrderMode(), mPrefs.getDfsOrderType(), - mPrefs.getDfsOrderSeed(), Activator.PLUGIN_ID); + mPrefs.getDfsOrderSeed()); } @Deprecated @@ -303,7 +303,7 @@ private IInitialAbstractionProvider> createPet return netProvider; } return new PetriLbeInitialAbstractionProvider<>(netProvider, services, mTransitionClazz, - mPrefs.lbeIndependenceSettings(), mCreateCompositionFactory.get(), Activator.PLUGIN_ID); + mPrefs.lbeIndependenceSettings(), mCreateCompositionFactory.get()); } private INwaOutgoingLetterAndTransitionProvider createPartialOrderAbstraction( diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/WitnessAutomatonAbstractionProvider.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/WitnessAutomatonAbstractionProvider.java index 73e2ddac536..a61e6a1b6af 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/WitnessAutomatonAbstractionProvider.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/WitnessAutomatonAbstractionProvider.java @@ -43,6 +43,7 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.IInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.witnesschecking.WitnessUtils; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.witnesschecking.WitnessUtils.Property; +import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.witnessparser.graph.WitnessEdge; import de.uni_freiburg.informatik.ultimate.witnessparser.graph.WitnessNode; @@ -90,4 +91,8 @@ public IDoubleDeckerAutomaton getInitialAbstraction(final IIcfg ia : mAbstractItpAutomata) { mCegarLoopBenchmark.reportInterpolantAutomatonStates(ia.size()); } - mPOR.reportStatistics(Activator.PLUGIN_ID); + + final var data = new StatisticsData(); + data.aggregateBenchmarkData(mPOR.getStatistics()); + mServices.getResultService().reportResult(Activator.PLUGIN_ID, + new StatisticsResult<>(Activator.PLUGIN_ID, "Partial order reduction statistics", data)); super.finish(); } diff --git a/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractConstraintHornClauseSolverTestSuite.java b/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractConstraintHornClauseSolverTestSuite.java index 2386c33d585..ccbde0fc8a5 100644 --- a/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractConstraintHornClauseSolverTestSuite.java +++ b/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractConstraintHornClauseSolverTestSuite.java @@ -30,15 +30,14 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker.HoareTripleCheckerStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifierStatisticsGenerator.PredicateUniferStatisticsDefinitions; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.PetriNetLargeBlockEncodingBenchmarks; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheckStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.plugins.generator.codecheck.CodeCheckBenchmarks; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.CegarLoopStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionBenchmarks; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimizationStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.test.UltimateRunDefinition; -import de.uni_freiburg.informatik.ultimate.test.decider.ITestResultDecider; import de.uni_freiburg.informatik.ultimate.test.decider.ChcTestResultDecider; +import de.uni_freiburg.informatik.ultimate.test.decider.ITestResultDecider; import de.uni_freiburg.informatik.ultimate.test.logs.incremental.IncrementalLogCsv; import de.uni_freiburg.informatik.ultimate.test.logs.incremental.IncrementalLogWithBenchmarkResults; import de.uni_freiburg.informatik.ultimate.test.logs.incremental.IncrementalLogWithVMParameters; @@ -72,7 +71,6 @@ protected ITestResultDecider constructITestResultDecider(final UltimateRunDefini @Override protected ITestSummary[] constructTestSummaries() { final ArrayList>> benchmarks = new ArrayList<>(); - benchmarks.add(PetriNetLargeBlockEncodingBenchmarks.class); benchmarks.add(TraceAbstractionBenchmarks.class); benchmarks.add(CodeCheckBenchmarks.class); benchmarks.add(Benchmark.class); @@ -147,7 +145,6 @@ protected ITestSummary[] constructTestSummaries() { // @formatter:on return new ITestSummary[] { new TraceAbstractionTestSummary(this.getClass()), - new CsvConcatenator(this.getClass(), PetriNetLargeBlockEncodingBenchmarks.class), new CsvConcatenator(this.getClass(), TraceAbstractionBenchmarks.class), new CsvConcatenator(this.getClass(), CodeCheckBenchmarks.class), // new CsvConcatenator(this.getClass(), StatisticsData.class), diff --git a/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractTraceAbstractionTestSuite.java b/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractTraceAbstractionTestSuite.java index 72d6318f308..07de171ae17 100644 --- a/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractTraceAbstractionTestSuite.java +++ b/trunk/source/UltimateTest/src/de/uni_freiburg/informatik/ultimate/ultimatetest/suites/traceabstraction/AbstractTraceAbstractionTestSuite.java @@ -31,7 +31,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker.HoareTripleCheckerStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifierStatisticsGenerator.PredicateUniferStatisticsDefinitions; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.PetriNetLargeBlockEncodingBenchmarks; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheckStatisticsDefinitions; import de.uni_freiburg.informatik.ultimate.plugins.generator.codecheck.CodeCheckBenchmarks; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.CegarLoopStatisticsDefinitions; @@ -69,7 +68,6 @@ protected ITestResultDecider constructITestResultDecider(final UltimateRunDefini @Override protected ITestSummary[] constructTestSummaries() { final ArrayList>> benchmarks = new ArrayList<>(); - benchmarks.add(PetriNetLargeBlockEncodingBenchmarks.class); benchmarks.add(TraceAbstractionBenchmarks.class); benchmarks.add(CodeCheckBenchmarks.class); benchmarks.add(Benchmark.class); @@ -144,7 +142,6 @@ protected ITestSummary[] constructTestSummaries() { // @formatter:on return new ITestSummary[] { new TraceAbstractionTestSummary(this.getClass()), - new CsvConcatenator(this.getClass(), PetriNetLargeBlockEncodingBenchmarks.class), new CsvConcatenator(this.getClass(), TraceAbstractionBenchmarks.class), new CsvConcatenator(this.getClass(), CodeCheckBenchmarks.class), // new CsvConcatenator(this.getClass(), StatisticsData.class), From 87b555acff521bdecdc1e6b3c35f994718c2333c Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 15 Dec 2023 15:31:25 +0100 Subject: [PATCH 29/91] missing license headers --- .../IcfgFloydHoareValidityCheck.java | 26 +++++++++++++++++++ .../NwaFloydHoareValidityCheck.java | 26 +++++++++++++++++++ 2 files changed, 52 insertions(+) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java index 501f57f5125..87446ba4c37 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java @@ -1,3 +1,29 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import java.util.Set; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java index 296a2e15878..e3ec5611e6d 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java @@ -1,3 +1,29 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; From 0aaec9cf90bc5eb5d624c5813d00b0e273ec6aa2 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 17 Dec 2023 10:33:43 +0100 Subject: [PATCH 30/91] continue refactoring --- .../smt/predicates/HoareAnnotation.java | 3 +- .../smt/predicates/PredicateUtils.java | 7 ++ .../floydhoare/HoareAnnotationComposer.java | 9 +- .../IcfgAnnotationFromAutomaton.java | 86 ++++++++++++++++ .../NwaHoareProofProducer.java | 61 +++++++----- .../HoareAnnotationWriter.java | 98 ------------------- 6 files changed, 136 insertions(+), 128 deletions(-) create mode 100644 trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgAnnotationFromAutomaton.java delete mode 100644 trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java index 5df3e846f79..4a3bf59c260 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java @@ -50,7 +50,8 @@ * * @author heizmann@informatik.uni-freiburg.de */ - +// TODO #proofRefactor get rid of this class +@Deprecated public class HoareAnnotation extends SPredicate { private static final String KEY = HoareAnnotation.class.getSimpleName(); diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java index 792ea2b06f1..94d6ad63fc9 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java @@ -399,6 +399,13 @@ private static Term rename(final Script script, final IPredicate postcond, final return result; } + public static IcfgLocation getLocation(final IPredicate pred) { + if (pred instanceof ISLPredicate) { + return ((ISLPredicate) pred).getProgramPoint(); + } + throw new IllegalArgumentException("predicate does not offer program point: " + pred); + } + public static Stream getLocations(final IPredicate pred) { if (pred instanceof ISLPredicate) { return Stream.of(((ISLPredicate) pred).getProgramPoint()); diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java index 67ad0587f3b..b23d721d5ce 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java @@ -48,7 +48,6 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.ExtendedSimplificationResult; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.Substitution; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.normalforms.NnfTransformer; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.normalforms.NnfTransformer.QuantifierHandling; @@ -89,8 +88,7 @@ public class HoareAnnotationComposer { private final IPredicate mSurrogateForEmptyCallPred; public HoareAnnotationComposer(final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final HoareAnnotationFragments hoareAnnotationFragments, final IUltimateServiceProvider services, - final SimplificationTechnique simplicationTechnique, final XnfConversionTechnique xnfConversionTechnique) { + final HoareAnnotationFragments hoareAnnotationFragments, final IUltimateServiceProvider services) { mServices = services; mLogger = services.getLoggingService().getLogger(getClass()); mCsToolkit = csToolkit; @@ -291,6 +289,11 @@ public Map getLoc2hoare() { return mLoc2hoare; } + public IFloydHoareAnnotation extractAnnotation() { + // TODO pre/post + return new FloydHoareMapping<>(null, null, mLoc2hoare); + } + /** * Construct Predicate which represents the same Predicate as ps, but where all globalVars are renamed to * oldGlobalVars. diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgAnnotationFromAutomaton.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgAnnotationFromAutomaton.java new file mode 100644 index 00000000000..2c99b33ba02 --- /dev/null +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgAnnotationFromAutomaton.java @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE TraceCheckerUtils Library. + * + * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; + +import java.util.HashMap; +import java.util.Set; +import java.util.function.Function; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; + +public class IcfgAnnotationFromAutomaton { + private final Function mGetProgramPoint; + private final IFloydHoareAnnotation mResult; + + public IcfgAnnotationFromAutomaton(final IFloydHoareAnnotation annotation, final Set states, + final Function getProgramPoint) { + mGetProgramPoint = getProgramPoint; + mResult = extractAnnotation(annotation, states); + } + + public static IcfgAnnotationFromAutomaton + create(final IFloydHoareAnnotation automatonAnnotation, final Set states) { + return new IcfgAnnotationFromAutomaton<>(automatonAnnotation, states, PredicateUtils::getLocation); + } + + public static IcfgAnnotationFromAutomaton + create(final IFloydHoareAnnotation automatonAnnotation, final INestedWordAutomaton automaton) { + return new IcfgAnnotationFromAutomaton<>(automatonAnnotation, automaton.getStates(), + PredicateUtils::getLocation); + } + + private IFloydHoareAnnotation extractAnnotation(final IFloydHoareAnnotation annotation, + final Set states) { + final var result = new HashMap(); + + for (final var state : states) { + final IPredicate pred = annotation.getAnnotation(state); + if (pred == null) { + // there is no annotation for this state + continue; + } + + final var loc = mGetProgramPoint.apply(state); + + final var annot = result.get(loc); + if (annot != null) { + // TODO add the invariant, don't overwrite the old one + } + + result.put(loc, pred); + } + + return new FloydHoareMapping<>(annotation.getPrecondition(), annotation.getPostcondition(), result); + } + + public IFloydHoareAnnotation getResult() { + return mResult; + } +} diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java index 84351e01636..f5e4c149431 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java @@ -28,6 +28,7 @@ import java.util.Map; import java.util.Set; +import java.util.function.Supplier; import de.uni_freiburg.informatik.ultimate.automata.nestedword.IDoubleDeckerAutomaton; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; @@ -48,7 +49,10 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; +import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; +import de.uni_freiburg.informatik.ultimate.util.statistics.KeyType; +import de.uni_freiburg.informatik.ultimate.util.statistics.TimeTracker; final class NwaHoareProofProducer implements IProofProducer, IUpdateOnMinimization, IUpdateOnDifference, @@ -66,9 +70,11 @@ final class NwaHoareProofProducer private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; private final HoareAnnotationFragments mHaf; - private INestedWordAutomaton mFinalAbstraction; + private PROOF mProof; + private final Statistics mStatistics = new Statistics(); + private NwaHoareProofProducer(final IUltimateServiceProvider services, final INestedWordAutomaton program, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final HoareProofSettings prefs, @@ -103,32 +109,21 @@ public PROGRAM getProgram() { @Override public boolean hasProof() { - // TODO Auto-generated method stub - return false; + return mFinalAbstraction != null; } @Override public PROOF getOrComputeProof() { - // TODO measure time - // mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); - try { - final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); - - // TODO extract data to IFloydHoareAnnotation - // final HoareAnnotationWriter writer = new HmComputeHoareAnnotationoareAnnotationWriter(mIcfg, mCsToolkit, - // mPredicateFactory, - // clha, - // mServices, mSimplificationTechnique, mXnfConversionTechnique); - // writer.addHoareAnnotationToCFG(); - - // TODO forward statistics - // mCegarLoopBenchmark.addHoareAnnotationData(clha.getHoareAnnotationStatisticsGenerator()); - } finally { - // mCegarLoopBenchmark.stop(CegarLoopStatisticsDefinitions.HoareAnnotationTime.toString()); + if (mProof == null) { + mProof = mStatistics.measureProofComputation(this::computeProof); } + return mProof; + } - // TODO - final IFloydHoareAnnotation floydHoare = null; + private PROOF computeProof() { + final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); + final var floydHoare = clha.extractAnnotation(); + mStatistics.reportHoareStatistics(clha); return mPost.processProof(floydHoare); } @@ -138,9 +133,7 @@ private HoareAnnotationComposer computeHoareAnnotationComposer() { "ManagedScript must not be locked at the beginning of Hoare annotation computation"); } new HoareAnnotationExtractor<>(mServices, mFinalAbstraction, mHaf); - final HoareAnnotationComposer clha = new HoareAnnotationComposer(mCsToolkit, mPredicateFactory, mHaf, mServices, - mPrefs.getSimplificationTechnique(), mPrefs.getXnfConversionTechnique()); - return clha; + return new HoareAnnotationComposer(mCsToolkit, mPredicateFactory, mHaf, mServices); } @Override @@ -152,8 +145,7 @@ private HoareAnnotationComposer computeHoareAnnotationComposer() { @Override public IStatisticsDataProvider getStatistics() { - // TODO Auto-generated method stub - throw new UnsupportedOperationException(); + return mStatistics; } @Override @@ -183,4 +175,21 @@ public void updateOnMinimization(final Map old2New, public void finish(final INestedWordAutomaton finalAbstraction) { mFinalAbstraction = finalAbstraction; } + + private final class Statistics extends AbstractStatisticsDataProvider { + private final TimeTracker mProofTime = new TimeTracker(); + + public Statistics() { + declare("Hoare annotation time", () -> mProofTime, KeyType.TT_TIMER); + forward("Postprocessor statistics", mPost::getStatistics); + } + + private T measureProofComputation(final Supplier computation) { + return mProofTime.measure(computation); + } + + private void reportHoareStatistics(final HoareAnnotationComposer composer) { + forward("Hoare annotation statistics", composer::getHoareAnnotationStatisticsGenerator); + } + } } \ No newline at end of file diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java deleted file mode 100644 index 9cd18078ebd..00000000000 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/HoareAnnotationWriter.java +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright (C) 2014-2015 Daniel Dietsch (dietsch@informatik.uni-freiburg.de) - * Copyright (C) 2014-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) - * Copyright (C) 2015 University of Freiburg - * - * This file is part of the ULTIMATE TraceAbstraction plug-in. - * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission - * to convey the resulting work. - */ -package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; - -import java.util.Map.Entry; - -import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.SPredicate; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.UnknownState; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationComposer; - -/** - * Write a Hoare annotation provided by HoareAnnotationFragments to the CFG. - * - * @author heizmann@informatik.uni-freiburg.de - * - */ -public class HoareAnnotationWriter { - - private final IUltimateServiceProvider mServices; - private final IIcfg mIcfg; - private final CfgSmtToolkit mCsToolkit; - private final PredicateFactory mPredicateFactory; - private final HoareAnnotationComposer mCegarLoopHoareAnnotation; - - - public HoareAnnotationWriter(final IIcfg icfg, final CfgSmtToolkit csToolkit, - final PredicateFactory predicateFactory, final HoareAnnotationComposer cegarLoopHoareAnnotation, - final IUltimateServiceProvider services, final SimplificationTechnique simplicationTechnique, - final XnfConversionTechnique xnfConversionTechnique) { - mServices = services; - mIcfg = icfg; - mCsToolkit = csToolkit; - mPredicateFactory = predicateFactory; - mCegarLoopHoareAnnotation = cegarLoopHoareAnnotation; - } - - public void addHoareAnnotationToCFG() { - for (final Entry entry : mCegarLoopHoareAnnotation.getLoc2hoare().entrySet()) { - final IcfgLocation loc = getProgramPoint(entry.getKey()); - final HoareAnnotation taAnnot = HoareAnnotation.getAnnotation(loc); - final HoareAnnotation hoareAnnot; - if (taAnnot == null) { - hoareAnnot = - mPredicateFactory.getNewHoareAnnotation(loc, mCsToolkit.getModifiableGlobalsTable()); - hoareAnnot.annotate(loc); - } else { - hoareAnnot = taAnnot; - } - hoareAnnot.addInvariant(entry.getValue()); - } - } - - private IcfgLocation getProgramPoint(final IPredicate pred) { - final IcfgLocation pp; - if (pred instanceof SPredicate) { - pp = ((SPredicate) pred).getProgramPoint(); - } else if (pred instanceof UnknownState) { - pp = ((UnknownState) pred).getProgramPoint(); - } else { - throw new AssertionError("predicate does not offer program point"); - } - return pp; - } -} From f62a22ff41eb19641fef07e626d58425ce501e78 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 17 Dec 2023 13:43:45 +0100 Subject: [PATCH 31/91] move proof-related code to its own library plugin --- trunk/source/BA_MavenParentUltimate/pom.xml | 1 + .../BuchiAutomizer/META-INF/MANIFEST.MF | 1 + .../cegar/AbstractBuchiCegarLoop.java | 2 +- .../InvariantSynthesis/META-INF/MANIFEST.MF | 1 + .../InvariantSynthesisStarter.java | 2 +- trunk/source/Library-Proofs/.classpath | 7 ++++ trunk/source/Library-Proofs/.project | 33 +++++++++++++++ .../source/Library-Proofs/LicenseTemplate.md | 23 +++++++++++ .../Library-Proofs/META-INF/MANIFEST.MF | 17 ++++++++ trunk/source/Library-Proofs/build.properties | 4 ++ trunk/source/Library-Proofs/pom.xml | 41 +++++++++++++++++++ .../proofs/IFinishWithFinalAbstraction.java | 14 +++---- .../lib}/proofs/IUpdateOnDifference.java | 14 +++---- .../lib}/proofs/IUpdateOnMinimization.java | 14 +++---- .../ultimate/lib/proofs/Proofs.java | 38 +++++++++++++++++ .../FloydHoareForInterpolantAutomaton.java | 14 +++---- .../proofs}/floydhoare/FloydHoareMapping.java | 14 +++---- .../floydhoare/FloydHoareValidityCheck.java | 14 +++---- .../floydhoare/HoareAnnotationComposer.java | 14 +++---- .../floydhoare/HoareAnnotationExtractor.java | 14 +++---- .../floydhoare/HoareAnnotationFragments.java | 14 +++---- .../floydhoare/HoareAnnotationPositions.java | 14 +++---- .../HoareAnnotationStatisticsDefinitions.java | 14 +++---- .../HoareAnnotationStatisticsGenerator.java | 14 +++---- .../HoareAnnotationStatisticsType.java | 14 +++---- .../floydhoare}/HoareProofSettings.java | 15 ++++--- .../floydhoare/IFloydHoareAnnotation.java | 14 +++---- .../IcfgAnnotationFromAutomaton.java | 14 +++---- .../IcfgFloydHoareValidityCheck.java | 14 +++---- .../NwaFloydHoareValidityCheck.java | 14 +++---- .../floydhoare}/NwaHoareProofProducer.java | 26 +++++------- .../META-INF/MANIFEST.MF | 3 +- .../source/Library-TraceCheckerUtils/pom.xml | 12 +++--- .../NwaInitialAbstractionProvider.java | 4 +- .../TraceAbstraction/META-INF/MANIFEST.MF | 1 + .../traceabstraction/AbstractCegarLoop.java | 4 +- .../traceabstraction/BasicCegarLoop.java | 2 +- .../CegarLoopSWBnonRecursive.java | 6 +-- .../traceabstraction/EagerReuseCegarLoop.java | 6 +-- .../IncrementalInclusionCegarLoop.java | 6 +-- .../traceabstraction/LazyReuseCegarLoop.java | 6 +-- .../traceabstraction/NwaCegarLoop.java | 6 +-- .../traceabstraction/ReuseCegarLoop.java | 6 +-- .../TraceAbstractionStarter.java | 2 +- .../preferences/TAPreferences.java | 4 +- ...TraceAbstractionPreferenceInitializer.java | 2 +- .../META-INF/MANIFEST.MF | 1 + .../CegarLoopConcurrentAutomata.java | 2 +- 48 files changed, 343 insertions(+), 179 deletions(-) create mode 100644 trunk/source/Library-Proofs/.classpath create mode 100644 trunk/source/Library-Proofs/.project create mode 100644 trunk/source/Library-Proofs/LicenseTemplate.md create mode 100644 trunk/source/Library-Proofs/META-INF/MANIFEST.MF create mode 100644 trunk/source/Library-Proofs/build.properties create mode 100644 trunk/source/Library-Proofs/pom.xml rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib}/proofs/IFinishWithFinalAbstraction.java (60%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib}/proofs/IUpdateOnDifference.java (72%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib}/proofs/IUpdateOnMinimization.java (67%) create mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/Proofs.java rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/FloydHoareForInterpolantAutomaton.java (74%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/FloydHoareMapping.java (80%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/FloydHoareValidityCheck.java (94%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/HoareAnnotationComposer.java (94%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/HoareAnnotationExtractor.java (88%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/HoareAnnotationFragments.java (92%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/HoareAnnotationPositions.java (78%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/HoareAnnotationStatisticsDefinitions.java (83%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/HoareAnnotationStatisticsGenerator.java (84%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/HoareAnnotationStatisticsType.java (66%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare}/HoareProofSettings.java (74%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/IFloydHoareAnnotation.java (63%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/IcfgAnnotationFromAutomaton.java (83%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/IcfgFloydHoareValidityCheck.java (90%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs}/floydhoare/NwaFloydHoareValidityCheck.java (88%) rename trunk/source/{Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare}/NwaHoareProofProducer.java (84%) diff --git a/trunk/source/BA_MavenParentUltimate/pom.xml b/trunk/source/BA_MavenParentUltimate/pom.xml index 129b518cdfd..f495412e27a 100644 --- a/trunk/source/BA_MavenParentUltimate/pom.xml +++ b/trunk/source/BA_MavenParentUltimate/pom.xml @@ -547,6 +547,7 @@ ../Library-PDR ../Library-PEA ../Library-PreferenceJson + ../Library-Proofs ../Library-Sifa ../Library-SMTLIB ../Library-SmtLibUtils diff --git a/trunk/source/BuchiAutomizer/META-INF/MANIFEST.MF b/trunk/source/BuchiAutomizer/META-INF/MANIFEST.MF index 6ffb8a4e9a5..3fd08e59dc9 100644 --- a/trunk/source/BuchiAutomizer/META-INF/MANIFEST.MF +++ b/trunk/source/BuchiAutomizer/META-INF/MANIFEST.MF @@ -8,6 +8,7 @@ Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.lib.smtlib, de.uni_freiburg.informatik.ultimate.lib.smtlibutils, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils, + de.uni_freiburg.informatik.ultimate.lib.proofs, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils, de.uni_freiburg.informatik.ultimate.lib.boogieast, de.uni_freiburg.informatik.ultimate.core, diff --git a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java index 2ba543e6d65..b2d764738f9 100644 --- a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java +++ b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/AbstractBuchiCegarLoop.java @@ -77,11 +77,11 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskIterationIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.TaskIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.CoverageAnalysis.BackwardCoveringInformation; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.NwaFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheckCraig; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; diff --git a/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF b/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF index 523cce2ae42..2f80473226c 100644 --- a/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF +++ b/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF @@ -20,6 +20,7 @@ Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.plugins.analysis.abstractinterpretationv2, de.uni_freiburg.informatik.ultimate.lib.ultimatemodel, de.uni_freiburg.informatik.ultimate.lib.icfgtransformer, + de.uni_freiburg.informatik.ultimate.lib.proofs, de.uni_freiburg.informatik.ultimate.plugins.blockencoding, de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction Bundle-ActivationPolicy: lazy diff --git a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java index f34340bc606..658e9d22462 100644 --- a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java +++ b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java @@ -68,6 +68,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; @@ -76,7 +77,6 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.ExternalSolver; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.SolverMode; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder.SolverSettings; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.invariantsynthesis.preferences.InvariantSynthesisPreferenceInitializer; import de.uni_freiburg.informatik.ultimate.plugins.generator.invariantsynthesis.preferences.InvariantSynthesisPreferenceInitializer.IncreasingStrategy; diff --git a/trunk/source/Library-Proofs/.classpath b/trunk/source/Library-Proofs/.classpath new file mode 100644 index 00000000000..e801ebfb468 --- /dev/null +++ b/trunk/source/Library-Proofs/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/trunk/source/Library-Proofs/.project b/trunk/source/Library-Proofs/.project new file mode 100644 index 00000000000..2cc7d65e15a --- /dev/null +++ b/trunk/source/Library-Proofs/.project @@ -0,0 +1,33 @@ + + + Library-Proofs + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + org.sonarlint.eclipse.core.sonarlintBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + + diff --git a/trunk/source/Library-Proofs/LicenseTemplate.md b/trunk/source/Library-Proofs/LicenseTemplate.md new file mode 100644 index 00000000000..bc7a02ea665 --- /dev/null +++ b/trunk/source/Library-Proofs/LicenseTemplate.md @@ -0,0 +1,23 @@ +Copyright (C) @{daterange} @{author:r} + +This file is part of the ULTIMATE Proofs Library. + +The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published +by the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +The ULTIMATE Proofs Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with the ULTIMATE Proofs Library. If not, see . + +Additional permission under GNU GPL version 3 section 7: +If you modify the ULTIMATE Proofs Library, or any covered work, by linking +or combining it with Eclipse RCP (or a modified version of Eclipse RCP), +containing parts covered by the terms of the Eclipse Public License, the +licensors of the ULTIMATE Proofs Library grant you additional permission +to convey the resulting work. diff --git a/trunk/source/Library-Proofs/META-INF/MANIFEST.MF b/trunk/source/Library-Proofs/META-INF/MANIFEST.MF new file mode 100644 index 00000000000..76c3a78733b --- /dev/null +++ b/trunk/source/Library-Proofs/META-INF/MANIFEST.MF @@ -0,0 +1,17 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: Library-Proofs +Bundle-SymbolicName: de.uni_freiburg.informatik.ultimate.lib.proofs +Bundle-Version: 0.2.4 +Bundle-RequiredExecutionEnvironment: JavaSE-11 +Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, + de.uni_freiburg.informatik.ultimate.lib.smtlib, + de.uni_freiburg.informatik.ultimate.lib.automata, + de.uni_freiburg.informatik.ultimate.smtinterpol, + de.uni_freiburg.informatik.ultimate.lib.smtlibutils, + de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils, + de.uni_freiburg.informatik.ultimate.lib.util +Export-Package: + de.uni_freiburg.informatik.ultimate.lib.proofs, + de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare +Automatic-Module-Name: de.uni.freiburg.informatik.ultimate.lib.proofs diff --git a/trunk/source/Library-Proofs/build.properties b/trunk/source/Library-Proofs/build.properties new file mode 100644 index 00000000000..34d2e4d2dad --- /dev/null +++ b/trunk/source/Library-Proofs/build.properties @@ -0,0 +1,4 @@ +source.. = src/ +output.. = bin/ +bin.includes = META-INF/,\ + . diff --git a/trunk/source/Library-Proofs/pom.xml b/trunk/source/Library-Proofs/pom.xml new file mode 100644 index 00000000000..3e2fd81b2b2 --- /dev/null +++ b/trunk/source/Library-Proofs/pom.xml @@ -0,0 +1,41 @@ + + + 4.0.0 + + + mavenparent + de.uni_freiburg.informatik.ultimate + 0.2.4 + ../BA_MavenParentUltimate/pom.xml + + + de.uni_freiburg.informatik.ultimate.lib.proofs + 0.2.4 + eclipse-plugin + diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IFinishWithFinalAbstraction.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IFinishWithFinalAbstraction.java similarity index 60% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IFinishWithFinalAbstraction.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IFinishWithFinalAbstraction.java index 50187352632..b3c35461b3d 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IFinishWithFinalAbstraction.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IFinishWithFinalAbstraction.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; +package de.uni_freiburg.informatik.ultimate.lib.proofs; public interface IFinishWithFinalAbstraction { void finish(A finalAbstraction); diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnDifference.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IUpdateOnDifference.java similarity index 72% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnDifference.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IUpdateOnDifference.java index 1c549eb8681..aadb03a0264 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnDifference.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IUpdateOnDifference.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; +package de.uni_freiburg.informatik.ultimate.lib.proofs; import java.util.Map; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnMinimization.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IUpdateOnMinimization.java similarity index 67% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnMinimization.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IUpdateOnMinimization.java index 16231f16848..dd7410661b9 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/proofs/IUpdateOnMinimization.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IUpdateOnMinimization.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs; +package de.uni_freiburg.informatik.ultimate.lib.proofs; import java.util.Map; diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/Proofs.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/Proofs.java new file mode 100644 index 00000000000..e632d40ca7e --- /dev/null +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/Proofs.java @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE Proofs Library. + * + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE Proofs Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE Proofs Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.proofs; + +/** + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + */ +public class Proofs { + public static final String PLUGIN_ID = Proofs.class.getPackage().getName(); + + public static final String PLUGIN_NAME = "Proofs"; +} diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareForInterpolantAutomaton.java similarity index 74% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareForInterpolantAutomaton.java index be16a16390f..055c986135f 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareForInterpolantAutomaton.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareForInterpolantAutomaton.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareMapping.java similarity index 80% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareMapping.java index dc99cf3bdf7..ac7195d63b4 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareMapping.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareMapping.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.Map; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareValidityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareValidityCheck.java similarity index 94% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareValidityCheck.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareValidityCheck.java index 4af18dfa48c..f67609e7f7b 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/FloydHoareValidityCheck.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareValidityCheck.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.ArrayDeque; import java.util.HashSet; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationComposer.java similarity index 94% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationComposer.java index b23d721d5ce..d6d64e060f0 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationComposer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationComposer.java @@ -3,29 +3,29 @@ * Copyright (C) 2014-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2015 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.ArrayList; import java.util.HashMap; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationExtractor.java similarity index 88% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationExtractor.java index ee6c877b33f..98c827b6151 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationExtractor.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationExtractor.java @@ -3,29 +3,29 @@ * Copyright (C) 2011-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2015 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.ArrayList; import java.util.Collection; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationFragments.java similarity index 92% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationFragments.java index 86eb79be8ae..410ae389af6 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationFragments.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationFragments.java @@ -3,29 +3,29 @@ * Copyright (C) 2012-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2015 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.ArrayList; import java.util.Collections; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationPositions.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationPositions.java similarity index 78% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationPositions.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationPositions.java index 2bdeba27e39..ef01f57d368 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationPositions.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationPositions.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.HashSet; import java.util.Map; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsDefinitions.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsDefinitions.java similarity index 83% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsDefinitions.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsDefinitions.java index b82b9dfad49..edaf99b855d 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsDefinitions.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsDefinitions.java @@ -2,29 +2,29 @@ * Copyright (C) 2016 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2016 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.function.Function; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsGenerator.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsGenerator.java similarity index 84% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsGenerator.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsGenerator.java index ae3299c5d76..4b14e583561 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsGenerator.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsGenerator.java @@ -2,29 +2,29 @@ * Copyright (C) 2016 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2016 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.Collection; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsType.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsType.java similarity index 66% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsType.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsType.java index 1df0c5a9bfc..62ba6ca2bad 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/HoareAnnotationStatisticsType.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareAnnotationStatisticsType.java @@ -2,29 +2,29 @@ * Copyright (C) 2016 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * Copyright (C) 2016 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import de.uni_freiburg.informatik.ultimate.util.statistics.StatisticsType; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareProofSettings.java similarity index 74% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareProofSettings.java index b94471a335b..a1b6af5aeac 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/HoareProofSettings.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/HoareProofSettings.java @@ -2,33 +2,32 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationPositions; public class HoareProofSettings { private final HoareAnnotationPositions mHoarePositions; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IFloydHoareAnnotation.java similarity index 63% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IFloydHoareAnnotation.java index d171ca7793b..1a48549825e 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IFloydHoareAnnotation.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IFloydHoareAnnotation.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgAnnotationFromAutomaton.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgAnnotationFromAutomaton.java similarity index 83% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgAnnotationFromAutomaton.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgAnnotationFromAutomaton.java index 2c99b33ba02..a011f8fedd5 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgAnnotationFromAutomaton.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgAnnotationFromAutomaton.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.HashMap; import java.util.Set; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java similarity index 90% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java index 87446ba4c37..31152697895 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/IcfgFloydHoareValidityCheck.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.Set; import java.util.stream.Collectors; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaFloydHoareValidityCheck.java similarity index 88% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaFloydHoareValidityCheck.java index e3ec5611e6d..2faed0f45a5 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/floydhoare/NwaFloydHoareValidityCheck.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaFloydHoareValidityCheck.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.nestedword.transitions.IOutgoingTransitionlet; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java similarity index 84% rename from trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index f5e4c149431..329a44b2121 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -2,29 +2,29 @@ * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * Copyright (C) 2023 University of Freiburg * - * This file is part of the ULTIMATE TraceCheckerUtils Library. + * This file is part of the ULTIMATE Proofs Library. * - * The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * - * The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceCheckerUtils Library. If not, see . + * along with the ULTIMATE Proofs Library. If not, see . * * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission + * licensors of the ULTIMATE Proofs Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction; +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; import java.util.Map; import java.util.Set; @@ -42,19 +42,15 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationComposer; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationExtractor; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.HoareAnnotationFragments; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare.IFloydHoareAnnotation; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnDifference; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs.IUpdateOnMinimization; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.KeyType; import de.uni_freiburg.informatik.ultimate.util.statistics.TimeTracker; -final class NwaHoareProofProducer +public final class NwaHoareProofProducer implements IProofProducer, IUpdateOnMinimization, IUpdateOnDifference, IFinishWithFinalAbstraction> { diff --git a/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF b/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF index 60078302bf7..081af8065ab 100644 --- a/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF +++ b/trunk/source/Library-TraceCheckerUtils/META-INF/MANIFEST.MF @@ -7,20 +7,19 @@ Bundle-RequiredExecutionEnvironment: JavaSE-11 Export-Package: de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton, - de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.floydhoare, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.abstraction, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.predicates, - de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.proofs, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.lib.smtlib, de.uni_freiburg.informatik.ultimate.lib.automata, de.uni_freiburg.informatik.ultimate.lib.smtlibutils, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils, + de.uni_freiburg.informatik.ultimate.lib.proofs, de.uni_freiburg.informatik.ultimate.lib.util, de.uni_freiburg.informatik.ultimate.smtinterpol, de.uni_freiburg.informatik.ultimate.smtsolver.external, diff --git a/trunk/source/Library-TraceCheckerUtils/pom.xml b/trunk/source/Library-TraceCheckerUtils/pom.xml index 4d77aca49e1..68e67a2f30c 100644 --- a/trunk/source/Library-TraceCheckerUtils/pom.xml +++ b/trunk/source/Library-TraceCheckerUtils/pom.xml @@ -2,26 +2,26 @@ Copyright (C) 2012-2015 Evren Ermis Copyright (C) 2015 University of Freiburg - This file is part of the ULTIMATE ModelCheckerUtils Library. + This file is part of the ULTIMATE TraceCheckerUtils Library. - The ULTIMATE ModelCheckerUtils Library is free software: you can redistribute it and/or modify + The ULTIMATE TraceCheckerUtils Library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - The ULTIMATE ModelCheckerUtils Library is distributed in the hope that it will be useful, + The ULTIMATE TraceCheckerUtils Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License - along with the ULTIMATE ModelCheckerUtils Library. If not, see . + along with the ULTIMATE TraceCheckerUtils Library. If not, see . Additional permission under GNU GPL version 3 section 7: - If you modify the ULTIMATE ModelCheckerUtils Library, or any covered work, by linking + If you modify the ULTIMATE TraceCheckerUtils Library, or any covered work, by linking or combining it with Eclipse RCP (or a modified version of Eclipse RCP), containing parts covered by the terms of the Eclipse Public License, the - licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission + licensors of the ULTIMATE TraceCheckerUtils Library grant you additional permission to convey the resulting work. --> Date: Sun, 17 Dec 2023 13:43:53 +0100 Subject: [PATCH 32/91] fix NPE --- .../PetriLbeInitialAbstractionProvider.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java index ed950c911e3..3955cea34d8 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/PetriLbeInitialAbstractionProvider.java @@ -59,7 +59,7 @@ public class PetriLbeInitialAbstractionProvider> private final Class mTransitionClazz; private final IndependenceSettings mIndependenceSettings; - private final Statistics mStatistics = new Statistics(); + private final Statistics mStatistics; /** * Create a new instance. @@ -86,6 +86,8 @@ public PetriLbeInitialAbstractionProvider( mTransitionClazz = transitionClazz; mIndependenceSettings = independenceSettings; mCompositionFactory = compositionFactory; + + mStatistics = new Statistics(); } @Override From 2bbf6a2cb3a834f4129bb44937298117a6080ce1 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 17 Dec 2023 19:36:13 +0100 Subject: [PATCH 33/91] move more code to proofs plugin --- trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF | 1 - .../informatik/ultimate/lib}/proofs/IProofConverter.java | 2 +- .../informatik/ultimate/lib}/proofs/IProofPostProcessor.java | 2 +- .../informatik/ultimate/lib}/proofs/IProofProducer.java | 2 +- .../ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java | 4 ++-- .../initialabstraction/IInitialAbstractionProvider.java | 2 +- .../initialabstraction/NwaInitialAbstractionProvider.java | 4 ++-- 7 files changed, 8 insertions(+), 9 deletions(-) rename trunk/source/{Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib}/proofs/IProofConverter.java (97%) rename trunk/source/{Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib}/proofs/IProofPostProcessor.java (98%) rename trunk/source/{Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils => Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib}/proofs/IProofProducer.java (98%) diff --git a/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF b/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF index 11f8e473f0d..5c3db1340b6 100644 --- a/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF +++ b/trunk/source/Library-ModelCheckerUtils/META-INF/MANIFEST.MF @@ -16,7 +16,6 @@ Export-Package: de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.dangerinvariants, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple, - de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.biesenb, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.equalityanalysis, diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofConverter.java similarity index 97% rename from trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofConverter.java index b6fa6c57a88..8b3efeac8bf 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofConverter.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofConverter.java @@ -24,7 +24,7 @@ * licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs; +package de.uni_freiburg.informatik.ultimate.lib.proofs; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofPostProcessor.java similarity index 98% rename from trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofPostProcessor.java index ced5310c233..ebaa235c04e 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofPostProcessor.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofPostProcessor.java @@ -24,7 +24,7 @@ * licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs; +package de.uni_freiburg.informatik.ultimate.lib.proofs; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java similarity index 98% rename from trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofProducer.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java index 44e1cd1707a..a8e4f537ff8 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/proofs/IProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java @@ -24,7 +24,7 @@ * licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission * to convey the resulting work. */ -package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs; +package de.uni_freiburg.informatik.ultimate.lib.proofs; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index 329a44b2121..ba4106e134c 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -38,11 +38,11 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofPostProcessor; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java index df06f0e0f19..03dd1eff6d2 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java @@ -33,8 +33,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index 2af037692bc..90f43cdcc45 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -35,10 +35,10 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofConverter; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofConverter; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.HoareProofSettings; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IFloydHoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; From 92aeb31c8fb502b1d04ea3c1d48604b47c35f59c Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 17 Dec 2023 19:37:00 +0100 Subject: [PATCH 34/91] compute Hoare states from preferences --- .../lib/proofs/floydhoare/NwaHoareProofProducer.java | 11 +++++++++++ .../NwaInitialAbstractionProvider.java | 8 +------- .../generator/traceabstraction/CegarLoopFactory.java | 2 ++ 3 files changed, 14 insertions(+), 7 deletions(-) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index ba4106e134c..c1ad82a2e29 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -29,6 +29,7 @@ import java.util.Map; import java.util.Set; import java.util.function.Supplier; +import java.util.stream.Collectors; import de.uni_freiburg.informatik.ultimate.automata.nestedword.IDoubleDeckerAutomaton; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; @@ -38,8 +39,11 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IAction; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; @@ -98,6 +102,13 @@ private NwaHoareProofProducer(final IUltimateServiceProvider services, IProofPostProcessor.identity(program)); } + public static Set computeHoareStates(final IIcfg icfg, + final INestedWordAutomaton abstraction, final HoareAnnotationPositions hoarePositions) { + final var hoareLocs = hoarePositions.getLocations(icfg); + return abstraction.getStates().stream() + .filter(p -> PredicateUtils.getLocations(p).anyMatch(hoareLocs::contains)).collect(Collectors.toSet()); + } + @Override public PROGRAM getProgram() { return mPost.getOriginalProgram(); diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index 90f43cdcc45..1c360096421 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -89,18 +89,12 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg computeHoareStates(final IIcfg icfg, - final INestedWordAutomaton abstraction) { - // TODO Auto-generated method stub - return null; - } - @Override public IProofProducer, PROOF> getProofProducer(final Class proofType, final Class proofUpdates) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 110bae5c2a0..f1c83b69dc5 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -349,6 +349,8 @@ private > A constructInitialAbstraction( } } + // TODO #proofRefactor superseded by NwaHoareProofProducer::computeHoareStates + @Deprecated private static Set hoareAnnotationStates(final Set hoareAnnotationLocs, final INestedWordAutomaton initialAbstraction) { return initialAbstraction.getStates().stream() From 6f6212acea94c3de69896cfd8b045959257d03a7 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 17 Dec 2023 19:37:12 +0100 Subject: [PATCH 35/91] some doc comments --- .../floydhoare/NwaHoareProofProducer.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index c1ad82a2e29..9404a5f69b6 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -54,6 +54,20 @@ import de.uni_freiburg.informatik.ultimate.util.statistics.KeyType; import de.uni_freiburg.informatik.ultimate.util.statistics.TimeTracker; +/** + * Produces a Floyd/Hoare annotation for a nested-word automaton. + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + * @param + * The type of letters in the program automaton + * @param + * The type of program for which a proof is produced. By default, this is {@link INestedWordAutomaton}, but + * it may differ if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. + * @param + * The type of proof which is produced. By default, this is {@link IFloydHoareAnnotation}, but it may differ + * if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. + */ public final class NwaHoareProofProducer implements IProofProducer, IUpdateOnMinimization, IUpdateOnDifference, IFinishWithFinalAbstraction> { @@ -93,6 +107,21 @@ private NwaHoareProofProducer(final IUltimateServiceProvider services, assert postProcessor.getOriginalProgram() == mProgram; } + /** + * Creates a new proof producer without any postprocessing. + * + * @param + * the type of letters in the program automaton for which a proof is produced + * @param services + * @param program + * @param csToolkit + * @param predicateFactory + * @param prefs + * @param hoareAnnotationStates + * The states for which a Hoare annotation shall be produced. This can be a subset of the program + * automaton's states. + * @return + */ public static NwaHoareProofProducer, IFloydHoareAnnotation> create(final IUltimateServiceProvider services, final INestedWordAutomaton program, From 646c763e46c9ba101d141f49802b71c50dfc842e Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 17 Dec 2023 20:16:35 +0100 Subject: [PATCH 36/91] add new base class for proof producers --- .../lib/proofs/AbstractProofProducer.java | 80 +++++++++++++++++++ .../floydhoare/NwaHoareProofProducer.java | 65 ++++++--------- 2 files changed, 105 insertions(+), 40 deletions(-) create mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java new file mode 100644 index 00000000000..e022a2df587 --- /dev/null +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE Proofs Library. + * + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE Proofs Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE Proofs Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.proofs; + +/** + * Base class for implementations of {@link IProofProducer}. + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + * @param + * The type of abstraction for which a proof shall be produced (see {@link IProofProducer}). + * @param

+ * The type of proof that shall be produced (see {@link IProofProducer}). + * @param + * The type of abstraction natively supported by the class that inherits from {@link AbstractProofProducer}. + * Proofs for other kinds of abstractions can be computed by post-processing. + * @param + * The type of proof natively supported by the class that inherits from {@link AbstractProofProducer}. Proofs + * of other kinds can be computed by post-processing. + */ +public abstract class AbstractProofProducer implements IProofProducer { + protected final A0 mProgram; + protected final IProofPostProcessor mPost; + + private P0 mInternalProof; + private P mProof; + + protected AbstractProofProducer(final A0 program, final IProofPostProcessor post) { + mProgram = program; + mPost = post; + + assert post.getTransformedProgram() == mProgram : "proof post processor program does not match"; + } + + @Override + public final A getProgram() { + return mPost.getOriginalProgram(); + } + + @Override + public final P getOrComputeProof() { + if (mProof == null) { + mProof = mPost.processProof(getOrComputeInternalProof()); + } + return mProof; + } + + protected final P0 getOrComputeInternalProof() { + if (mInternalProof == null) { + mInternalProof = computeProof(); + } + return mInternalProof; + } + + protected abstract P0 computeProof(); +} diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index 9404a5f69b6..5aa42ea2313 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -44,9 +44,9 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; +import de.uni_freiburg.informatik.ultimate.lib.proofs.AbstractProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; @@ -61,50 +61,45 @@ * * @param * The type of letters in the program automaton - * @param - * The type of program for which a proof is produced. By default, this is {@link INestedWordAutomaton}, but - * it may differ if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. - * @param + * @param + * The type of abstraction for which a proof is produced. By default, this is {@link INestedWordAutomaton}, + * but it may differ if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. + * @param

* The type of proof which is produced. By default, this is {@link IFloydHoareAnnotation}, but it may differ * if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. */ -public final class NwaHoareProofProducer - implements IProofProducer, IUpdateOnMinimization, IUpdateOnDifference, +public final class NwaHoareProofProducer + extends AbstractProofProducer, IFloydHoareAnnotation> + implements IUpdateOnMinimization, IUpdateOnDifference, IFinishWithFinalAbstraction> { private final IUltimateServiceProvider mServices; - - private final INestedWordAutomaton mProgram; private final CfgSmtToolkit mCsToolkit; private final PredicateFactory mPredicateFactory; private final HoareProofSettings mPrefs; private final Set mHoareAnnotationStates; - private final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> mPost; - private final HoareAnnotationFragments mHaf; private INestedWordAutomaton mFinalAbstraction; - - private PROOF mProof; - private final Statistics mStatistics = new Statistics(); + private final Statistics mStatistics; private NwaHoareProofProducer(final IUltimateServiceProvider services, final INestedWordAutomaton program, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final HoareProofSettings prefs, final Set hoareAnnotationStates, - final IProofPostProcessor, IFloydHoareAnnotation, PROGRAM, PROOF> postProcessor) { + final IProofPostProcessor, IFloydHoareAnnotation, A, P> postProcessor) { + super(program, postProcessor); + mServices = services; - mProgram = program; mCsToolkit = csToolkit; mPredicateFactory = predicateFactory; mPrefs = prefs; mHoareAnnotationStates = hoareAnnotationStates; mHaf = new HoareAnnotationFragments<>(services.getLoggingService().getLogger(getClass()), hoareAnnotationStates); - mPost = postProcessor; - assert postProcessor.getOriginalProgram() == mProgram; + mStatistics = new Statistics(mPost); } /** @@ -138,29 +133,19 @@ public static Set computeHoareStates(final IIcfg PredicateUtils.getLocations(p).anyMatch(hoareLocs::contains)).collect(Collectors.toSet()); } - @Override - public PROGRAM getProgram() { - return mPost.getOriginalProgram(); - } - @Override public boolean hasProof() { return mFinalAbstraction != null; } @Override - public PROOF getOrComputeProof() { - if (mProof == null) { - mProof = mStatistics.measureProofComputation(this::computeProof); - } - return mProof; - } - - private PROOF computeProof() { - final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); - final var floydHoare = clha.extractAnnotation(); - mStatistics.reportHoareStatistics(clha); - return mPost.processProof(floydHoare); + protected IFloydHoareAnnotation computeProof() { + return mStatistics.measureProofComputation(() -> { + final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); + final var floydHoare = clha.extractAnnotation(); + mStatistics.reportHoareStatistics(clha); + return floydHoare; + }); } private HoareAnnotationComposer computeHoareAnnotationComposer() { @@ -173,8 +158,8 @@ private HoareAnnotationComposer computeHoareAnnotationComposer() { } @Override - public NwaHoareProofProducer - withPostProcessor(final IProofPostProcessor postProcessor) { + public NwaHoareProofProducer + withPostProcessor(final IProofPostProcessor postProcessor) { return new NwaHoareProofProducer<>(mServices, mProgram, mCsToolkit, mPredicateFactory, mPrefs, mHoareAnnotationStates, IProofPostProcessor.compose(mPost, postProcessor)); } @@ -212,12 +197,12 @@ public void finish(final INestedWordAutomaton finalAbstraction) { mFinalAbstraction = finalAbstraction; } - private final class Statistics extends AbstractStatisticsDataProvider { + private static final class Statistics extends AbstractStatisticsDataProvider { private final TimeTracker mProofTime = new TimeTracker(); - public Statistics() { + public Statistics(final IProofPostProcessor post) { declare("Hoare annotation time", () -> mProofTime, KeyType.TT_TIMER); - forward("Postprocessor statistics", mPost::getStatistics); + forward("Postprocessor statistics", post::getStatistics); } private T measureProofComputation(final Supplier computation) { From d48c12e9c9a89dc44bdd66ca50287ed3b088951f Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 17 Dec 2023 20:17:58 +0100 Subject: [PATCH 37/91] better method name --- .../informatik/ultimate/lib/proofs/IProofProducer.java | 7 ++++--- .../lib/proofs/floydhoare/NwaHoareProofProducer.java | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java index a8e4f537ff8..761e92329d3 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java @@ -35,8 +35,9 @@ * provided to the constructor. * * Beyond that, proof producers are typically stateful and may gather information necessary to compute a proof, e.g. - * during verification of the program. The method {@link #hasProof()} can be used to determine if all information to - * compute a proof has been collected. If so, invoking {@link #getOrComputeProof()} should produce the desired proof. + * during verification of the program. The method {@link #isReadyToComputeProof()} can be used to determine if all + * information to compute a proof has been collected. If so, invoking {@link #getOrComputeProof()} should produce the + * desired proof. * * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * @@ -58,7 +59,7 @@ public interface IProofProducer { * * @return true if a call to {@link #getOrComputeProof()} will succeed, false otherwise. */ - boolean hasProof(); + boolean isReadyToComputeProof(); /** * Attempts to compute the proof artifact. If successful, the artifact must be cached and returned again on diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index 5aa42ea2313..643780995f8 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -134,7 +134,7 @@ public static Set computeHoareStates(final IIcfg Date: Mon, 18 Dec 2023 09:56:30 +0100 Subject: [PATCH 38/91] add check to AbstractProofProducer --- .../informatik/ultimate/lib/proofs/AbstractProofProducer.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java index e022a2df587..f053200b03a 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java @@ -71,6 +71,9 @@ public final P getOrComputeProof() { protected final P0 getOrComputeInternalProof() { if (mInternalProof == null) { + if (!isReadyToComputeProof()) { + throw new UnsupportedOperationException(getClass().getSimpleName() + " not yet ready to compute proof"); + } mInternalProof = computeProof(); } return mInternalProof; From a7c5404ee28408f0967e6f3c0cb39025f42a7134 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Wed, 20 Dec 2023 14:18:44 +0100 Subject: [PATCH 39/91] remove no longer needed dependency --- trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF | 1 - 1 file changed, 1 deletion(-) diff --git a/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF b/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF index 2f80473226c..be97fecc287 100644 --- a/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF +++ b/trunk/source/InvariantSynthesis/META-INF/MANIFEST.MF @@ -11,7 +11,6 @@ Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.lib.boogieast, de.uni_freiburg.informatik.ultimate.core, de.uni_freiburg.informatik.ultimate.lib.automata, - de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils, de.uni_freiburg.informatik.ultimate.smtinterpol, de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder, de.uni_freiburg.informatik.ultimate.smtsolver.external, From 177732a3c9d068519a2a654f780acb61a0cd8df0 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Wed, 20 Dec 2023 14:27:22 +0100 Subject: [PATCH 40/91] remove unused method --- .../petrinet/operations/PetriNet2FiniteAutomaton.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java b/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java index 284243f73c2..12eea4d10e0 100644 --- a/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java +++ b/trunk/source/Library-Automata/src/de/uni_freiburg/informatik/ultimate/automata/petrinet/operations/PetriNet2FiniteAutomaton.java @@ -208,10 +208,6 @@ public INestedWordAutomaton getResult() { return mResult; } - public Map, PLACE> getStateMap() { - return mMarking2State; - } - @Override public boolean checkResult(final IStateFactory stateFactory) throws AutomataLibraryException { return true; From ed90216339bb08b87c6bad283cb3dfc5a709b616 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Wed, 20 Dec 2023 14:54:30 +0100 Subject: [PATCH 41/91] remove now obsolete (and unused) parameter from CEGAR loops --- .../traceabstraction/CegarLoopFactory.java | 26 ++++--------------- .../CegarLoopSWBnonRecursive.java | 8 +++--- .../traceabstraction/EagerReuseCegarLoop.java | 7 +++-- .../IncrementalInclusionCegarLoop.java | 8 +++--- .../traceabstraction/LazyReuseCegarLoop.java | 7 +++-- .../traceabstraction/NwaCegarLoop.java | 4 +-- .../traceabstraction/ReuseCegarLoop.java | 5 ++-- .../CegarLoopConcurrentAutomata.java | 5 ++-- 8 files changed, 23 insertions(+), 47 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index f1c83b69dc5..d406c09fcdf 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -32,7 +32,6 @@ import java.util.List; import java.util.Set; import java.util.function.Supplier; -import java.util.stream.Collectors; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryException; import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryServices; @@ -54,7 +53,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.IInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.NwaInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.PartialOrderAbstractionProvider; @@ -145,8 +143,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr stateFactoryForRefinement, witnessAutomaton); // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new IncrementalInclusionCegarLoop<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, - hoareAnnotationStates(hoareAnnotationLocs, abstraction), services, languageOperation, + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, languageOperation, mTransitionClazz, stateFactoryForRefinement); } @@ -155,8 +152,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr stateFactoryForRefinement, witnessAutomaton); // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new CegarLoopSWBnonRecursive<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, - hoareAnnotationStates(hoareAnnotationLocs, abstraction), services, mTransitionClazz, + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); } @@ -224,18 +220,15 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService switch (mPrefs.getFloydHoareAutomataReuse()) { case EAGER: return new EagerReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, - hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, Collections.emptyList(), + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case LAZY_IN_ORDER: return new LazyReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, - hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, Collections.emptyList(), + errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case NONE: return new NwaCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, errorLocs, - mPrefs.interpolation(), null, mComputeHoareAnnotation, - hoareAnnotationStates(hoareAnnotationLocs, initialAbstraction), services, mTransitionClazz, + mPrefs.interpolation(), null, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); default: throw new AssertionError("Unknown Setting: " + mPrefs.getFloydHoareAutomataReuse()); @@ -349,15 +342,6 @@ private > A constructInitialAbstraction( } } - // TODO #proofRefactor superseded by NwaHoareProofProducer::computeHoareStates - @Deprecated - private static Set hoareAnnotationStates(final Set hoareAnnotationLocs, - final INestedWordAutomaton initialAbstraction) { - return initialAbstraction.getStates().stream() - .filter(p -> PredicateUtils.getLocations(p).anyMatch(hoareAnnotationLocs::contains)) - .collect(Collectors.toSet()); - } - public CegarLoopStatisticsGenerator getStatistics() { return mCegarLoopBenchmark; } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 15ac82586bc..5b1b3dd8b68 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -175,12 +175,10 @@ public & IUpdateOnMinimization & IFinishWit final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg icfg, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, - final T proofUpdater, final boolean computeHoareAnnotation, final Set hoareAnnotationStates, - final IUltimateServiceProvider services, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { + final T proofUpdater, final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, - stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mErrorPathHistory = new ArrayList<>(); mnofStates = new ArrayList<>(); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index 933e6ada7dd..4266f664b42 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -82,14 +82,13 @@ public & IUpdateOnMinimization & IFinishWit final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, - floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFile, transitionClazz, - stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, + rawFloydHoareAutomataFromFile, transitionClazz, stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index dd66fd8e418..769490d90ec 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -88,12 +88,10 @@ public & IUpdateOnMinimization & IFinishWit final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, - final LanguageOperation languageOperation, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { + final IUltimateServiceProvider services, final LanguageOperation languageOperation, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, - stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mLanguageOperation = languageOperation; if (proofUpdater != null) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index 7946c32c130..75f8706ef15 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -81,14 +81,13 @@ public & IUpdateOnMinimization & IFinishWit final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFiles, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, - floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFiles, transitionClazz, - stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, + rawFloydHoareAutomataFromFiles, transitionClazz, stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 8972e63331d..da3291b2abb 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -143,8 +143,8 @@ public & IUpdateOnMinimization & IFinishWit final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, - final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + final IUltimateServiceProvider services, final Class transitionClazz, + final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mProofUpdater = proofUpdater == null ? null : new ProofUpdater<>(proofUpdater); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java index 67d6ad3a143..196b4ede3c1 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java @@ -113,13 +113,12 @@ public & IUpdateOnMinimization & IFinishWit final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final Set hoareAnnotationStates, final IUltimateServiceProvider services, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, hoareAnnotationStates, services, transitionClazz, - stateFactoryForRefinement); + proofUpdater, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mFloydHoareAutomataFromOtherErrorLocations = floydHoareAutomataFromOtherLocations; mRawFloydHoareAutomataFromFile = rawFloydHoareAutomataFromFile; mFloydHoareAutomataFromFile = new ArrayList<>(); diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 190d4956cba..633a223ca06 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -28,7 +28,6 @@ package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstractionconcurrent; import java.util.Arrays; -import java.util.Collections; import java.util.HashSet; import java.util.Map; import java.util.Set; @@ -79,8 +78,8 @@ public CegarLoopConcurrentAutomata(final DebugIdentifier name, final IIcfg ro final Set errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, createInitialAbstraction(services, csToolkit, predicateFactory, taPrefs, rootNode), rootNode, - csToolkit, predicateFactory, taPrefs, errorLocs, taPrefs.interpolation(), null, false, - Collections.emptySet(), services, transitionClazz, stateFactoryForRefinement); + csToolkit, predicateFactory, taPrefs, errorLocs, taPrefs.interpolation(), null, false, services, + transitionClazz, stateFactoryForRefinement); } private static > INestedWordAutomaton createInitialAbstraction( From 50509a4b73e6357c8a4acdb88067f8df90a751df Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 21 Dec 2023 12:16:39 +0100 Subject: [PATCH 42/91] generalize IcfgAnnotationFromAutomaton to TransformFloydHoareAnnotation & document --- .../IcfgAnnotationFromAutomaton.java | 86 ------------- .../TransformFloydHoareAnnotation.java | 118 ++++++++++++++++++ 2 files changed, 118 insertions(+), 86 deletions(-) delete mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgAnnotationFromAutomaton.java create mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/TransformFloydHoareAnnotation.java diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgAnnotationFromAutomaton.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgAnnotationFromAutomaton.java deleted file mode 100644 index a011f8fedd5..00000000000 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgAnnotationFromAutomaton.java +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) - * Copyright (C) 2023 University of Freiburg - * - * This file is part of the ULTIMATE Proofs Library. - * - * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE Proofs Library. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE Proofs Library, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE Proofs Library grant you additional permission - * to convey the resulting work. - */ -package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; - -import java.util.HashMap; -import java.util.Set; -import java.util.function.Function; - -import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; - -public class IcfgAnnotationFromAutomaton { - private final Function mGetProgramPoint; - private final IFloydHoareAnnotation mResult; - - public IcfgAnnotationFromAutomaton(final IFloydHoareAnnotation annotation, final Set states, - final Function getProgramPoint) { - mGetProgramPoint = getProgramPoint; - mResult = extractAnnotation(annotation, states); - } - - public static IcfgAnnotationFromAutomaton - create(final IFloydHoareAnnotation automatonAnnotation, final Set states) { - return new IcfgAnnotationFromAutomaton<>(automatonAnnotation, states, PredicateUtils::getLocation); - } - - public static IcfgAnnotationFromAutomaton - create(final IFloydHoareAnnotation automatonAnnotation, final INestedWordAutomaton automaton) { - return new IcfgAnnotationFromAutomaton<>(automatonAnnotation, automaton.getStates(), - PredicateUtils::getLocation); - } - - private IFloydHoareAnnotation extractAnnotation(final IFloydHoareAnnotation annotation, - final Set states) { - final var result = new HashMap(); - - for (final var state : states) { - final IPredicate pred = annotation.getAnnotation(state); - if (pred == null) { - // there is no annotation for this state - continue; - } - - final var loc = mGetProgramPoint.apply(state); - - final var annot = result.get(loc); - if (annot != null) { - // TODO add the invariant, don't overwrite the old one - } - - result.put(loc, pred); - } - - return new FloydHoareMapping<>(annotation.getPrecondition(), annotation.getPostcondition(), result); - } - - public IFloydHoareAnnotation getResult() { - return mResult; - } -} diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/TransformFloydHoareAnnotation.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/TransformFloydHoareAnnotation.java new file mode 100644 index 00000000000..811fac32b30 --- /dev/null +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/TransformFloydHoareAnnotation.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE Proofs Library. + * + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE Proofs Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE Proofs Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; + +import java.util.HashMap; +import java.util.Set; +import java.util.function.Function; + +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; + +/** + * Transforms a Floyd-Hoare annotation by applying a function to every state. + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * + * @param + * The type of states of the given Floyd-Hoare annotation + * @param + * The type of states of the transformed Floyd-Hoare annotation + */ +public class TransformFloydHoareAnnotation { + private final Function mTransformer; + private final IFloydHoareAnnotation mResult; + + /** + * Creates a new instance and transforms a given annotation + * + * @param annotation + * The input annotation to be transformed + * @param states + * The set of all states/locations to be transformed. Annotations for any state not included in this set + * will be dropped. + * @param transformer + * The function to be applied to each state (which must be injective) + */ + public TransformFloydHoareAnnotation(final IFloydHoareAnnotation annotation, final Set states, + final Function transformer) { + mTransformer = transformer; + mResult = extractAnnotation(annotation, states); + } + + private static TransformFloydHoareAnnotation + predicateToIcfgLocation(final IFloydHoareAnnotation automatonAnnotation, final Set states) { + return new TransformFloydHoareAnnotation<>(automatonAnnotation, states, PredicateUtils::getLocation); + } + + /** + * Constructs a Floyd-Hoare annotation for a sequential ICFG from a Floyd-Hoare annotation for the corresponding + * nested-word automaton. + * + * @param + * The type of automaton states. In practice, all states must implement {@link ISLPredicate}. + * @param automatonAnnotation + * The Floyd-Hoare annotation of the nested-word automaton + * @param automaton + * The nested-word automaton + * @return a Floyd-Hoare annotation for the ICFG + */ + public static IFloydHoareAnnotation + nwaToIcfg(final IFloydHoareAnnotation automatonAnnotation, final INestedWordAutomaton automaton) { + return predicateToIcfgLocation(automatonAnnotation, automaton.getStates()).getResult(); + } + + private IFloydHoareAnnotation extractAnnotation(final IFloydHoareAnnotation annotation, + final Set states) { + final var result = new HashMap(); + + for (final S1 state : states) { + final IPredicate pred = annotation.getAnnotation(state); + if (pred == null) { + // there is no annotation for this state + continue; + } + + final var transformed = mTransformer.apply(state); + final var annot = result.get(transformed); + if (annot != null) { + throw new IllegalStateException( + "two different annotations for " + transformed + ": " + annot + " and " + pred); + } + + result.put(transformed, pred); + } + return new FloydHoareMapping<>(annotation.getPrecondition(), annotation.getPostcondition(), result); + } + + public IFloydHoareAnnotation getResult() { + return mResult; + } +} From ffa4bff6eeba2f4f4f80e91459b6445ce3b517f4 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 21 Dec 2023 12:17:42 +0100 Subject: [PATCH 43/91] move printing of Floyd-Hoare annotations to a central location --- .../InvariantSynthesisStarter.java | 39 +-------- .../proofs/floydhoare/FloydHoareUtils.java | 79 +++++++++++++++++++ .../traceabstraction/AbstractCegarLoop.java | 54 ------------- 3 files changed, 82 insertions(+), 90 deletions(-) create mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java diff --git a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java index 658e9d22462..29adc272326 100644 --- a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java +++ b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java @@ -47,7 +47,6 @@ import de.uni_freiburg.informatik.ultimate.core.lib.results.UnprovabilityReason; import de.uni_freiburg.informatik.ultimate.core.lib.results.UnprovableResult; import de.uni_freiburg.informatik.ultimate.core.model.models.IElement; -import de.uni_freiburg.informatik.ultimate.core.model.models.ILocation; import de.uni_freiburg.informatik.ultimate.core.model.preferences.IPreferenceProvider; import de.uni_freiburg.informatik.ultimate.core.model.results.IResult; import de.uni_freiburg.informatik.ultimate.core.model.results.IResultWithSeverity.Severity; @@ -61,13 +60,13 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgElement; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.dangerinvariants.DangerInvariantUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareUtils; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; @@ -191,7 +190,8 @@ public InvariantSynthesisStarter(final IUltimateServiceProvider services, final hoareAnnot.annotate(entry.getKey()); hoareAnnot.addInvariant(entry.getValue()); } - writeHoareAnnotationToLogger(icfg); + // TODO #proofRefactor + FloydHoareUtils.writeHoareAnnotationToLogger(icfg, null, mLogger, true); mOverallResult = Result.SAFE; } } else { @@ -363,39 +363,6 @@ private void createProcedureContractResults(final IIcfg icfg, } } - private void writeHoareAnnotationToLogger(final IIcfg root) { - for (final Entry> proc2label2pp : root.getProgramPoints() - .entrySet()) { - for (final IcfgLocation pp : proc2label2pp.getValue().values()) { - final HoareAnnotation hoare = HoareAnnotation.getAnnotation(pp); - if (hoare == null) { - mLogger.info("For program point " + prettyPrintProgramPoint(pp) - + " no Hoare annotation was computed."); - } else { - mLogger.info("At program point " + prettyPrintProgramPoint(pp) + " the Hoare annotation is: " - + hoare.getFormula()); - } - } - } - } - - private static String prettyPrintProgramPoint(final IcfgLocation pp) { - final ILocation loc = ILocation.getAnnotation(pp); - if (loc == null) { - return ""; - } - final int startLine = loc.getStartLine(); - final int endLine = loc.getEndLine(); - final StringBuilder sb = new StringBuilder(); - sb.append(pp); - if (startLine == endLine) { - sb.append("(line " + startLine + ")"); - } else { - sb.append("(lines " + startLine + " " + endLine + ")"); - } - return sb.toString(); - } - private void reportDangerResults(final Map invariants, final Set errorLocations, final IBacktranslationService backtranslator) { final Map map = new HashMap<>(); diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java new file mode 100644 index 00000000000..be40fe70ca4 --- /dev/null +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2023 University of Freiburg + * + * This file is part of the ULTIMATE Proofs Library. + * + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE Proofs Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE Proofs Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; + +import de.uni_freiburg.informatik.ultimate.core.model.models.ILocation; +import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; + +public final class FloydHoareUtils { + private FloydHoareUtils() { + // no instances of static class + } + + public static void writeHoareAnnotationToLogger(final IIcfg icfg, + final IFloydHoareAnnotation annotation, final ILogger logger, final boolean logTrivialAnnotations) { + + for (final var proc2label2pp : icfg.getProgramPoints().entrySet()) { + for (final LOC pp : proc2label2pp.getValue().values()) { + final IPredicate hoare = annotation.getAnnotation(pp); + + if (hoare == null) { + logger.info("For program point %s no Hoare annotation was computed.", prettyPrintProgramPoint(pp)); + } else if (logTrivialAnnotations || !SmtUtils.isTrueLiteral(hoare.getFormula())) { + logger.info("At program point %s the Hoare annotation is: %s", prettyPrintProgramPoint(pp), + hoare.getFormula()); + } + } + } + } + + private static String prettyPrintProgramPoint(final IcfgLocation pp) { + final ILocation loc = ILocation.getAnnotation(pp); + if (loc == null) { + return ""; + } + final int startLine = loc.getStartLine(); + final int endLine = loc.getEndLine(); + final StringBuilder sb = new StringBuilder(); + sb.append(pp); + if (startLine == endLine) { + sb.append("(line "); + sb.append(startLine); + } else { + sb.append("(lines "); + sb.append(startLine); + sb.append(" "); + sb.append(endLine); + } + sb.append(")"); + return sb.toString(); + } +} diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 09d911586cd..31b4d24a210 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -36,7 +36,6 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; @@ -61,7 +60,6 @@ import de.uni_freiburg.informatik.ultimate.core.lib.exceptions.ToolchainExceptionWrapper; import de.uni_freiburg.informatik.ultimate.core.lib.results.UnprovabilityReason; import de.uni_freiburg.informatik.ultimate.core.model.models.IElement; -import de.uni_freiburg.informatik.ultimate.core.model.models.ILocation; import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.core.model.services.IProgressAwareTimer; import de.uni_freiburg.informatik.ultimate.core.model.services.IProgressMonitorService; @@ -76,7 +74,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.interpolant.IInterpolantGenerator; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; @@ -85,7 +82,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.TaskIdentifier; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.HoareAnnotationPositions; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaFloydHoareValidityCheck; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.logic.Script; @@ -109,7 +105,6 @@ */ public abstract class AbstractCegarLoop, A extends IAutomaton> { private static final boolean DUMP_BIGGEST_AUTOMATON = false; - private static final boolean EXTENDED_HOARE_ANNOTATION_LOGGING = true; protected final ILogger mLogger; protected final SimplificationTechnique mSimplificationTechnique; @@ -884,55 +879,6 @@ public CegarLoopResult getResult() { public int remainingErrorLocs() { return mErrorLocs.size() - mResults.size(); } - - // TODO #proofRefactor - @SuppressWarnings("unchecked") - private void writeHoareAnnotationToLogger() { - final IIcfg root = (IIcfg) mIcfg; - for (final Entry> proc2label2pp : root.getProgramPoints() - .entrySet()) { - for (final IcfgLocation pp : proc2label2pp.getValue().values()) { - final HoareAnnotation hoare = HoareAnnotation.getAnnotation(pp); - - if (hoare != null && !SmtUtils.isTrueLiteral(hoare.getFormula())) { - - mLogger.info("At program point %s the Hoare annotation is: %s", prettyPrintProgramPoint(pp), - hoare.getFormula()); - } else if (EXTENDED_HOARE_ANNOTATION_LOGGING) { - if (hoare == null) { - mLogger.info("For program point %s no Hoare annotation was computed.", - prettyPrintProgramPoint(pp)); - } else { - mLogger.info("At program point %s the Hoare annotation is: %s", prettyPrintProgramPoint(pp), - hoare.getFormula()); - } - } - } - } - } - - private String prettyPrintProgramPoint(final IcfgLocation pp) { - final ILocation loc = ILocation.getAnnotation(pp); - if (loc == null) { - return ""; - } - final int startLine = loc.getStartLine(); - final int endLine = loc.getEndLine(); - final StringBuilder sb = new StringBuilder(); - sb.append(pp); - if (startLine == endLine) { - sb.append("(line "); - sb.append(startLine); - } else { - sb.append("(lines "); - sb.append(startLine); - sb.append(" "); - sb.append(endLine); - } - sb.append(")"); - return sb.toString(); - } - } } From aa874c3ce7d56b1f06f9e30ccb329d404a31a3ff Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 21 Dec 2023 12:33:42 +0100 Subject: [PATCH 44/91] InvariantSynthesis: use FloydHoareMapping in place of HoareAnnotation --- .../InvariantSynthesisStarter.java | 47 ++++++++----------- .../smt/predicates/PredicateFactory.java | 6 --- .../IcfgFloydHoareValidityCheck.java | 7 +++ 3 files changed, 27 insertions(+), 33 deletions(-) diff --git a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java index 29adc272326..9ce8fc0880d 100644 --- a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java +++ b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java @@ -53,7 +53,6 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.IBacktranslationService; import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgProgramExecution; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; @@ -61,15 +60,16 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.dangerinvariants.DangerInvariantUtils; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareMapping; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareUtils; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; +import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder; @@ -160,6 +160,7 @@ public InvariantSynthesisStarter(final IUltimateServiceProvider services, final return; } + final FloydHoareMapping floydHoare; final CFGInvariantsGenerator cfgInvGenerator = new CFGInvariantsGenerator(icfg, services, predicateOfInitialLocations, predicateOfErrorLocations, predicateFactory, predicateUnifier, invSynthSettings, icfg.getCfgSmtToolkit(), kindOfInvariant); @@ -176,26 +177,18 @@ public InvariantSynthesisStarter(final IUltimateServiceProvider services, final mLogger.debug(invariants); mOverallResult = Result.UNKNOWN; } + floydHoare = null; } else { assert kindOfInvariant == KindOfInvariant.SAFETY; - - // if (mLogger.isDebugEnabled()) { - // for (IcfgLocation loc : invariants.keySet()) { - // mLogger.debug(loc + ": " + invariants.get(loc)); - // } - // } - for (final Entry entry : invariants.entrySet()) { - final HoareAnnotation hoareAnnot = predicateFactory.getNewHoareAnnotation(entry.getKey(), - icfg.getCfgSmtToolkit().getModifiableGlobalsTable()); - hoareAnnot.annotate(entry.getKey()); - hoareAnnot.addInvariant(entry.getValue()); - } - // TODO #proofRefactor - FloydHoareUtils.writeHoareAnnotationToLogger(icfg, null, mLogger, true); + floydHoare = + new FloydHoareMapping<>(predicateOfInitialLocations, predicateOfErrorLocations, invariants); + FloydHoareUtils.writeHoareAnnotationToLogger(icfg, floydHoare, mLogger, true); + // TODO #proofRefactor pass the annotation 'floydHoare' to other plugins mOverallResult = Result.SAFE; } } else { mOverallResult = Result.UNKNOWN; + floydHoare = null; } final Map> proc2errNodes = icfg.getProcedureErrorNodes(); @@ -213,9 +206,10 @@ public InvariantSynthesisStarter(final IUltimateServiceProvider services, final mLogger.debug("Overall result: " + mOverallResult); mLogger.debug("Continue processing: " + mServices.getProgressMonitorService().continueProcessing()); if (mOverallResult == Result.SAFE) { + assert floydHoare != null; final IBacktranslationService backTranslatorService = mServices.getBacktranslationService(); - createInvariantResults(icfg, icfg.getCfgSmtToolkit(), backTranslatorService); - createProcedureContractResults(icfg, backTranslatorService); + createInvariantResults(icfg, floydHoare, backTranslatorService); + createProcedureContractResults(icfg, floydHoare, backTranslatorService); } final StatisticsData stat = new StatisticsData(); stat.aggregateBenchmarkData(statistics); @@ -313,11 +307,10 @@ private InvariantSynthesisSettings constructSettings(final String cfgIdentifier) useUnsatCores, useAbstractInterpretationPredicates, useWPForPathInvariants, useLBE); } - private void createInvariantResults(final IIcfg icfg, final CfgSmtToolkit csToolkit, - final IBacktranslationService backTranslatorService) { - assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, true).getResult() : "incorrect Hoare annotation"; - - final Term trueterm = csToolkit.getManagedScript().getScript().term("true"); + private void createInvariantResults(final IIcfg icfg, + final FloydHoareMapping annotation, final IBacktranslationService backTranslatorService) { + assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, annotation, true) + .getResult() : "incorrect Hoare annotation"; final Set locsForLoopLocations = new HashSet<>(); @@ -326,7 +319,7 @@ private void createInvariantResults(final IIcfg icfg, final CfgSmt // find all locations that have outgoing edges which are annotated with LoopEntry, i.e., all loop candidates for (final IcfgLocation locNode : locsForLoopLocations) { - final HoareAnnotation hoare = HoareAnnotation.getAnnotation(locNode); + final IPredicate hoare = annotation.getAnnotation(locNode); if (hoare == null) { continue; } @@ -335,7 +328,7 @@ private void createInvariantResults(final IIcfg icfg, final CfgSmt new InvariantResult<>(Activator.PLUGIN_NAME, locNode, backTranslatorService, formula); reportResult(invResult); - if (formula.equals(trueterm)) { + if (SmtUtils.isTrueLiteral(formula)) { continue; } new WitnessInvariant(invResult.getInvariant()).annotate(locNode); @@ -343,7 +336,7 @@ private void createInvariantResults(final IIcfg icfg, final CfgSmt } private void createProcedureContractResults(final IIcfg icfg, - final IBacktranslationService backTranslatorService) { + final FloydHoareMapping annotation, final IBacktranslationService backTranslatorService) { final Map finalNodes = icfg.getProcedureExitNodes(); for (final Entry proc : finalNodes.entrySet()) { final String procName = proc.getKey(); @@ -351,7 +344,7 @@ private void createProcedureContractResults(final IIcfg icfg, continue; } final IcfgLocation finalNode = proc.getValue(); - final HoareAnnotation hoare = HoareAnnotation.getAnnotation(finalNode); + final IPredicate hoare = annotation.getAnnotation(finalNode); if (hoare != null) { final Term formula = hoare.getFormula(); final ProcedureContractResult result = new ProcedureContractResult<>( diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateFactory.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateFactory.java index fce75e1437a..f56f2668e26 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateFactory.java +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateFactory.java @@ -33,7 +33,6 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IIcfgSymbolTable; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.ModifiableGlobalsTable; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; @@ -89,11 +88,6 @@ public MLPredicate newMLDontCarePredicate(final IcfgLocation[] programPoints) { return newMLPredicate(programPoints, mDontCareTerm); } - public HoareAnnotation getNewHoareAnnotation(final IcfgLocation pp, - final ModifiableGlobalsTable modifiableGlobalsTable) { - return new HoareAnnotation(pp, constructFreshSerialNumber(), this, mMgdScript); - } - private static final class NoCallerDebugIdentifier extends DebugIdentifier { public static final NoCallerDebugIdentifier INSTANCE = new NoCallerDebugIdentifier(); diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java index 31152697895..b237c554b00 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java @@ -49,11 +49,17 @@ public class IcfgFloydHoareValidityCheck extends Floyd private final IIcfg mIcfg; private final Set mErrorLocs; + @Deprecated public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final IIcfg icfg, final boolean assertValidity) { this(services, icfg, new IcfgHoareAnnotation<>(), assertValidity, MissingAnnotationBehaviour.IGNORE, false); } + public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final IIcfg icfg, + final IFloydHoareAnnotation annotation, final boolean assertValidity) { + this(services, icfg, annotation, assertValidity, MissingAnnotationBehaviour.IGNORE, false); + } + public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final IIcfg icfg, final IFloydHoareAnnotation annotation, final boolean assertValidity, final MissingAnnotationBehaviour missingAnnotations, final boolean checkSafety) { @@ -117,6 +123,7 @@ private Iterable> getSuccessors(final LOC state .map(e -> new Pair<>(clazz.cast(e), (LOC) e.getTarget())).collect(Collectors.toList()); } + @Deprecated private static final class IcfgHoareAnnotation implements IFloydHoareAnnotation { @Override public IPredicate getPrecondition() { From 66b37b68b452c17d4a680f6b88dbf861e9ba35f3 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 21 Dec 2023 13:03:15 +0100 Subject: [PATCH 45/91] deduplicate code for invariant and procedure contract results --- .../codecheck/CodeCheckObserver.java | 1 + .../InvariantSynthesisStarter.java | 68 ++--------------- .../proofs/floydhoare/FloydHoareUtils.java | 65 ++++++++++++++++ .../IcfgFloydHoareValidityCheck.java | 2 +- .../models/annotation/WitnessInvariant.java | 14 ++-- .../TraceAbstractionStarter.java | 76 +++---------------- 6 files changed, 93 insertions(+), 133 deletions(-) diff --git a/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java b/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java index 1aee1afdcdd..24775ac0c77 100644 --- a/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java +++ b/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java @@ -534,6 +534,7 @@ public boolean process(final IElement root) { return false; } + // TODO #proofRefactor create IFloydHoareAnnotation and use FloydHoareUtils method private void createInvariantResults(final List procRootsToCheck, final IIcfg icfg, final CfgSmtToolkit csToolkit, final IBacktranslationService backTranslatorService) { diff --git a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java index 9ce8fc0880d..737a5c89d8d 100644 --- a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java +++ b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java @@ -30,19 +30,14 @@ import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; -import java.util.HashSet; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Set; -import de.uni_freiburg.informatik.ultimate.core.lib.models.annotation.WitnessInvariant; import de.uni_freiburg.informatik.ultimate.core.lib.results.AllSpecificationsHoldResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.DangerInvariantResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.GenericResult; -import de.uni_freiburg.informatik.ultimate.core.lib.results.InvariantResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.PositiveResult; -import de.uni_freiburg.informatik.ultimate.core.lib.results.ProcedureContractResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.StatisticsResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.UnprovabilityReason; import de.uni_freiburg.informatik.ultimate.core.lib.results.UnprovableResult; @@ -69,7 +64,6 @@ import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SolverBuilder; @@ -207,9 +201,14 @@ public InvariantSynthesisStarter(final IUltimateServiceProvider services, final mLogger.debug("Continue processing: " + mServices.getProgressMonitorService().continueProcessing()); if (mOverallResult == Result.SAFE) { assert floydHoare != null; + assert new IcfgFloydHoareValidityCheck<>(services, icfg, floydHoare, true) + .getResult() : "incorrect Hoare annotation"; + final IBacktranslationService backTranslatorService = mServices.getBacktranslationService(); - createInvariantResults(icfg, floydHoare, backTranslatorService); - createProcedureContractResults(icfg, floydHoare, backTranslatorService); + FloydHoareUtils.createInvariantResults(Activator.PLUGIN_NAME, icfg, floydHoare, backTranslatorService, + this::reportResult); + FloydHoareUtils.createProcedureContractResults(Activator.PLUGIN_NAME, icfg, floydHoare, + backTranslatorService, this::reportResult); } final StatisticsData stat = new StatisticsData(); stat.aggregateBenchmarkData(statistics); @@ -307,55 +306,6 @@ private InvariantSynthesisSettings constructSettings(final String cfgIdentifier) useUnsatCores, useAbstractInterpretationPredicates, useWPForPathInvariants, useLBE); } - private void createInvariantResults(final IIcfg icfg, - final FloydHoareMapping annotation, final IBacktranslationService backTranslatorService) { - assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, annotation, true) - .getResult() : "incorrect Hoare annotation"; - - final Set locsForLoopLocations = new HashSet<>(); - - locsForLoopLocations.addAll(IcfgUtils.getPotentialCycleProgramPoints(icfg)); - locsForLoopLocations.addAll(icfg.getLoopLocations()); - // find all locations that have outgoing edges which are annotated with LoopEntry, i.e., all loop candidates - - for (final IcfgLocation locNode : locsForLoopLocations) { - final IPredicate hoare = annotation.getAnnotation(locNode); - if (hoare == null) { - continue; - } - final Term formula = hoare.getFormula(); - final InvariantResult invResult = - new InvariantResult<>(Activator.PLUGIN_NAME, locNode, backTranslatorService, formula); - reportResult(invResult); - - if (SmtUtils.isTrueLiteral(formula)) { - continue; - } - new WitnessInvariant(invResult.getInvariant()).annotate(locNode); - } - } - - private void createProcedureContractResults(final IIcfg icfg, - final FloydHoareMapping annotation, final IBacktranslationService backTranslatorService) { - final Map finalNodes = icfg.getProcedureExitNodes(); - for (final Entry proc : finalNodes.entrySet()) { - final String procName = proc.getKey(); - if (isAuxilliaryProcedure(procName)) { - continue; - } - final IcfgLocation finalNode = proc.getValue(); - final IPredicate hoare = annotation.getAnnotation(finalNode); - if (hoare != null) { - final Term formula = hoare.getFormula(); - final ProcedureContractResult result = new ProcedureContractResult<>( - Activator.PLUGIN_NAME, finalNode, backTranslatorService, procName, formula); - - reportResult(result); - // TODO: Add setting that controls the generation of those witness invariants - } - } - } - private void reportDangerResults(final Map invariants, final Set errorLocations, final IBacktranslationService backtranslator) { final Map map = new HashMap<>(); @@ -380,10 +330,6 @@ private void reportUnproveableResult(final IcfgProgramExecution pe, unproabilityReasons)); } - private static boolean isAuxilliaryProcedure(final String proc) { - return "ULTIMATE.init".equals(proc) || "ULTIMATE.start".equals(proc); - } - private void reportResult(final IResult res) { mServices.getResultService().reportResult(Activator.PLUGIN_ID, res); } diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java index be40fe70ca4..51a61e1930b 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java @@ -26,12 +26,25 @@ */ package de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare; +import java.util.HashSet; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.function.Consumer; + +import de.uni_freiburg.informatik.ultimate.core.lib.models.annotation.WitnessInvariant; +import de.uni_freiburg.informatik.ultimate.core.lib.results.InvariantResult; +import de.uni_freiburg.informatik.ultimate.core.lib.results.ProcedureContractResult; import de.uni_freiburg.informatik.ultimate.core.model.models.ILocation; +import de.uni_freiburg.informatik.ultimate.core.model.services.IBacktranslationService; import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgElement; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; +import de.uni_freiburg.informatik.ultimate.logic.Term; public final class FloydHoareUtils { private FloydHoareUtils() { @@ -76,4 +89,56 @@ private static String prettyPrintProgramPoint(final IcfgLocation pp) { sb.append(")"); return sb.toString(); } + + public static void createInvariantResults(final String pluginName, final IIcfg icfg, + final IFloydHoareAnnotation annotation, final IBacktranslationService backTranslatorService, + final Consumer> reporter) { + final Set locsForLoopLocations = new HashSet<>(); + locsForLoopLocations.addAll(IcfgUtils.getPotentialCycleProgramPoints(icfg)); + locsForLoopLocations.addAll(icfg.getLoopLocations()); + // find all locations that have outgoing edges which are annotated with LoopEntry, i.e., all loop candidates + + for (final IcfgLocation locNode : locsForLoopLocations) { + final IPredicate hoare = annotation.getAnnotation(locNode); + if (hoare == null) { + continue; + } + final Term formula = hoare.getFormula(); + final InvariantResult invResult = + new InvariantResult<>(pluginName, locNode, backTranslatorService, formula); + reporter.accept(invResult); + + if (SmtUtils.isTrueLiteral(formula)) { + continue; + } + // TODO #proofRefactor + new WitnessInvariant(invResult.getInvariant()).annotate(locNode); + } + } + + public static void createProcedureContractResults(final String pluginName, final IIcfg icfg, + final IFloydHoareAnnotation annotation, final IBacktranslationService backTranslatorService, + final Consumer> reporter) { + final Map finalNodes = icfg.getProcedureExitNodes(); + for (final Entry proc : finalNodes.entrySet()) { + final String procName = proc.getKey(); + if (isAuxiliaryProcedure(procName)) { + continue; + } + final IcfgLocation finalNode = proc.getValue(); + final IPredicate hoare = annotation.getAnnotation(finalNode); + if (hoare != null) { + final Term formula = hoare.getFormula(); + final ProcedureContractResult result = + new ProcedureContractResult<>(pluginName, finalNode, backTranslatorService, procName, formula); + + reporter.accept(result); + // TODO: Add setting that controls the generation of those witness invariants + } + } + } + + private static boolean isAuxiliaryProcedure(final String proc) { + return "ULTIMATE.init".equals(proc) || "ULTIMATE.start".equals(proc); + } } diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java index b237c554b00..b99ddd67c1f 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java @@ -124,7 +124,7 @@ private Iterable> getSuccessors(final LOC state } @Deprecated - private static final class IcfgHoareAnnotation implements IFloydHoareAnnotation { + public static final class IcfgHoareAnnotation implements IFloydHoareAnnotation { @Override public IPredicate getPrecondition() { return null; diff --git a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java index 4f48b4cd617..bf42b4b5351 100644 --- a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java +++ b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java @@ -1,22 +1,22 @@ /* * Copyright (C) 2015 Daniel Dietsch (dietsch@informatik.uni-freiburg.de) * Copyright (C) 2015 University of Freiburg - * + * * This file is part of the ULTIMATE Core. - * + * * The ULTIMATE Core is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. - * + * * The ULTIMATE Core is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public License * along with the ULTIMATE Core. If not, see . - * + * * Additional permission under GNU GPL version 3 section 7: * If you modify the ULTIMATE Core, or any covered work, by linking * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), @@ -32,10 +32,12 @@ import de.uni_freiburg.informatik.ultimate.core.model.models.annotation.Visualizable; /** - * + * * @author Daniel Dietsch (dietsch@informatik.uni-freiburg.de) * */ +// TODO #proofRefactor +@Deprecated public class WitnessInvariant extends ModernAnnotations { private static final long serialVersionUID = 1L; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java index da9b850740a..5c108e29734 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java @@ -33,7 +33,6 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Set; import java.util.function.Predicate; import java.util.function.Supplier; @@ -44,11 +43,8 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingLetterAndTransitionProvider; import de.uni_freiburg.informatik.ultimate.boogie.ast.BoogieASTNode; import de.uni_freiburg.informatik.ultimate.core.lib.models.annotation.Check; -import de.uni_freiburg.informatik.ultimate.core.lib.models.annotation.WitnessInvariant; import de.uni_freiburg.informatik.ultimate.core.lib.results.AllSpecificationsHoldResult; -import de.uni_freiburg.informatik.ultimate.core.lib.results.InvariantResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.PositiveResult; -import de.uni_freiburg.informatik.ultimate.core.lib.results.ProcedureContractResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.ResultUtil; import de.uni_freiburg.informatik.ultimate.core.lib.results.StatisticsResult; import de.uni_freiburg.informatik.ultimate.core.model.models.IElement; @@ -58,11 +54,9 @@ import de.uni_freiburg.informatik.ultimate.core.model.services.ILogger; import de.uni_freiburg.informatik.ultimate.core.model.services.IProgressMonitorService; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgPetrifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgElement; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgForkTransitionThreadCurrent; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; @@ -71,12 +65,11 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.ProcedureErrorDebugIdentifier.ProcedureErrorType; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.StringDebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.transformations.BlockEncodingBacktranslator; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareUtils; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.abstraction.ICopyActionFactory; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.PetriNetLargeBlockEncoding.IPLBECompositionFactory; -import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.BoogieIcfgLocation; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.AbstractCegarLoop.Result; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; @@ -183,8 +176,16 @@ private void runCegarLoops(final IIcfg icfg) { if (mComputeHoareAnnotation && progmon.continueProcessing() && results.stream().allMatch( a -> a.resultStream().allMatch(r -> r != Result.TIMEOUT && !Result.USER_LIMIT_RESULTS.contains(r)))) { final IBacktranslationService backTranslatorService = mServices.getBacktranslationService(); - createInvariantResults(icfg, backTranslatorService); - createProcedureContractResults(icfg, backTranslatorService); + + // TODO #proofRefactor + final var annotation = new IcfgFloydHoareValidityCheck.IcfgHoareAnnotation<>(); + assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, annotation, true) + .getResult() : "incorrect Hoare annotation"; + + FloydHoareUtils.createInvariantResults(Activator.PLUGIN_NAME, icfg, annotation, backTranslatorService, + mResultReporter::reportResult); + FloydHoareUtils.createProcedureContractResults(Activator.PLUGIN_NAME, icfg, annotation, + backTranslatorService, mResultReporter::reportResult); } mRootOfNewModel = mArtifact; } @@ -426,57 +427,6 @@ private CegarLoopResult executeCegarLoop(final IUltimateServiceProvider servi return icfg.getCfgSmtToolkit().getConcurrencyInformation().getInUseErrorNodeMap(); } - private void createInvariantResults(final IIcfg icfg, - final IBacktranslationService backTranslatorService) { - final CfgSmtToolkit csToolkit = icfg.getCfgSmtToolkit(); - assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, true).getResult() : "incorrect Hoare annotation"; - - final Term trueterm = csToolkit.getManagedScript().getScript().term("true"); - - final Set locsForLoopLocations = new HashSet<>(); - - locsForLoopLocations.addAll(IcfgUtils.getPotentialCycleProgramPoints(icfg)); - locsForLoopLocations.addAll(icfg.getLoopLocations()); - // find all locations that have outgoing edges which are annotated with LoopEntry, i.e., all loop candidates - - for (final IcfgLocation locNode : locsForLoopLocations) { - final HoareAnnotation hoare = HoareAnnotation.getAnnotation(locNode); - if (hoare == null) { - continue; - } - final Term formula = hoare.getFormula(); - final InvariantResult invResult = - new InvariantResult<>(Activator.PLUGIN_NAME, locNode, backTranslatorService, formula); - mResultReporter.reportResult(invResult); - - if (formula.equals(trueterm)) { - continue; - } - new WitnessInvariant(invResult.getInvariant()).annotate(locNode); - } - } - - private void createProcedureContractResults(final IIcfg icfg, - final IBacktranslationService backTranslatorService) { - final Map finalNodes = icfg.getProcedureExitNodes(); - for (final Entry proc : finalNodes.entrySet()) { - final String procName = proc.getKey(); - if (isAuxilliaryProcedure(procName)) { - continue; - } - final IcfgLocation finalNode = proc.getValue(); - final HoareAnnotation hoare = HoareAnnotation.getAnnotation(finalNode); - if (hoare != null) { - final Term formula = hoare.getFormula(); - final ProcedureContractResult result = new ProcedureContractResult<>( - Activator.PLUGIN_NAME, finalNode, backTranslatorService, procName, formula); - - mResultReporter.reportResult(result); - // TODO: Add setting that controls the generation of those witness invariants - } - } - } - private void logNumberOfWitnessInvariants(final Collection errNodesOfAllProc) { int numberOfCheckedInvariants = 0; for (final IcfgLocation err : errNodesOfAllProc) { @@ -598,10 +548,6 @@ private String getBenchmarkDescription(final DebugIdentifier ident, final int nu return description; } - private static boolean isAuxilliaryProcedure(final String proc) { - return ULTIMATE_INIT.equals(proc) || ULTIMATE_START.equals(proc); - } - /** * @return the root of the CFG. */ From 5a532426535f97d44d886e87e01173c66eae8152 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 21 Dec 2023 15:48:31 +0100 Subject: [PATCH 46/91] unify CodeCheck handling of invariants with TraceAbstraction, InvariantSynthesis --- trunk/source/CodeCheck/META-INF/MANIFEST.MF | 1 + .../codecheck/CodeCheckObserver.java | 57 +++++-------------- 2 files changed, 15 insertions(+), 43 deletions(-) diff --git a/trunk/source/CodeCheck/META-INF/MANIFEST.MF b/trunk/source/CodeCheck/META-INF/MANIFEST.MF index d36b92619ca..fb21aa1bf2b 100644 --- a/trunk/source/CodeCheck/META-INF/MANIFEST.MF +++ b/trunk/source/CodeCheck/META-INF/MANIFEST.MF @@ -7,6 +7,7 @@ Require-Bundle: de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.core, de.uni_freiburg.informatik.ultimate.lib.smtlibutils, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils, + de.uni_freiburg.informatik.ultimate.lib.proofs, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils, de.uni_freiburg.informatik.ultimate.lib.util, de.uni_freiburg.informatik.ultimate.lib.boogieast, diff --git a/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java b/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java index 24775ac0c77..ab39f28a827 100644 --- a/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java +++ b/trunk/source/CodeCheck/src/de/uni_freiburg/informatik/ultimate/plugins/generator/codecheck/CodeCheckObserver.java @@ -46,11 +46,9 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.NestedRun; import de.uni_freiburg.informatik.ultimate.automata.nestedword.NestedWord; import de.uni_freiburg.informatik.ultimate.core.lib.models.annotation.Check; -import de.uni_freiburg.informatik.ultimate.core.lib.models.annotation.WitnessInvariant; import de.uni_freiburg.informatik.ultimate.core.lib.results.AllSpecificationsHoldResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.CounterExampleResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.GenericResult; -import de.uni_freiburg.informatik.ultimate.core.lib.results.InvariantResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.PositiveResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.StatisticsResult; import de.uni_freiburg.informatik.ultimate.core.lib.results.TimeoutResultAtElement; @@ -87,7 +85,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.tracecheck.ITraceCheckPreferences.AssertCodeBlockOrder; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.tracecheck.ITraceCheckPreferences.UnsatCores; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.DagSizePrinter; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareMapping; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; @@ -518,8 +517,7 @@ public boolean process(final IElement root) { reportPositiveResults(mErrNodesOfAllProc); if (OUTPUT_HOARE_ANNOTATION) { - createInvariantResults(procRootsToCheck, icfg, icfg.getCfgSmtToolkit(), - mServices.getBacktranslationService()); + createInvariantAndContractResults(procRootsToCheck, icfg, mServices.getBacktranslationService()); } } else if (overallResult == Result.UNSAFE) { reportCounterexampleResult(realErrorProgramExecution); @@ -534,41 +532,14 @@ public boolean process(final IElement root) { return false; } - // TODO #proofRefactor create IFloydHoareAnnotation and use FloydHoareUtils method - private void createInvariantResults(final List procRootsToCheck, - final IIcfg icfg, final CfgSmtToolkit csToolkit, - final IBacktranslationService backTranslatorService) { - final Term trueterm = csToolkit.getManagedScript().getScript().term("true"); - - final Set locsForLoopLocations = new HashSet<>(IcfgUtils.getPotentialCycleProgramPoints(icfg)); - - locsForLoopLocations.addAll(icfg.getLoopLocations()); - // find all locations that have outgoing edges which are annotated with LoopEntry, i.e., all loop candidates - + private void createInvariantAndContractResults(final List procRootsToCheck, + final IIcfg icfg, final IBacktranslationService backTranslatorService) { for (final AnnotatedProgramPoint pr : procRootsToCheck) { - final Map ha = computeHoareAnnotation(pr); - for (final Entry kvp : ha.entrySet()) { - final IcfgLocation locNode = kvp.getKey(); - if (!locsForLoopLocations.contains(locNode)) { - // only compute loop invariants - continue; - } - - final Term invariant = kvp.getValue(); - if (invariant == null) { - continue; - } - mLogger.info("Invariant with dag size " + new DagSizePrinter(invariant)); - - final InvariantResult invResult = - new InvariantResult<>(Activator.PLUGIN_NAME, locNode, backTranslatorService, invariant); - reportResult(invResult); - - if (trueterm.equals(invariant)) { - continue; - } - new WitnessInvariant(invResult.getInvariant()).annotate(locNode); - } + final var floydHoare = computeHoareAnnotation(pr); + FloydHoareUtils.createInvariantResults(Activator.PLUGIN_NAME, icfg, floydHoare, backTranslatorService, + this::reportResult); + FloydHoareUtils.createProcedureContractResults(Activator.PLUGIN_NAME, icfg, floydHoare, + backTranslatorService, this::reportResult); } } @@ -638,8 +609,8 @@ private InterpolatingTraceCheck> createTraceCheck( } } - private Map computeHoareAnnotation(final AnnotatedProgramPoint pr) { - final Map pp2HoareAnnotation = new HashMap<>(); + private FloydHoareMapping computeHoareAnnotation(final AnnotatedProgramPoint pr) { + final Map pp2HoareAnnotation = new HashMap<>(); final Map> pp2app = computeProgramPointToAnnotatedProgramPoints(pr); for (final Entry> kvp : pp2app.entrySet()) { @@ -649,9 +620,9 @@ private Map computeHoareAnnotation(final AnnotatedProgramPoi SmtUtils.orWithExtendedLocalSimplification(mCsToolkit.getManagedScript().getScript(), terms); final Term simplifiedOrTerm = SmtUtils.simplify(mCsToolkit.getManagedScript(), orTerm, mServices, SimplificationTechnique.SIMPLIFY_DDA); - pp2HoareAnnotation.put(kvp.getKey(), simplifiedOrTerm); + pp2HoareAnnotation.put(kvp.getKey(), mPredicateUnifier.getOrConstructPredicate(simplifiedOrTerm)); } - return pp2HoareAnnotation; + return new FloydHoareMapping<>(mPredicateUnifier, pp2HoareAnnotation); } /** From 38d3fd19f3c52d80932343b889694f798ce084f2 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 21 Dec 2023 15:50:29 +0100 Subject: [PATCH 47/91] minor simplifications --- .../lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java | 6 ------ .../generator/traceabstraction/TraceAbstractionStarter.java | 4 ++-- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java index b99ddd67c1f..71e173e94a6 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java @@ -49,12 +49,6 @@ public class IcfgFloydHoareValidityCheck extends Floyd private final IIcfg mIcfg; private final Set mErrorLocs; - @Deprecated - public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final IIcfg icfg, - final boolean assertValidity) { - this(services, icfg, new IcfgHoareAnnotation<>(), assertValidity, MissingAnnotationBehaviour.IGNORE, false); - } - public IcfgFloydHoareValidityCheck(final IUltimateServiceProvider services, final IIcfg icfg, final IFloydHoareAnnotation annotation, final boolean assertValidity) { this(services, icfg, annotation, assertValidity, MissingAnnotationBehaviour.IGNORE, false); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java index 5c108e29734..c3eab00cb87 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java @@ -173,8 +173,8 @@ private void runCegarLoops(final IIcfg icfg) { final IProgressMonitorService progmon = mServices.getProgressMonitorService(); - if (mComputeHoareAnnotation && progmon.continueProcessing() && results.stream().allMatch( - a -> a.resultStream().allMatch(r -> r != Result.TIMEOUT && !Result.USER_LIMIT_RESULTS.contains(r)))) { + if (mComputeHoareAnnotation && progmon.continueProcessing() + && results.stream().allMatch(a -> a.resultStream().noneMatch(Result::isLimit))) { final IBacktranslationService backTranslatorService = mServices.getBacktranslationService(); // TODO #proofRefactor From 6f0885ec5869e604e3b16efa9b4f506df6ea663b Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 22 Dec 2023 12:22:05 +0100 Subject: [PATCH 48/91] remove unused param --- .../generator/traceabstraction/CegarLoopFactory.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index d406c09fcdf..6425df36d67 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -159,13 +159,13 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr if ((FORCE_FINITE_AUTOMATA_FOR_SEQUENTIAL_PROGRAMS && !IcfgUtils.isConcurrent(root)) || witnessAutomaton != null) { return createFiniteAutomataCegarLoop(services, name, root, predicateFactory, errorLocs, - rawFloydHoareAutomataFromFile, hoareAnnotationLocs, stateFactoryForRefinement, witnessAutomaton); + rawFloydHoareAutomataFromFile, stateFactoryForRefinement, witnessAutomaton); } switch (mPrefs.getAutomataTypeConcurrency()) { case FINITE_AUTOMATA: return createFiniteAutomataCegarLoop(services, name, root, predicateFactory, errorLocs, - rawFloydHoareAutomataFromFile, hoareAnnotationLocs, stateFactoryForRefinement, witnessAutomaton); + rawFloydHoareAutomataFromFile, stateFactoryForRefinement, witnessAutomaton); case PARTIAL_ORDER_FA: requireNoReuse("POR-based analysis"); requireNoWitnesses(witnessAutomaton, "POR-based analysis"); @@ -209,10 +209,10 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService final DebugIdentifier name, final IIcfg root, final PredicateFactory predicateFactory, final Set errorLocs, final List> rawFloydHoareAutomataFromFile, - final Set hoareAnnotationLocs, final PredicateFactoryRefinement stateFactoryForRefinement, + final PredicateFactoryRefinement stateFactoryForRefinement, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton) { - // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loops + // TODO #proofRefactor extract proof producer from IInitialAbstractionProvider and pass to CEGAR loops final INestedWordAutomaton initialAbstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); final CfgSmtToolkit csToolkit = root.getCfgSmtToolkit(); From c943d41e6c7a3ab7f5e2a7642918bcb7d52c8372 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 22 Dec 2023 12:57:32 +0100 Subject: [PATCH 49/91] remove redundant constructor parameters --- .../traceabstraction/AbstractCegarLoop.java | 6 +----- .../traceabstraction/BasicCegarLoop.java | 12 +++++++----- .../traceabstraction/CegarLoopFactory.java | 16 +++++++--------- .../CegarLoopSWBnonRecursive.java | 10 ++++------ .../traceabstraction/EagerReuseCegarLoop.java | 12 +++++------- .../IncrementalInclusionCegarLoop.java | 13 ++++++------- .../traceabstraction/LazyReuseCegarLoop.java | 12 +++++------- .../generator/traceabstraction/NwaCegarLoop.java | 10 ++++------ .../traceabstraction/ReuseCegarLoop.java | 10 ++++------ .../concurrency/CegarLoopForPetriNet.java | 4 ++-- .../concurrency/PartialOrderCegarLoop.java | 8 +++----- .../CegarLoopConcurrentAutomata.java | 4 ++-- 12 files changed, 50 insertions(+), 67 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 31b4d24a210..0e7257bfcd4 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -109,7 +109,6 @@ public abstract class AbstractCegarLoop, A extends protected final ILogger mLogger; protected final SimplificationTechnique mSimplificationTechnique; protected final XnfConversionTechnique mXnfConversionTechnique; - protected final Class mTransitionClazz; /** * Interprocedural control flow graph. @@ -196,14 +195,12 @@ public abstract class AbstractCegarLoop, A extends * @param taPrefs * @param errorLocs * @param logger - * @param transitionClazz * @param computeHoareAnnotation */ protected AbstractCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, final A initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final ILogger logger, final Class transitionClazz, - final boolean computeHoareAnnotation) { + final Set errorLocs, final ILogger logger, final boolean computeHoareAnnotation) { mServices = services; mLogger = logger; mSimplificationTechnique = taPrefs.getSimplificationTechnique(); @@ -216,7 +213,6 @@ protected AbstractCegarLoop(final IUltimateServiceProvider services, final Debug mPredicateFactory = predicateFactory; mPref = taPrefs; mErrorLocs = errorLocs; - mTransitionClazz = transitionClazz; mComputeHoareAnnotation = computeHoareAnnotation; // TODO: TaskIdentifier should probably be provided by caller mTaskIdentifier = new SubtaskFileIdentifier(null, mIcfg.getIdentifier() + "_" + name); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index 11aedcd58df..7c15c73b8e1 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -184,12 +184,14 @@ public String getShortString() { public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, InterpolationTechnique interpolation, - final boolean computeHoareAnnotation, final IUltimateServiceProvider services, - final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + final Set errorLocs, final boolean computeHoareAnnotation, + final IUltimateServiceProvider services, final Class transitionClazz, + final PredicateFactoryRefinement stateFactoryForRefinement) { super(services, name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - services.getLoggingService().getLogger(Activator.PLUGIN_ID), transitionClazz, computeHoareAnnotation); + services.getLoggingService().getLogger(Activator.PLUGIN_ID), computeHoareAnnotation); mPathProgramDumpController = new PathProgramDumpController<>(getServices(), mPref, mIcfg); + + InterpolationTechnique interpolation = taPrefs.interpolation(); if (mFallbackToFpIfInterprocedural && rootNode.getProcedureEntryNodes().size() > 1 && interpolation == InterpolationTechnique.FPandBP) { mLogger.info("fallback from FPandBP to FP because CFG is interprocedural"); @@ -219,7 +221,7 @@ public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, fi new TaCheckAndRefinementPreferences<>(getServices(), mPref, interpolation, mSimplificationTechnique, mXnfConversionTechnique, mCsToolkit, mPredicateFactory, mIcfg); mStrategyFactory = new StrategyFactory<>(mLogger, mPref, taCheckAndRefinementPrefs, mIcfg, mPredicateFactory, - mPredicateFactoryInterpolantAutomata, mTransitionClazz); + mPredicateFactoryInterpolantAutomata, transitionClazz); if (mPref.dumpOnlyReuseAutomata()) { // Construct an empty file. We need this empty file in cases where diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 6425df36d67..2d9c1e58271 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -143,8 +143,8 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr stateFactoryForRefinement, witnessAutomaton); // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new IncrementalInclusionCegarLoop<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, languageOperation, - mTransitionClazz, stateFactoryForRefinement); + errorLocs, null, mComputeHoareAnnotation, services, languageOperation, mTransitionClazz, + stateFactoryForRefinement); } if (mPrefs.interpolantAutomaton() == InterpolantAutomaton.TOTALINTERPOLATION) { @@ -152,8 +152,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr stateFactoryForRefinement, witnessAutomaton); // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new CegarLoopSWBnonRecursive<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, mTransitionClazz, - stateFactoryForRefinement); + errorLocs, null, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); } if ((FORCE_FINITE_AUTOMATA_FOR_SEQUENTIAL_PROGRAMS && !IcfgUtils.isConcurrent(root)) @@ -173,7 +172,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr return new PartialOrderCegarLoop<>(name, createPartialOrderAbstraction(services, predicateFactory, stateFactoryForRefinement, root, errorLocs), - root, csToolkit, predicateFactory, mPrefs, errorLocs, mPrefs.interpolation(), services, + root, csToolkit, predicateFactory, mPrefs, errorLocs, services, factory.createProviders(root, predicateFactory), mTransitionClazz, stateFactoryForRefinement); case PETRI_NET: requireNoReuse("Petri net-based analysis"); @@ -220,16 +219,15 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService switch (mPrefs.getFloydHoareAutomataReuse()) { case EAGER: return new EagerReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, Collections.emptyList(), + errorLocs, null, mComputeHoareAnnotation, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case LAZY_IN_ORDER: return new LazyReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mPrefs.interpolation(), null, mComputeHoareAnnotation, services, Collections.emptyList(), + errorLocs, null, mComputeHoareAnnotation, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case NONE: return new NwaCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, errorLocs, - mPrefs.interpolation(), null, mComputeHoareAnnotation, services, mTransitionClazz, - stateFactoryForRefinement); + null, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); default: throw new AssertionError("Unknown Setting: " + mPrefs.getFloydHoareAutomataReuse()); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 5b1b3dd8b68..2e5354748ba 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -67,7 +67,6 @@ import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheckCraig; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheck; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; @@ -166,7 +165,6 @@ public class CegarLoopSWBnonRecursive> extends NwaC * @param csToolkit * @param taPrefs * @param errorLocs - * @param interpolation * @param computeHoareAnnotation * @param services * @param transitionClazz @@ -174,11 +172,11 @@ public class CegarLoopSWBnonRecursive> extends NwaC public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> CegarLoopSWBnonRecursive( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg icfg, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, - final T proofUpdater, final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, + final boolean computeHoareAnnotation, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, + computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mErrorPathHistory = new ArrayList<>(); mnofStates = new ArrayList<>(); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index 4266f664b42..c5a7ced5e5b 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -51,7 +51,6 @@ import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; @@ -80,15 +79,14 @@ private enum MinimizeInitially { public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> EagerReuseCegarLoop( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, + final boolean computeHoareAnnotation, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, - rawFloydHoareAutomataFromFile, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, + computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFile, + transitionClazz, stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index 769490d90ec..9680598ed72 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -68,7 +68,6 @@ import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.NondeterministicInterpolantAutomaton; @@ -86,12 +85,12 @@ public class IncrementalInclusionCegarLoop> extends public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> IncrementalInclusionCegarLoop( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final IUltimateServiceProvider services, final LanguageOperation languageOperation, - final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, + final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final LanguageOperation languageOperation, final Class transitionClazz, + final PredicateFactoryRefinement stateFactoryForRefinement) { + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, + computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mLanguageOperation = languageOperation; if (proofUpdater != null) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index 75f8706ef15..4af9d102d30 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -55,7 +55,6 @@ import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; @@ -79,15 +78,14 @@ public class LazyReuseCegarLoop> extends ReuseCegar public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> LazyReuseCegarLoop( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, + final boolean computeHoareAnnotation, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFiles, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, - rawFloydHoareAutomataFromFiles, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, + computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFiles, + transitionClazz, stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index da3291b2abb..f94c16290b4 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -90,7 +90,6 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SMTFeatureExtractionTermClassifier.ScoringMethod; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.PathProgram; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.PathProgram.PathProgramConstructionResult; @@ -141,11 +140,10 @@ public class NwaCegarLoop> extends BasicCegarLoop & IUpdateOnMinimization & IFinishWithFinalAbstraction>> NwaCegarLoop( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final IUltimateServiceProvider services, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, + final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, + final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mProofUpdater = proofUpdater == null ? null : new ProofUpdater<>(proofUpdater); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java index 196b4ede3c1..000b8cc447b 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java @@ -72,7 +72,6 @@ import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; @@ -111,14 +110,13 @@ public class ReuseCegarLoop> extends NwaCegarLoop & IUpdateOnMinimization & IFinishWithFinalAbstraction>> ReuseCegarLoop( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, - final InterpolationTechnique interpolation, final T proofUpdater, final boolean computeHoareAnnotation, - final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, + final boolean computeHoareAnnotation, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, - proofUpdater, computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, + computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); mFloydHoareAutomataFromOtherErrorLocations = floydHoareAutomataFromOtherLocations; mRawFloydHoareAutomataFromFile = rawFloydHoareAutomataFromFile; mFloydHoareAutomataFromFile = new ArrayList<>(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index 78623a36d56..2e422188b0c 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -151,8 +151,8 @@ public CegarLoopForPetriNet(final DebugIdentifier name, final BoundedPetriNet rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - taPrefs.interpolation(), false, services, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, false, services, + transitionClazz, stateFactoryForRefinement); mPetriClStatisticsGenerator = new PetriCegarLoopStatisticsGenerator(mCegarLoopBenchmark); mCounterexampleCache = new CounterexampleCache<>(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java index 00e8a56cc4a..db1676f5d38 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java @@ -90,7 +90,6 @@ import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.PartialOrderReductionFacade.StateSplitter; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.SleepSetStateFactoryForRefinement.SleepPredicate; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.IndependenceSettings.AbstractionType; -import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.Activator; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.BasicCegarLoop; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.CegarLoopStatisticsDefinitions; @@ -132,12 +131,11 @@ public class PartialOrderCegarLoop> public PartialOrderCegarLoop(final DebugIdentifier name, final INwaOutgoingLetterAndTransitionProvider initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final InterpolationTechnique interpolation, - final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final IUltimateServiceProvider services, final List> independenceProviders, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, interpolation, false, - services, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, false, services, + transitionClazz, stateFactoryForRefinement); assert !mPref.applyOneShotPOR() : "Turn off one-shot partial order reduction when using this CEGAR loop."; diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 633a223ca06..6076b4eddfd 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -78,8 +78,8 @@ public CegarLoopConcurrentAutomata(final DebugIdentifier name, final IIcfg ro final Set errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, createInitialAbstraction(services, csToolkit, predicateFactory, taPrefs, rootNode), rootNode, - csToolkit, predicateFactory, taPrefs, errorLocs, taPrefs.interpolation(), null, false, services, - transitionClazz, stateFactoryForRefinement); + csToolkit, predicateFactory, taPrefs, errorLocs, null, false, services, transitionClazz, + stateFactoryForRefinement); } private static > INestedWordAutomaton createInitialAbstraction( From c9b4873c824264cf0d19a0d72bec43f8272bc52a Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 22 Dec 2023 13:16:04 +0100 Subject: [PATCH 50/91] small simplification --- .../traceabstraction/BasicCegarLoop.java | 27 ------------------- .../traceabstraction/NwaCegarLoop.java | 20 ++++++++++++++ 2 files changed, 20 insertions(+), 27 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index 7c15c73b8e1..dd276d7115d 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -136,33 +136,6 @@ public abstract class BasicCegarLoop, A extends IAutomaton> extends AbstractCegarLoop { - public enum AutomatonType { - FLOYD_HOARE, ERROR; - - private String mLongString; - - static { - FLOYD_HOARE.mLongString = "FloydHoare"; - ERROR.mLongString = "Error"; - } - - private String mShortString; - - static { - FLOYD_HOARE.mShortString = "Fh"; - ERROR.mShortString = "Err"; - } - - public String getLongString() { - return mLongString; - } - - public String getShortString() { - return mShortString; - } - - } - private static final boolean NON_EA_INDUCTIVITY_CHECK = false; protected final PredicateFactoryRefinement mStateFactoryForRefinement; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index f94c16290b4..a4f4d8ed67b 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -116,6 +116,26 @@ */ public class NwaCegarLoop> extends BasicCegarLoop> { + private enum AutomatonType { + FLOYD_HOARE("FloydHoare", "Fh"), ERROR("Error", "Err"); + + private final String mLongString; + private final String mShortString; + + AutomatonType(final String longString, final String shortString) { + mLongString = longString; + mShortString = shortString; + } + + public String getLongString() { + return mLongString; + } + + public String getShortString() { + return mShortString; + } + } + protected static final int MINIMIZE_EVERY_KTH_ITERATION = 10; protected static final boolean REMOVE_DEAD_ENDS = true; protected static final int MINIMIZATION_TIMEOUT = 1_000; From d1c4f2c748bcb58ff5e8e6d5a7f211569f524287 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 22 Dec 2023 14:59:40 +0100 Subject: [PATCH 51/91] some more small simplifications --- .../traceabstraction/AbstractCegarLoop.java | 4 ++-- .../traceabstraction/BasicCegarLoop.java | 16 ++++++---------- 2 files changed, 8 insertions(+), 12 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 0e7257bfcd4..351fe138992 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -200,9 +200,9 @@ public abstract class AbstractCegarLoop, A extends protected AbstractCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, final A initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final ILogger logger, final boolean computeHoareAnnotation) { + final Set errorLocs, final boolean computeHoareAnnotation) { mServices = services; - mLogger = logger; + mLogger = services.getLoggingService().getLogger(Activator.PLUGIN_ID); mSimplificationTechnique = taPrefs.getSimplificationTechnique(); mXnfConversionTechnique = taPrefs.getXnfConversionTechnique(); mPrintAutomataLabeling = taPrefs.getAutomataFormat(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index dd276d7115d..c00a8fd715e 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -53,6 +53,7 @@ import de.uni_freiburg.informatik.ultimate.automata.Word; import de.uni_freiburg.informatik.ultimate.automata.nestedword.EpsilonNestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; +import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaBasis; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaOutgoingLetterAndTransitionProvider; import de.uni_freiburg.informatik.ultimate.automata.nestedword.NestedRun; import de.uni_freiburg.informatik.ultimate.automata.nestedword.NestedWord; @@ -161,7 +162,7 @@ public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, fi final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(services, name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - services.getLoggingService().getLogger(Activator.PLUGIN_ID), computeHoareAnnotation); + computeHoareAnnotation); mPathProgramDumpController = new PathProgramDumpController<>(getServices(), mPref, mIcfg); InterpolationTechnique interpolation = taPrefs.interpolation(); @@ -227,7 +228,7 @@ protected void initialize() throws AutomataLibraryException { * Reads a sequence of SMT assertions from a file (line by line), creates a refinement result from them and refines * the initial abstraction with this result. */ - protected final void readInitialProof() { + protected final void readInitialProof() throws AutomataLibraryException { final String filename = ILocation.getAnnotation(mIcfg).getFileName() + ".proof.smt2"; final Path path = Paths.get(filename).toAbsolutePath(); if (Files.notExists(path)) { @@ -259,8 +260,8 @@ protected final void readInitialProof() { predicates.toArray(IPredicate[]::new)); final VpAlphabet alphabet; - if (mAbstraction instanceof INwaOutgoingLetterAndTransitionProvider) { - alphabet = ((INwaOutgoingLetterAndTransitionProvider) mAbstraction).getVpAlphabet(); + if (mAbstraction instanceof INwaBasis) { + alphabet = ((INwaBasis) mAbstraction).getVpAlphabet(); } else { alphabet = new VpAlphabet<>(mAbstraction.getAlphabet()); } @@ -283,12 +284,7 @@ protected final void readInitialProof() { false)), new Lazy<>(() -> new MonolithicHoareTripleChecker(mCsToolkit)), new Lazy<>(() -> unifier)); mInterpolAutomaton = mRefinementResult.getInfeasibilityProof(); - - try { - refineAbstraction(); - } catch (final AutomataLibraryException e) { - throw new IllegalStateException(e); - } + refineAbstraction(); } @Override From a67f538b293ca8b56e6ae5ffb969e9f39c59bf20 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 11:41:49 +0100 Subject: [PATCH 52/91] fix typo --- .../ultimate/lib/proofs/floydhoare/FloydHoareUtils.java | 2 +- .../ultimate/core/lib/results/ProcedureContractResult.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java index 6827a2e585b..ad0ab9b89a7 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java @@ -144,7 +144,7 @@ public static void createProcedureContractResults(final IUltimateServiceProvider reporter.accept(result); // TODO #proofRefactor - new WitnessProcedureContract(result.getReqiresResult(), result.getEnsuresResult()).annotate(exit); + new WitnessProcedureContract(result.getRequiresResult(), result.getEnsuresResult()).annotate(exit); } } } diff --git a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/results/ProcedureContractResult.java b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/results/ProcedureContractResult.java index 1c6d06b47e7..14db8f6d594 100644 --- a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/results/ProcedureContractResult.java +++ b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/results/ProcedureContractResult.java @@ -62,7 +62,7 @@ public String getEnsuresResult() { return mEnsures; } - public String getReqiresResult() { + public String getRequiresResult() { return mRequires; } From a1f6fffe6d382d2b8c568add0174e6fa204ea396 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 11:44:48 +0100 Subject: [PATCH 53/91] deprecate class --- .../core/lib/models/annotation/WitnessProcedureContract.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java index cca7f08a2eb..adc27baa4c3 100644 --- a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java +++ b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java @@ -38,6 +38,8 @@ * @author Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * */ +// TODO #proofRefactor +@Deprecated public class WitnessProcedureContract extends ModernAnnotations { private static final long serialVersionUID = 1L; From 6d4caa8b7e83601a45cead7a0c8f58a6c1eddd7f Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 12:12:59 +0100 Subject: [PATCH 54/91] remove HoareAnnotation class --- .../InvariantSynthesisStarter.java | 6 +- .../smt/predicates/HoareAnnotation.java | 114 ------------------ .../ultimate/lib/proofs/ProofAnnotation.java | 89 ++++++++++++++ .../IcfgFloydHoareValidityCheck.java | 20 --- .../TraceAbstractionStarter.java | 5 +- 5 files changed, 97 insertions(+), 137 deletions(-) delete mode 100644 trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java create mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/ProofAnnotation.java diff --git a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java index ffc208b0432..b52567bec36 100644 --- a/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java +++ b/trunk/source/InvariantSynthesis/src/de/uni_freiburg/informatik/ultimate/plugins/generator/invariantsynthesis/InvariantSynthesisStarter.java @@ -59,6 +59,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.proofs.ProofAnnotation; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareMapping; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareUtils; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IcfgFloydHoareValidityCheck; @@ -178,7 +179,10 @@ public InvariantSynthesisStarter(final IUltimateServiceProvider services, final floydHoare = new FloydHoareMapping<>(predicateOfInitialLocations, predicateOfErrorLocations, invariants); FloydHoareUtils.writeHoareAnnotationToLogger(icfg, floydHoare, mLogger, true); - // TODO #proofRefactor pass the annotation 'floydHoare' to other plugins + + // Annotate the ICFG with the computed Floyd-Hoare annotation, so it can be consumed by other plugins. + ProofAnnotation.addProof(icfg, floydHoare); + mOverallResult = Result.SAFE; } } else { diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java deleted file mode 100644 index 4a3bf59c260..00000000000 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/HoareAnnotation.java +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright (C) 2014-2015 Daniel Dietsch (dietsch@informatik.uni-freiburg.de) - * Copyright (C) 2012-2015 Matthias Heizmann (heizmann@informatik.uni-freiburg.de) - * Copyright (C) 2015 University of Freiburg - * - * This file is part of the ULTIMATE TraceAbstraction plug-in. - * - * The ULTIMATE TraceAbstraction plug-in is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE TraceAbstraction plug-in is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE TraceAbstraction plug-in. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE TraceAbstraction plug-in, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE TraceAbstraction plug-in grant you additional permission - * to convey the resulting work. - */ -package de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates; - -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; - -import de.uni_freiburg.informatik.ultimate.core.model.models.IElement; -import de.uni_freiburg.informatik.ultimate.core.model.models.IPayload; -import de.uni_freiburg.informatik.ultimate.core.model.models.annotation.IAnnotations; -import de.uni_freiburg.informatik.ultimate.core.model.models.annotation.Visualizable; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; -import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; -import de.uni_freiburg.informatik.ultimate.logic.Term; - -/** - * Specifies properties of a state in a graph representation of a system. These properties are - *

- * - * @author heizmann@informatik.uni-freiburg.de - */ -// TODO #proofRefactor get rid of this class -@Deprecated -public class HoareAnnotation extends SPredicate { - - private static final String KEY = HoareAnnotation.class.getSimpleName(); - private static final long serialVersionUID = 72852101509650437L; - - private final ManagedScript mMgdScript; - @Visualizable - private final boolean mIsUnknown = false; - - private final List mInvariants = new ArrayList<>(); - - public HoareAnnotation(final IcfgLocation programPoint, final int serialNumber, - final PredicateFactory predicateFactory, final ManagedScript mgdScript) { - super(programPoint, serialNumber, new String[] { programPoint.getProcedure() }, - mgdScript.getScript().term("true"), new HashSet<>(), new HashSet<>(), null); - mMgdScript = mgdScript; - } - - public void addInvariant(final IPredicate pred) { - mVars.addAll(pred.getVars()); - mFunctions.addAll(pred.getFuns()); - mInvariants.add(pred.getFormula()); - } - - @Override - public Term getFormula() { - return SmtUtils.and(mMgdScript.getScript(), mInvariants); - } - - @Override - public Term getClosedFormula() { - return PredicateUtils.computeClosedFormula(getFormula(), mVars, mMgdScript); - } - - @Override - public boolean isUnknown() { - return mIsUnknown; - } - - public void annotate(final IElement node) { - if (node == null) { - return; - } - node.getPayload().getAnnotations().put(KEY, this); - } - - public static HoareAnnotation getAnnotation(final IElement node) { - if (node != null && node.hasPayload()) { - final IPayload payload = node.getPayload(); - if (payload.hasAnnotation()) { - final IAnnotations annot = payload.getAnnotations().get(KEY); - if (annot != null) { - return (HoareAnnotation) annot; - } - } - } - return null; - } - -} diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/ProofAnnotation.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/ProofAnnotation.java new file mode 100644 index 00000000000..ca38fe445c3 --- /dev/null +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/ProofAnnotation.java @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2024 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2024 University of Freiburg + * + * This file is part of the ULTIMATE Proofs Library. + * + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE Proofs Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE Proofs Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.proofs; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +import de.uni_freiburg.informatik.ultimate.core.lib.models.annotation.ModernAnnotations; +import de.uni_freiburg.informatik.ultimate.core.model.models.IElement; +import de.uni_freiburg.informatik.ultimate.core.model.models.annotation.IAnnotations; +import de.uni_freiburg.informatik.ultimate.core.model.models.annotation.Visualizable; + +/** + * Annotates a program (such as an ICFG) with one or more proofs. + * + * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + */ +public class ProofAnnotation extends ModernAnnotations { + private static final long serialVersionUID = -9142656546325935187L; + + private static final String KEY = ProofAnnotation.class.getName(); + + @Visualizable + private final List mProofs; + + private ProofAnnotation(final List proofs) { + mProofs = proofs; + } + + public List getProofs() { + return Collections.unmodifiableList(mProofs); + } + + public static void addProof(final IElement element, final Object proof) { + final IAnnotations annot = element.getPayload().getAnnotations().get(KEY); + + final var proofs = new ArrayList<>(); + if (annot != null) { + proofs.addAll(((ProofAnnotation) annot).getProofs()); + } + proofs.add(proof); + + final var newAnnot = new ProofAnnotation(proofs); + element.getPayload().getAnnotations().put(KEY, newAnnot); + } + + public static List getProofs(final IElement element) { + final IAnnotations annot = element.getPayload().getAnnotations().get(KEY); + if (annot == null) { + return Collections.emptyList(); + } + return ((ProofAnnotation) annot).getProofs(); + } + + public static List getProofs(final IElement element, final Class typeOfProof) { + final IAnnotations annot = element.getPayload().getAnnotations().get(KEY); + if (annot == null) { + return Collections.emptyList(); + } + return ((ProofAnnotation) annot).getProofs().stream().filter(typeOfProof::isInstance).map(typeOfProof::cast) + .collect(Collectors.toList()); + } +} diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java index 71e173e94a6..8a81884f562 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/IcfgFloydHoareValidityCheck.java @@ -39,8 +39,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.MonolithicHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.HoareAnnotation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.ManagedScript; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Triple; @@ -116,22 +114,4 @@ private Iterable> getSuccessors(final LOC state return state.getIncomingEdges().stream().filter(clazz::isInstance) .map(e -> new Pair<>(clazz.cast(e), (LOC) e.getTarget())).collect(Collectors.toList()); } - - @Deprecated - public static final class IcfgHoareAnnotation implements IFloydHoareAnnotation { - @Override - public IPredicate getPrecondition() { - return null; - } - - @Override - public IPredicate getPostcondition() { - return null; - } - - @Override - public IPredicate getAnnotation(final LOC state) { - return HoareAnnotation.getAnnotation(state); - } - } } \ No newline at end of file diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java index e35f0ac3f15..ca41c09fa70 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java @@ -68,6 +68,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareUtils; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.FloydHoareValidityCheck.MissingAnnotationBehaviour; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IFloydHoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IcfgFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.independence.abstraction.ICopyActionFactory; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.petrinetlbe.PetriNetLargeBlockEncoding.IPLBECompositionFactory; @@ -178,8 +179,8 @@ private void runCegarLoops(final IIcfg icfg) { && results.stream().allMatch(a -> a.resultStream().noneMatch(Result::isLimit))) { final IBacktranslationService backTranslatorService = mServices.getBacktranslationService(); - // TODO #proofRefactor - final var annotation = new IcfgFloydHoareValidityCheck.IcfgHoareAnnotation<>(); + // TODO #proofRefactor Retrieve the actual annotation and check it + final IFloydHoareAnnotation annotation = null; assert new IcfgFloydHoareValidityCheck<>(mServices, icfg, annotation, true, MissingAnnotationBehaviour.IGNORE, true).getResult() : "incorrect Hoare annotation"; From 098a0b3079896a36b71dc8b8f194c8705bd5fb90 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 12:13:12 +0100 Subject: [PATCH 55/91] fix typo --- .../CegarLoopConcurrentAutomata.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 6076b4eddfd..3b9e0c603ba 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -145,7 +145,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); // TODO #proofRefactor - final boolean explointSigmaStarConcatOfIA = mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa(); + final boolean exploitSigmaStarConcatOfIA = mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa(); final INestedWordAutomaton oldAbstraction = mAbstraction; final IPredicateUnifier predicateUnifier = mRefinementResult.getPredicateUnifier(); @@ -173,7 +173,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { oldAbstraction, determinized, psd2, false); } else { diff = new Difference<>(new AutomataLibraryServices(getServices()), mStateFactoryForRefinement, - oldAbstraction, determinized, psd2, explointSigmaStarConcatOfIA); + oldAbstraction, determinized, psd2, exploitSigmaStarConcatOfIA); } determinized.switchToReadonlyMode(); assert !mCsToolkit.getManagedScript().isLocked(); From 7b35f9c4acbaa67edfa25688ffd2fd6a64a3f640 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 12:55:31 +0100 Subject: [PATCH 56/91] propagate proof updater down into AbstractCegarLoop --- .../lib/proofs/IAbstractionSanityCheck.java | 31 +++++++++++++ .../traceabstraction/AbstractCegarLoop.java | 43 ++++++++++--------- .../traceabstraction/BasicCegarLoop.java | 17 +++----- .../traceabstraction/CegarLoopFactory.java | 6 +-- .../traceabstraction/NwaCegarLoop.java | 10 ++--- .../concurrency/CegarLoopForPetriNet.java | 7 ++- .../concurrency/PartialOrderCegarLoop.java | 4 +- .../TraceAbstractionConcurrentObserver.java | 2 +- 8 files changed, 75 insertions(+), 45 deletions(-) create mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IAbstractionSanityCheck.java diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IAbstractionSanityCheck.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IAbstractionSanityCheck.java new file mode 100644 index 00000000000..6173bd1136b --- /dev/null +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IAbstractionSanityCheck.java @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2024 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) + * Copyright (C) 2024 University of Freiburg + * + * This file is part of the ULTIMATE Proofs Library. + * + * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with the ULTIMATE Proofs Library. If not, see . + * + * Additional permission under GNU GPL version 3 section 7: + * If you modify the ULTIMATE Proofs Library, or any covered work, by linking + * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), + * containing parts covered by the terms of the Eclipse Public License, the + * licensors of the ULTIMATE Proofs Library grant you additional permission + * to convey the resulting work. + */ +package de.uni_freiburg.informatik.ultimate.lib.proofs; + +public interface IAbstractionSanityCheck { + public boolean performSanityCheck(A abstraction); +} diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 351fe138992..98b58e85473 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -48,7 +48,6 @@ import de.uni_freiburg.informatik.ultimate.automata.AutomatonDefinitionPrinter.NamedAutomaton; import de.uni_freiburg.informatik.ultimate.automata.IAutomaton; import de.uni_freiburg.informatik.ultimate.automata.IRun; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.INestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.nestedword.INwaBasis; import de.uni_freiburg.informatik.ultimate.automata.nestedword.NestedWordAutomaton; import de.uni_freiburg.informatik.ultimate.automata.petrinet.IPetriNet; @@ -72,16 +71,13 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IncrementalHoareTripleChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.interpolant.IInterpolantGenerator; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskFileIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.TaskIdentifier; -import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.HoareAnnotationPositions; -import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaFloydHoareValidityCheck; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IAbstractionSanityCheck; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.logic.Script; @@ -103,7 +99,7 @@ * * @author heizmann@informatik.uni-freiburg.de */ -public abstract class AbstractCegarLoop, A extends IAutomaton> { +public abstract class AbstractCegarLoop, A extends IAutomaton, T> { private static final boolean DUMP_BIGGEST_AUTOMATON = false; protected final ILogger mLogger; @@ -125,7 +121,11 @@ public abstract class AbstractCegarLoop, A extends * Intermediate layer to encapsulate preferences. */ protected final TAPreferences mPref; - protected final boolean mComputeHoareAnnotation; + + /** + * Iteratively computes a proof artifact during CEGAR loop. May be null. + */ + protected final T mProofUpdater; /** * Set of error location whose reachability is analyzed by this CEGAR loop. @@ -200,7 +200,7 @@ public abstract class AbstractCegarLoop, A extends protected AbstractCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, final A initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final boolean computeHoareAnnotation) { + final Set errorLocs, final T proofUpdater) { mServices = services; mLogger = services.getLoggingService().getLogger(Activator.PLUGIN_ID); mSimplificationTechnique = taPrefs.getSimplificationTechnique(); @@ -213,7 +213,7 @@ protected AbstractCegarLoop(final IUltimateServiceProvider services, final Debug mPredicateFactory = predicateFactory; mPref = taPrefs; mErrorLocs = errorLocs; - mComputeHoareAnnotation = computeHoareAnnotation; + mProofUpdater = proofUpdater; // TODO: TaskIdentifier should probably be provided by caller mTaskIdentifier = new SubtaskFileIdentifier(null, mIcfg.getIdentifier() + "_" + name); mResultBuilder = new CegarLoopResultBuilder(); @@ -482,16 +482,20 @@ private void refineAbstractionInternal(final AutomatonType automatonType) mLogger.info("%s automaton has %s", automatonType, mInterpolAutomaton.sizeInformation()); } - // TODO #proofRefactor - // TODO should proof updaters have methods for sanity checks like this? - if (mComputeHoareAnnotation && mPref.getHoareAnnotationPositions() == HoareAnnotationPositions.All) { - final var unifier = new PredicateUnifier(mLogger, mServices, mCsToolkit.getManagedScript(), - mPredicateFactory, mCsToolkit.getSymbolTable(), mSimplificationTechnique, mXnfConversionTechnique); - assert NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, mCsToolkit.getManagedScript(), - new IncrementalHoareTripleChecker(mCsToolkit, false), unifier, - (INestedWordAutomaton) mAbstraction, true).getResult() : "Not inductive"; + if (mProofUpdater != null && mProofUpdater instanceof IAbstractionSanityCheck) { + assert ((IAbstractionSanityCheck) mProofUpdater).performSanityCheck(mAbstraction); } + // TODO #proofRefactor move the code below into Floyd/Hoare proof producer (method performSanityCheck) + // + // if (mProofUpdater != null && mPref.getHoareAnnotationPositions() == HoareAnnotationPositions.All) { + // final var unifier = new PredicateUnifier(mLogger, mServices, mCsToolkit.getManagedScript(), + // mPredicateFactory, mCsToolkit.getSymbolTable(), mSimplificationTechnique, mXnfConversionTechnique); + // assert NwaFloydHoareValidityCheck.forInterpolantAutomaton(mServices, mCsToolkit.getManagedScript(), + // new IncrementalHoareTripleChecker(mCsToolkit, false), unifier, + // (INestedWordAutomaton) mAbstraction, true).getResult() : "Not inductive"; + // } + if (mIteration <= mPref.watchIteration() && mPref.artifact() == Artifact.ABSTRACTION) { mArtifactAutomaton = mAbstraction; } @@ -860,9 +864,8 @@ public CegarLoopResult getResult() { floydHoareAutomata = null; } - // TODO #proofRefactor - // TODO make sure CEGAR loops transmit necessary info to proof producers (e.g. in finish() or isAbsEmpty()) - // TODO let callers decide if they want to extract proofs using CegarLoopResult::hasProvenAnything() + // TODO #proofRefactor let CEGAR loops transmit info to proof producers (e.g. in finish() or isAbsEmpty()) + // TODO #proofRefactor let callers decide what to do with proofs (use CegarLoopResult::hasProvenAnything) // if (mComputeHoareAnnotation && mResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE)) { // computeIcfgHoareAnnotation(); // writeHoareAnnotationToLogger(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index f94957ce26e..04c69c9212a 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -134,8 +134,8 @@ * @param * The type of abstraction refined by the CEGAR loop */ -public abstract class BasicCegarLoop, A extends IAutomaton> - extends AbstractCegarLoop { +public abstract class BasicCegarLoop, A extends IAutomaton, T> + extends AbstractCegarLoop { private static final boolean NON_EA_INDUCTIVITY_CHECK = false; @@ -158,11 +158,10 @@ public abstract class BasicCegarLoop, A extends IAu public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final boolean computeHoareAnnotation, - final IUltimateServiceProvider services, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { + final Set errorLocs, final T proofUpdater, final IUltimateServiceProvider services, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(services, name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - computeHoareAnnotation); + proofUpdater); mPathProgramDumpController = new PathProgramDumpController<>(getServices(), mPref, mIcfg); InterpolationTechnique interpolation = taPrefs.interpolation(); @@ -174,10 +173,8 @@ public BasicCegarLoop(final DebugIdentifier name, final A initialAbstraction, fi mStoreFloydHoareAutomata = taPrefs.getFloydHoareAutomataReuse() != FloydHoareAutomataReuse.NONE; mStateFactoryForRefinement = stateFactoryForRefinement; - - // TODO #proofRefactor - mPredicateFactoryInterpolantAutomata = new PredicateFactoryForInterpolantAutomata( - super.mCsToolkit.getManagedScript(), mPredicateFactory, computeHoareAnnotation); + mPredicateFactoryInterpolantAutomata = new PredicateFactoryForInterpolantAutomata(mCsToolkit.getManagedScript(), + mPredicateFactory, proofUpdater != null); mPredicateFactoryResultChecking = new PredicateFactoryResultChecking(mPredicateFactory); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 2d9c1e58271..56b95df24b5 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -123,8 +123,8 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr * * @return the newly created CEGAR loop */ - public BasicCegarLoop constructCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, - final IIcfg root, final Set errorLocs, + public BasicCegarLoop constructCegarLoop(final IUltimateServiceProvider services, + final DebugIdentifier name, final IIcfg root, final Set errorLocs, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton, final List> rawFloydHoareAutomataFromFile) { mCegarLoopBenchmark = new CegarLoopStatisticsGenerator(); @@ -204,7 +204,7 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService return new PredicateFactory(services, csToolkit.getManagedScript(), csToolkit.getSymbolTable()); } - private BasicCegarLoop createFiniteAutomataCegarLoop(final IUltimateServiceProvider services, + private BasicCegarLoop createFiniteAutomataCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, final IIcfg root, final PredicateFactory predicateFactory, final Set errorLocs, final List> rawFloydHoareAutomataFromFile, diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 11ab9fa2913..c298c24a3f3 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -93,6 +93,7 @@ import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.PathProgram; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.PathProgram.PathProgramConstructionResult; +import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.NwaCegarLoop.ProofUpdater; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimization; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimization.AutomataMinimizationTimeout; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.errorabstraction.ErrorGeneralizationEngine; @@ -114,7 +115,8 @@ * @author Christian Schilling (schillic@informatik.uni-freiburg.de) * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) */ -public class NwaCegarLoop> extends BasicCegarLoop> { +public class NwaCegarLoop> + extends BasicCegarLoop, ProofUpdater> { private enum AutomatonType { FLOYD_HOARE("FloydHoare", "Fh"), ERROR("Error", "Err"); @@ -155,8 +157,6 @@ public String getShortString() { private final AStarHeuristic mAStarHeuristic; private final Integer mAStarRandomHeuristicSeed; - protected final ProofUpdater mProofUpdater; - public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> NwaCegarLoop( final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, @@ -164,8 +164,8 @@ public & IUpdateOnMinimization & IFinishWit final boolean computeHoareAnnotation, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); - mProofUpdater = proofUpdater == null ? null : new ProofUpdater<>(proofUpdater); + proofUpdater == null ? null : new ProofUpdater<>(proofUpdater), services, transitionClazz, + stateFactoryForRefinement); mErrorGeneralizationEngine = new ErrorGeneralizationEngine<>(services); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index 85f5ca092d7..313593810c2 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -98,7 +98,7 @@ import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; public class CegarLoopForPetriNet> - extends BasicCegarLoop> { + extends BasicCegarLoop, Object> { public enum SizeReduction { REMOVE_DEAD, REMOVE_REDUNDANT_FLOW @@ -151,7 +151,7 @@ public CegarLoopForPetriNet(final DebugIdentifier name, final BoundedPetriNet rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, final Set errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, false, services, + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, null, services, transitionClazz, stateFactoryForRefinement); mPetriClStatisticsGenerator = new PetriCegarLoopStatisticsGenerator(mCegarLoopBenchmark); mCounterexampleCache = new CounterexampleCache<>(); @@ -520,8 +520,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { throw new UnsupportedOperationException(); } - // TODO #proofRefactor - if (mComputeHoareAnnotation) { + if (mProofUpdater != null) { assert checkInterpolantAutomatonInductivity(dia) : "Not inductive"; } if (mPref.dumpAutomata()) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java index db1676f5d38..5b8a511ee5d 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java @@ -114,7 +114,7 @@ * The type of statements in the program. */ public class PartialOrderCegarLoop> - extends BasicCegarLoop> { + extends BasicCegarLoop, Object> { private final PartialOrderMode mPartialOrderMode; private final InformationStorageFactory mFactory = new InformationStorageFactory(); @@ -134,7 +134,7 @@ public PartialOrderCegarLoop(final DebugIdentifier name, final TAPreferences taPrefs, final Set errorLocs, final IUltimateServiceProvider services, final List> independenceProviders, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, false, services, + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, null, services, transitionClazz, stateFactoryForRefinement); assert !mPref.applyOneShotPOR() : "Turn off one-shot partial order reduction when using this CEGAR loop."; diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java index aab09be3fe7..76d69877bea 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java @@ -113,7 +113,7 @@ public boolean process(final IElement root) { } } - BasicCegarLoop abstractCegarLoop; + BasicCegarLoop abstractCegarLoop; final AllErrorsAtOnceDebugIdentifier name = TraceAbstractionStarter.AllErrorsAtOnceDebugIdentifier.INSTANCE; final PredicateFactoryRefinement stateFactoryForRefinement = new PredicateFactoryRefinement(mServices, csToolkit.getManagedScript(), predicateFactory, false, Collections.emptySet()); From 806e1ff7e4ab59978edc08ee8182605c9bc7e284 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 12:55:51 +0100 Subject: [PATCH 57/91] rename and document parameter --- .../PredicateFactoryForInterpolantAutomata.java | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryForInterpolantAutomata.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryForInterpolantAutomata.java index 769af5a0a6a..7a95afda269 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryForInterpolantAutomata.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/PredicateFactoryForInterpolantAutomata.java @@ -58,14 +58,22 @@ public class PredicateFactoryForInterpolantAutomata IConcurrentProductStateFactory, IPetriNet2FiniteAutomatonStateFactory, IMinimizationStateFactory, IDeterminizeStateFactory { - protected final boolean mComputeHoareAnnotation; + protected final boolean mPreserveTerms; private final IPredicate mEmtpyStack; protected final ManagedScript mMgdScript; protected final PredicateFactory mPredicateFactory; + /** + * + * @param mgdScript + * @param predicateFactory + * @param preserveTerms + * Whether the factory should preserve the terms for computed predicates. If this is {@code false}, the + * factory may replace some terms by "don't care". + */ public PredicateFactoryForInterpolantAutomata(final ManagedScript mgdScript, - final PredicateFactory predicateFactory, final boolean computeHoareAnnotation) { - mComputeHoareAnnotation = computeHoareAnnotation; + final PredicateFactory predicateFactory, final boolean preserveTerms) { + mPreserveTerms = preserveTerms; mMgdScript = mgdScript; mPredicateFactory = predicateFactory; mEmtpyStack = mPredicateFactory.newEmptyStackPredicate(); @@ -73,7 +81,7 @@ public PredicateFactoryForInterpolantAutomata(final ManagedScript mgdScript, @Override public IPredicate determinize(final Map> down2up) { - if (mComputeHoareAnnotation) { + if (mPreserveTerms) { final List upPredicates = new ArrayList<>(); for (final IPredicate caller : down2up.keySet()) { for (final IPredicate current : down2up.get(caller)) { From 38790be2a911851336ad41a4eda91a95e11ac17c Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 12:56:37 +0100 Subject: [PATCH 58/91] update some TODO comments --- .../ultimate/lib/proofs/floydhoare/FloydHoareUtils.java | 3 --- .../ultimate/core/lib/models/annotation/WitnessInvariant.java | 2 +- .../core/lib/models/annotation/WitnessProcedureContract.java | 2 +- .../generator/traceabstraction/preferences/TAPreferences.java | 2 +- .../CegarLoopConcurrentAutomata.java | 1 - 5 files changed, 3 insertions(+), 7 deletions(-) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java index ad0ab9b89a7..a724ca31d0e 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/FloydHoareUtils.java @@ -114,7 +114,6 @@ public static void createInvariantResults(final String pluginName, final IIcfg result = new ProcedureContractResult<>(pluginName, exit, backTranslatorService, procName, requiresFormula, ensuresFormula); reporter.accept(result); - - // TODO #proofRefactor new WitnessProcedureContract(result.getRequiresResult(), result.getEnsuresResult()).annotate(exit); } } diff --git a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java index bf42b4b5351..a37e9925228 100644 --- a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java +++ b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessInvariant.java @@ -36,7 +36,7 @@ * @author Daniel Dietsch (dietsch@informatik.uni-freiburg.de) * */ -// TODO #proofRefactor +// TODO #witnessRefactor Remove this annotation. WitnessPrinter should work with a Floyd/Hoare proof directly. @Deprecated public class WitnessInvariant extends ModernAnnotations { diff --git a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java index adc27baa4c3..22ba3beaf3c 100644 --- a/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java +++ b/trunk/source/Library-UltimateCore/src/de/uni_freiburg/informatik/ultimate/core/lib/models/annotation/WitnessProcedureContract.java @@ -38,7 +38,7 @@ * @author Matthias Heizmann (heizmann@informatik.uni-freiburg.de) * */ -// TODO #proofRefactor +// TODO #witnessRefactor Remove this annotation. WitnessPrinter should work with a Floyd/Hoare proof directly. @Deprecated public class WitnessProcedureContract extends ModernAnnotations { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java index 54fed6e4b6c..fe2e85ef2d6 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/preferences/TAPreferences.java @@ -344,7 +344,7 @@ public Concurrency getAutomataTypeConcurrency() { return mAutomataTypeConcurrency; } - // TODO #proofRefactor + // TODO #proofRefactor Remove this method // TODO #proofRefactor update all settings files to reflect the removal / changes to the corresponding settings @Deprecated public boolean computeHoareAnnotation() { diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 3b9e0c603ba..9b9d8790d2b 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -144,7 +144,6 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // howDifferentAreInterpolants(mInterpolAutomaton.getStates()); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); - // TODO #proofRefactor final boolean exploitSigmaStarConcatOfIA = mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa(); final INestedWordAutomaton oldAbstraction = mAbstraction; From 18f2a4f87152f74ec617c0d7770f102559108db5 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 18:48:10 +0100 Subject: [PATCH 59/91] narrow public signature of AbstractCegarLoop --- .../traceabstraction/AbstractCegarLoop.java | 8 ++++---- .../traceabstraction/BasicCegarLoop.java | 14 +++++++------- .../CegarLoopSWBnonRecursive.java | 2 +- .../IncrementalInclusionCegarLoop.java | 6 +++--- .../traceabstraction/NwaCegarLoop.java | 14 +++++++------- .../concurrency/CegarLoopForPetriNet.java | 18 +++++++++--------- .../concurrency/PartialOrderCegarLoop.java | 2 +- .../CegarLoopConcurrentAutomata.java | 6 +++--- .../TraceAbstractionConcurrentObserver.java | 4 ++-- .../TAwAFAsCegarLoop.java | 4 ++-- 10 files changed, 39 insertions(+), 39 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index 98b58e85473..d137ff52565 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -135,7 +135,7 @@ public abstract class AbstractCegarLoop, A extends /** * Current Iteration of this CEGAR loop. */ - protected int mIteration; + private int mIteration; /** * Accepting run of the abstraction obtained in this iteration. @@ -295,11 +295,11 @@ protected abstract Pair> isCounterexampleFeasi */ public abstract IElement getArtifact(); - public int getIteration() { + protected int getIteration() { return mIteration; } - public String errorLocs() { + private String errorLocs() { final Iterator it = mErrorLocs.iterator(); if (!it.hasNext()) { return "[]"; @@ -336,7 +336,7 @@ public final CegarLoopResult runCegar() { return r; } - public final CegarLoopResult startCegar() { + private final CegarLoopResult startCegar() { mIteration = 0; if (mLogger.isInfoEnabled()) { mLogger.info("======== Iteration %s == of CEGAR loop == %s ========", mIteration, mName); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index 04c69c9212a..f67f811a022 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -295,7 +295,7 @@ mAbstraction, new SubtaskIterationIdentifier(mTaskIdentifier, getIteration()), try { if (mPref.hasLimitPathProgramCount() && mPref.getLimitPathProgramCount() < mStrategyFactory .getPathProgramCache().getPathProgramCount(mCounterexample)) { - final String taskDescription = "bailout by path program count limit in iteration " + mIteration; + final String taskDescription = "bailout by path program count limit in iteration " + getIteration(); throw new TaskCanceledException(UserDefinedLimit.PATH_PROGRAM_ATTEMPTS, getClass(), taskDescription); } @@ -320,7 +320,7 @@ mAbstraction, new SubtaskIterationIdentifier(mTaskIdentifier, getIteration()), if (feasibility != LBool.SAT) { // dump path program if necessary mPathProgramDumpController.reportPathProgram(mCounterexample, mRefinementResult.somePerfectSequenceFound(), - mIteration); + getIteration()); } if (feasibility != LBool.UNSAT) { mLogger.info("Counterexample %s feasible", feasibility == LBool.SAT ? "is" : "might be"); @@ -455,9 +455,9 @@ private boolean checkPathProgramRemoval() return true; } final Set counterexampleLetters = mCounterexample.getWord().asSet(); - final PathProgramConstructionResult ppcr = PathProgram.constructPathProgram( - "PathprogramSubtractedCheckIteration" + mIteration, mIcfg, counterexampleLetters, - Collections.emptySet()); + final PathProgramConstructionResult ppcr = + PathProgram.constructPathProgram("PathprogramSubtractedCheckIteration" + getIteration(), mIcfg, + counterexampleLetters, Collections.emptySet()); final Map, IIcfgTransition> oldTransition2NewTransition = ppcr.getOldTransition2NewTransition(); final Map, IIcfgTransition> newTransition2OldTransition = @@ -511,7 +511,7 @@ protected void dumpOrAppendAutomatonForReuseIfEnabled( } else { printedAutomaton = automaton; } - new AutomatonDefinitionPrinter(services, "nwa" + mIteration, + new AutomatonDefinitionPrinter(services, "nwa" + getIteration(), mPref.dumpPath() + File.separator + filename, mPrintAutomataLabeling, "", !mFirstReuseDump, printedAutomaton); mFirstReuseDump = false; @@ -534,7 +534,7 @@ protected void checkEnhancement( } catch (final Error e) { // suppress any exception, throw assertion error instead } - throw new AssertionError("enhanced interpolant automaton in iteration " + mIteration + throw new AssertionError("enhanced interpolant automaton in iteration " + getIteration() + " broken: counterexample of length " + mCounterexample.getLength() + " not accepted" + (isOriginalBroken ? " (original was already broken)" : " (original is ok)")); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 2e5354748ba..3bdb8a8ed3e 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -718,7 +718,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // s_Logger.debug("[" + i + "]: " + mErrorPathHistory.get(i)); // } - mCegarLoopBenchmark.reportAbstractionSize(mAbstraction.size(), mIteration); + mCegarLoopBenchmark.reportAbstractionSize(mAbstraction.size(), getIteration()); mLogger.info("Abstraction has " + mNestedAbstraction.sizeInformation()); mLogger.info("Interpolant automaton has " + mInterpolAutomaton.sizeInformation()); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index 9680598ed72..10ae8a0d489 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -205,7 +205,7 @@ protected boolean isAbstractionEmpty() throws AutomataOperationCanceledException @Override protected boolean refineAbstraction() throws AutomataLibraryException { - mStateFactoryForRefinement.setIteration(super.mIteration); + mStateFactoryForRefinement.setIteration(getIteration()); // howDifferentAreInterpolants(mInterpolAutomaton.getStates()); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); @@ -281,7 +281,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { if (mPref.dumpAutomata()) { for (int i = 0; i < mInterpolantAutomata.size(); i++) { final String filename = - "IncrementalInclusion_Interation" + mIteration + "_InterpolantAutomaton" + i; + "IncrementalInclusion_Interation" + getIteration() + "_InterpolantAutomaton" + i; super.writeAutomatonToFile(mInterpolantAutomata.get(i), filename); } } @@ -305,7 +305,7 @@ private void switchAllInterpolantAutomataToReadOnlyMode() { if (mPref.dumpAutomata()) { for (int i = 0; i < mInterpolantAutomata.size(); i++) { final String filename = - "EnhancedInterpolantAutomaton_WhoseConstructionWasStartedIn_Iteration" + mIteration; + "EnhancedInterpolantAutomaton_WhoseConstructionWasStartedIn_Iteration" + getIteration(); super.writeAutomatonToFile(mInterpolantAutomata.get(i), filename); mInterpolantAutomata.get(i); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index c298c24a3f3..e84a73bb85d 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -226,7 +226,7 @@ protected boolean isAbstractionEmpty() throws AutomataOperationCanceledException if (mPref.hasLimitTraceHistogram() && traceHistogram.getMax() > mPref.getLimitTraceHistogram()) { final String taskDescription = - "bailout by trace histogram " + traceHistogram.toString() + " in iteration " + mIteration; + "bailout by trace histogram " + traceHistogram.toString() + " in iteration " + getIteration(); throw new TaskCanceledException(UserDefinedLimit.TRACE_HISTOGRAM, getClass(), taskDescription); } @@ -303,7 +303,7 @@ protected void constructErrorAutomaton() throws AutomataOperationCanceledExcepti mErrorGeneralizationEngine.constructErrorAutomaton(mCounterexample, mPredicateFactory, mRefinementResult.getPredicateUnifier(), mCsToolkit, mSimplificationTechnique, mXnfConversionTechnique, mIcfg.getCfgSmtToolkit().getSymbolTable(), mPredicateFactoryInterpolantAutomata, mAbstraction, - mIteration); + getIteration()); mInterpolAutomaton = null; final NestedWordAutomaton resultBeforeEnhancement = @@ -315,7 +315,7 @@ assert accepts(getServices(), resultBeforeEnhancement, mCounterexample.getWord() @Override protected boolean refineAbstraction() throws AutomataLibraryException { - mStateFactoryForRefinement.setIteration(mIteration); + mStateFactoryForRefinement.setIteration(getIteration()); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); final INestedWordAutomaton minuend = mAbstraction; @@ -329,7 +329,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { final InterpolantAutomatonEnhancement enhanceMode; final INwaOutgoingLetterAndTransitionProvider subtrahend; final boolean exploitSigmaStarConcatOfIa; - if (mErrorGeneralizationEngine.hasAutomatonInIteration(mIteration)) { + if (mErrorGeneralizationEngine.hasAutomatonInIteration(getIteration())) { mErrorGeneralizationEngine.startDifference(); automatonType = AutomatonType.ERROR; useErrorAutomaton = true; @@ -392,7 +392,7 @@ private void computeAutomataDifference(final INestedWordAutomaton } } - if (mErrorGeneralizationEngine.hasAutomatonInIteration(mIteration)) { + if (mErrorGeneralizationEngine.hasAutomatonInIteration(getIteration())) { mErrorGeneralizationEngine.stopDifference(minuend, mPredicateFactoryInterpolantAutomata, mPredicateFactoryResultChecking, mCounterexample, false); if (mFaultLocalizationMode != RelevanceAnalysisMode.NONE) { @@ -450,7 +450,7 @@ private RunningTaskInfo executeDifferenceTimeoutActions(final INestedWordAutomat final AutomatonType automatonType) throws AutomataLibraryException { final RunningTaskInfo runningTaskInfo = getDifferenceTimeoutRunningTaskInfo(minuend, subtrahend, subtrahendBeforeEnhancement, automatonType); - if (mErrorGeneralizationEngine.hasAutomatonInIteration(mIteration)) { + if (mErrorGeneralizationEngine.hasAutomatonInIteration(getIteration())) { mErrorGeneralizationEngine.stopDifference(minuend, mPredicateFactoryInterpolantAutomata, mPredicateFactoryResultChecking, mCounterexample, true); } @@ -515,7 +515,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac AutomataMinimization, IPredicate, L> am; try { final boolean computeOld2New = mProofUpdater != null; - am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, mIteration, + am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, getIteration(), predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, lcsProvider, true); } catch (final AutomataMinimizationTimeout e) { diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index 313593810c2..ca9daf3d653 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -164,7 +164,7 @@ public CegarLoopForPetriNet(final DebugIdentifier name, final BoundedPetriNet mPref.getLimitTraceHistogram()) { final String taskDescription = - "bailout by trace histogram " + traceHistogram.toString() + " in iteration " + mIteration; + "bailout by trace histogram " + traceHistogram.toString() + " in iteration " + getIteration(); throw new TaskCanceledException(UserDefinedLimit.TRACE_HISTOGRAM, getClass(), taskDescription); } return false; @@ -235,7 +235,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { super.writeAutomatonToFile(enhancementResult.getSecond().getResult(), filename); } - if (mIteration <= mPref.watchIteration() && mPref.artifact() == Artifact.NEG_INTERPOLANT_AUTOMATON) { + if (getIteration() <= mPref.watchIteration() && mPref.artifact() == Artifact.NEG_INTERPOLANT_AUTOMATON) { // Complement the interpolant automaton final INwaOutgoingLetterAndTransitionProvider nia = new ComplementDD<>(new AutomataLibraryServices(getServices()), @@ -366,7 +366,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { } } - mCegarLoopBenchmark.reportAbstractionSize(mAbstraction.size(), mIteration); + mCegarLoopBenchmark.reportAbstractionSize(mAbstraction.size(), getIteration()); mBiggestAbstractionTransitions = mAbstraction.getTransitions().size(); assert !acceptsPetriViaFA(getServices(), mAbstraction, mCounterexample.getWord()) : "Intersection broken!"; @@ -377,12 +377,12 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // statistic[0] + " internal transitions " + statistic[1] + // "call transitions " + statistic[2]+ " return transitions "); - if (mIteration <= mPref.watchIteration() + if (getIteration() <= mPref.watchIteration() && (mPref.artifact() == Artifact.ABSTRACTION || mPref.artifact() == Artifact.RCFG)) { mArtifactAutomaton = mAbstraction; } if (mPref.dumpAutomata()) { - final String filename = "Abstraction" + mIteration; + final String filename = "Abstraction" + getIteration(); writeAutomatonToFile(mAbstraction, filename); } return true; @@ -478,7 +478,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { (IPetriNet) mAbstraction, raw, universalSubtrahendLoopers); } catch (final AutomataOperationCanceledException tce) { final String taskDescription = generateOnDemandEnhancementCanceledMessage(interpolAutomaton, - universalSubtrahendLoopers, mAbstraction.getAlphabet(), mIteration); + universalSubtrahendLoopers, mAbstraction.getAlphabet(), getIteration()); tce.addRunningTaskInfo(new RunningTaskInfo(getClass(), taskDescription)); throw tce; } finally { @@ -491,7 +491,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { if (end - start > DEBUG_DUMP_DRYRUNRESULT_THRESHOLD * 1_000_000_000L) { final String filename = new SubtaskIterationIdentifier(mTaskIdentifier, getIteration()) + "_DifferencePairwiseOnDemandInput"; - final String atsHeaderMessage = "inputs of difference operation in iteration " + mIteration; + final String atsHeaderMessage = "inputs of difference operation in iteration " + getIteration(); final String atsCode = "PetriNet diff = differencePairwiseOnDemand(net, nwa);"; super.writeAutomataToFile(filename, atsHeaderMessage, atsCode, new NamedAutomaton<>("net", mAbstraction), new NamedAutomaton<>("nwa", dia)); @@ -524,7 +524,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { assert checkInterpolantAutomatonInductivity(dia) : "Not inductive"; } if (mPref.dumpAutomata()) { - final String filename = "InterpolantAutomatonDeterminized_Iteration" + mIteration; + final String filename = "InterpolantAutomatonDeterminized_Iteration" + getIteration(); writeAutomatonToFile(dia, filename); } // assert accepts(mServices, dia, mCounterexample.getWord(), diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java index 5b8a511ee5d..83691e77294 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java @@ -276,7 +276,7 @@ private IBudgetFunction makeBudget(final SleepMapReduction optBudget = new OptimisticBudget<>(new AutomataLibraryServices(mServices), mPOR.getDfsOrder(), mPOR.getSleepMapFactory(), this::createVisitor, reduction); - final double switchProbability = mPref.getCoinflipProbability(mIteration); + final double switchProbability = mPref.getCoinflipProbability(getIteration()); final long seed = mPref.coinflipSeed(); switch (mPref.useCoinflip()) { case OFF: diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 9b9d8790d2b..726e26f93e8 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -104,7 +104,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac AutomataMinimization, IMLPredicate, L> am; try { final boolean computeOld2New = mProofUpdater != null; - am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, mIteration, + am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, getIteration(), predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, lcsProvider, false); } catch (final AutomataMinimizationTimeout e) { @@ -140,7 +140,7 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac @Override protected boolean refineAbstraction() throws AutomataLibraryException { - mStateFactoryForRefinement.setIteration(super.mIteration); + mStateFactoryForRefinement.setIteration(getIteration()); // howDifferentAreInterpolants(mInterpolAutomaton.getStates()); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); @@ -196,7 +196,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { mAbstraction = diff.getResult(); // mDeadEndRemovalTime = diff.getDeadEndRemovalTime(); if (mPref.dumpAutomata()) { - final String filename = "InterpolantAutomaton_Iteration" + mIteration; + final String filename = "InterpolantAutomaton_Iteration" + getIteration(); super.writeAutomatonToFile(mInterpolAutomaton, filename); } diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java index 76d69877bea..7949dd787c5 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java @@ -142,7 +142,7 @@ public boolean process(final IElement root) { clrReporter.reportCegarLoopResult(result); clrReporter.reportAllSafeResultIfNecessary(result, errNodesOfAllProc.size()); - mLogger.info("Statistics - iterations: " + abstractCegarLoop.getIteration()); + // mLogger.info("Statistics - iterations: " + abstractCegarLoop.getIteration()); // s_Logger.info("Statistics - biggest abstraction: " + // abstractCegarLoop.mBiggestAbstractionSize + " states"); // s_Logger.info("Statistics - biggest abstraction in iteration: " + @@ -150,7 +150,7 @@ public boolean process(final IElement root) { String stat = ""; stat += "Statistics: "; - stat += " Iterations " + abstractCegarLoop.getIteration() + "."; + // stat += " Iterations " + abstractCegarLoop.getIteration() + "."; stat += " CFG has "; stat += petrifiedIcfg.getProgramPoints().size(); stat += " locations,"; diff --git a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java index e2dd9a5e567..0625947bd22 100644 --- a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java +++ b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TAwAFAsCegarLoop.java @@ -461,7 +461,7 @@ private AlternatingAutomaton computeAlternatingAutomaton(final Da @Override protected boolean refineAbstraction() throws AutomataLibraryException { // copied - mStateFactoryForRefinement.setIteration(super.mIteration); + mStateFactoryForRefinement.setIteration(getIteration()); mCegarLoopBenchmark.start(CegarLoopStatisticsDefinitions.AutomataDifference.toString()); final boolean explointSigmaStarConcatOfIA = mProofUpdater == null || mProofUpdater.exploitSigmaStarConcatOfIa(); @@ -507,7 +507,7 @@ protected boolean refineAbstraction() throws AutomataLibraryException { // copie mAbstraction = diff.getResult(); // mDeadEndRemovalTime = diff.getDeadEndRemovalTime(); if (mPref.dumpAutomata()) { - final String filename = "InterpolantAutomaton_Iteration" + mIteration; + final String filename = "InterpolantAutomaton_Iteration" + getIteration(); super.writeAutomatonToFile(mInterpolAutomaton, filename); } From f43013b09d947422bf141505fbff4ee6d555b80c Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Sun, 4 Feb 2024 18:52:53 +0100 Subject: [PATCH 60/91] simplify type signatures --- .../generator/traceabstraction/CegarLoopLocalResult.java | 3 +-- .../plugins/generator/traceabstraction/CegarLoopResult.java | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopLocalResult.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopLocalResult.java index aba6165f563..8f5380f1a75 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopLocalResult.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopLocalResult.java @@ -31,7 +31,6 @@ import de.uni_freiburg.informatik.ultimate.core.lib.exceptions.IRunningTaskStackProvider; import de.uni_freiburg.informatik.ultimate.core.lib.results.UnprovabilityReason; import de.uni_freiburg.informatik.ultimate.core.model.translation.IProgramExecution; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.AbstractCegarLoop.Result; @@ -40,7 +39,7 @@ * @author Daniel Dietsch (dietsch@informatik.uni-freiburg.de) * */ -public final class CegarLoopLocalResult> { +public final class CegarLoopLocalResult { private final IProgramExecution mProgramExecution; private final IRunningTaskStackProvider mRunningTaskStackProvider; private final List mUnprovabilityReasons; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java index ad633e640ec..aca32c04fde 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java @@ -32,7 +32,6 @@ import java.util.stream.Stream; import de.uni_freiburg.informatik.ultimate.core.model.models.IElement; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.AbstractCegarLoop.Result; @@ -40,7 +39,7 @@ import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; -public class CegarLoopResult> { +public class CegarLoopResult { private final IStatisticsDataProvider mCegarLoopStatisticsGenerator; private final IElement mArtifact; private final List, IPredicateUnifier>> mFloydHoareAutomata; From a5e34d2eddcf3ca71c76f2ec2fc74cabe07d46fe Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Mon, 5 Feb 2024 10:35:45 +0100 Subject: [PATCH 61/91] separate proof production from postprocessing CEGAR loops decide which kinds of proofs they provide and how. Disentangle possible postprocessing of proofs from CEGAR loops and proof production. --- .../lib/proofs/AbstractProofProducer.java | 83 ------------------- .../ultimate/lib/proofs/IProofProducer.java | 22 ----- .../floydhoare/NwaHoareProofProducer.java | 71 ++++++---------- .../IInitialAbstractionProvider.java | 31 +++---- .../NwaInitialAbstractionProvider.java | 24 ++---- .../traceabstraction/AbstractCegarLoop.java | 35 ++++---- .../traceabstraction/BasicCegarLoop.java | 5 +- .../traceabstraction/CegarLoopFactory.java | 16 ++-- .../traceabstraction/CegarLoopResult.java | 32 +++++-- .../CegarLoopResultReporter.java | 6 +- .../CegarLoopSWBnonRecursive.java | 18 ++-- .../traceabstraction/EagerReuseCegarLoop.java | 16 ++-- .../IncrementalInclusionCegarLoop.java | 22 ++--- .../traceabstraction/LazyReuseCegarLoop.java | 16 ++-- .../traceabstraction/NwaCegarLoop.java | 68 +++------------ .../traceabstraction/ReuseCegarLoop.java | 14 ++-- .../TraceAbstractionStarter.java | 25 +++--- .../concurrency/CegarLoopForPetriNet.java | 5 +- .../concurrency/PartialOrderCegarLoop.java | 5 +- .../CegarLoopConcurrentAutomata.java | 2 +- .../TraceAbstractionConcurrentObserver.java | 18 ++-- .../META-INF/MANIFEST.MF | 1 + .../TraceAbstractionWithAFAsObserver.java | 2 +- 23 files changed, 185 insertions(+), 352 deletions(-) delete mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java deleted file mode 100644 index f053200b03a..00000000000 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/AbstractProofProducer.java +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) - * Copyright (C) 2023 University of Freiburg - * - * This file is part of the ULTIMATE Proofs Library. - * - * The ULTIMATE Proofs Library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE Proofs Library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE Proofs Library. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE Proofs Library, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE Proofs Library grant you additional permission - * to convey the resulting work. - */ -package de.uni_freiburg.informatik.ultimate.lib.proofs; - -/** - * Base class for implementations of {@link IProofProducer}. - * - * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) - * - * @param - * The type of abstraction for which a proof shall be produced (see {@link IProofProducer}). - * @param

- * The type of proof that shall be produced (see {@link IProofProducer}). - * @param - * The type of abstraction natively supported by the class that inherits from {@link AbstractProofProducer}. - * Proofs for other kinds of abstractions can be computed by post-processing. - * @param - * The type of proof natively supported by the class that inherits from {@link AbstractProofProducer}. Proofs - * of other kinds can be computed by post-processing. - */ -public abstract class AbstractProofProducer implements IProofProducer { - protected final A0 mProgram; - protected final IProofPostProcessor mPost; - - private P0 mInternalProof; - private P mProof; - - protected AbstractProofProducer(final A0 program, final IProofPostProcessor post) { - mProgram = program; - mPost = post; - - assert post.getTransformedProgram() == mProgram : "proof post processor program does not match"; - } - - @Override - public final A getProgram() { - return mPost.getOriginalProgram(); - } - - @Override - public final P getOrComputeProof() { - if (mProof == null) { - mProof = mPost.processProof(getOrComputeInternalProof()); - } - return mProof; - } - - protected final P0 getOrComputeInternalProof() { - if (mInternalProof == null) { - if (!isReadyToComputeProof()) { - throw new UnsupportedOperationException(getClass().getSimpleName() + " not yet ready to compute proof"); - } - mInternalProof = computeProof(); - } - return mInternalProof; - } - - protected abstract P0 computeProof(); -} diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java index 761e92329d3..96f1b25711d 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofProducer.java @@ -72,27 +72,5 @@ public interface IProofProducer { */ PROOF getOrComputeProof(); - /** - * Obtains a new proof producer which applies the given postprocessing to the proof artifact as it would be computed - * by this instance. The returned object should be an instance of the same class as this instance; implementing - * classes are encouraged to specialize the return type of this method. - * - * There is no guarantee that this proof producer remains valid, or if so, that computed proofs are shared between - * the instances. - * - * @param - * The type of program for which the post processor outputs a proof - * @param - * The type of proof artifact returned by the post processor - * @param postProcessor - * A post processor to apply to the computed proof. The program returned by - * {@link IProofPostProcessor#getTransformedProgram()} must equal the program returned by - * {@link #getProgram()}. - * @return A new proof producer that applies the given post processor after computing a proof, thereby computing a - * proof for the program returned by {@link IProofPostProcessor#getOriginalProgram()}. - */ - IProofProducer - withPostProcessor(IProofPostProcessor postProcessor); - IStatisticsDataProvider getStatistics(); } diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index 643780995f8..541396f1a71 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -44,9 +44,9 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; -import de.uni_freiburg.informatik.ultimate.lib.proofs.AbstractProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; @@ -68,62 +68,37 @@ * The type of proof which is produced. By default, this is {@link IFloydHoareAnnotation}, but it may differ * if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. */ -public final class NwaHoareProofProducer - extends AbstractProofProducer, IFloydHoareAnnotation> - implements IUpdateOnMinimization, IUpdateOnDifference, +public final class NwaHoareProofProducer + implements IProofProducer, IFloydHoareAnnotation>, + IUpdateOnMinimization, IUpdateOnDifference, IFinishWithFinalAbstraction> { private final IUltimateServiceProvider mServices; + private final INestedWordAutomaton mProgram; private final CfgSmtToolkit mCsToolkit; private final PredicateFactory mPredicateFactory; private final HoareProofSettings mPrefs; - private final Set mHoareAnnotationStates; private final HoareAnnotationFragments mHaf; private INestedWordAutomaton mFinalAbstraction; + + private IFloydHoareAnnotation mProof; private final Statistics mStatistics; - private NwaHoareProofProducer(final IUltimateServiceProvider services, + public NwaHoareProofProducer(final IUltimateServiceProvider services, final INestedWordAutomaton program, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final HoareProofSettings prefs, - final Set hoareAnnotationStates, - final IProofPostProcessor, IFloydHoareAnnotation, A, P> postProcessor) { - super(program, postProcessor); - + final Set hoareAnnotationStates) { mServices = services; + mProgram = program; mCsToolkit = csToolkit; mPredicateFactory = predicateFactory; mPrefs = prefs; - mHoareAnnotationStates = hoareAnnotationStates; mHaf = new HoareAnnotationFragments<>(services.getLoggingService().getLogger(getClass()), hoareAnnotationStates); - mStatistics = new Statistics(mPost); - } - - /** - * Creates a new proof producer without any postprocessing. - * - * @param - * the type of letters in the program automaton for which a proof is produced - * @param services - * @param program - * @param csToolkit - * @param predicateFactory - * @param prefs - * @param hoareAnnotationStates - * The states for which a Hoare annotation shall be produced. This can be a subset of the program - * automaton's states. - * @return - */ - public static - NwaHoareProofProducer, IFloydHoareAnnotation> - create(final IUltimateServiceProvider services, final INestedWordAutomaton program, - final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final HoareProofSettings prefs, final Set hoareAnnotationStates) { - return new NwaHoareProofProducer<>(services, program, csToolkit, predicateFactory, prefs, hoareAnnotationStates, - IProofPostProcessor.identity(program)); + mStatistics = new Statistics(); } public static Set computeHoareStates(final IIcfg icfg, @@ -133,13 +108,25 @@ public static Set computeHoareStates(final IIcfg PredicateUtils.getLocations(p).anyMatch(hoareLocs::contains)).collect(Collectors.toSet()); } + @Override + public INestedWordAutomaton getProgram() { + return mProgram; + } + @Override public boolean isReadyToComputeProof() { return mFinalAbstraction != null; } @Override - protected IFloydHoareAnnotation computeProof() { + public IFloydHoareAnnotation getOrComputeProof() { + if (mProof == null) { + mProof = computeProof(); + } + return mProof; + } + + private IFloydHoareAnnotation computeProof() { return mStatistics.measureProofComputation(() -> { final HoareAnnotationComposer clha = computeHoareAnnotationComposer(); final var floydHoare = clha.extractAnnotation(); @@ -157,13 +144,6 @@ private HoareAnnotationComposer computeHoareAnnotationComposer() { return new HoareAnnotationComposer(mCsToolkit, mPredicateFactory, mHaf, mServices); } - @Override - public NwaHoareProofProducer - withPostProcessor(final IProofPostProcessor postProcessor) { - return new NwaHoareProofProducer<>(mServices, mProgram, mCsToolkit, mPredicateFactory, mPrefs, - mHoareAnnotationStates, IProofPostProcessor.compose(mPost, postProcessor)); - } - @Override public IStatisticsDataProvider getStatistics() { return mStatistics; @@ -200,9 +180,8 @@ public void finish(final INestedWordAutomaton finalAbstraction) { private static final class Statistics extends AbstractStatisticsDataProvider { private final TimeTracker mProofTime = new TimeTracker(); - public Statistics(final IProofPostProcessor post) { + public Statistics() { declare("Hoare annotation time", () -> mProofTime, KeyType.TT_TIMER); - forward("Postprocessor statistics", post::getStatistics); } private T measureProofComputation(final Supplier computation) { diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java index 03dd1eff6d2..3eb967acf8b 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java @@ -34,7 +34,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; @@ -77,25 +77,26 @@ A getInitialAbstraction(IIcfg icfg, Set - * The type of proofs that shall be produced - * @param proofType - * The type of proofs that shall be produced - * @param proofUpdates - * If this is non-null, the returned producer must implement this interface. If no such producer can be - * found, fail instead. - * @return A proof producer satisfying the above constraints. + * @param + * The type of proof for the provided abstraction that is given + * @param + * The type of proof for the original ICFG that shall be produced + * @param inputProof + * The type of proof for the provided abstraction that is given + * @param outputProof + * The type of proof for the original ICFG that shall be produced + * @return A proof postprocessor satisfying the above constraints. * @throws UnsupportedOperationException - * if no proof producer satisfying the constraints is known + * if no proof postprocessor satisfying the constraints is known */ // TODO #proofRefactor - default IProofProducer getProofProducer(final Class proofType, - final Class proofUpdates) { - final String suffix = proofUpdates == null ? "" : (" while implementing " + proofUpdates.getSimpleName()); + default IProofPostProcessor, OUTPROOF> + getProofConverter(final Class inputProof, final Class outputProof) { throw new UnsupportedOperationException(getClass().getSimpleName() - + " does not support producing proofs of type " + proofType.getSimpleName() + suffix); + + " does not support producing proofs of type " + outputProof.getSimpleName()); } default IStatisticsDataProvider getStatistics() { diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index 1c360096421..ab1b1de8bfc 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -37,8 +37,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofConverter; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.HoareProofSettings; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IFloydHoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; @@ -96,24 +95,19 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg IProofProducer, PROOF> - getProofProducer(final Class proofType, final Class proofUpdates) { + public IProofPostProcessor, INPROOF, IIcfg, OUTPROOF> + getProofConverter(final Class inputProof, final Class outputProof) { if (!mPrefs.computeHoareAnnotation()) { return null; } - if (proofUpdates == null || proofUpdates.isAssignableFrom(NwaHoareProofProducer.class)) { - // TODO implement retrieval of suitable proof converter, if one exists - final IProofConverter, IFloydHoareAnnotation, PROOF> converter = - null; - - if (converter != null) { - return NwaHoareProofProducer - .create(mServices, mAbstraction, mCsToolkit, mPredicateFactory, mPrefs, mHoareStates) - .withPostProcessor(converter); - } + // TODO #proofRefactor implement retrieval of suitable proof converter, if one exists + final IProofPostProcessor, IFloydHoareAnnotation, IIcfg, OUTPROOF> converter = + null; + if (converter != null) { + return (IProofPostProcessor) converter; } - return IInitialAbstractionProvider.super.getProofProducer(proofType, proofUpdates); + return IInitialAbstractionProvider.super.getProofConverter(inputProof, outputProof); } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java index d137ff52565..b40d31a7bba 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/AbstractCegarLoop.java @@ -78,6 +78,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskFileIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.TaskIdentifier; import de.uni_freiburg.informatik.ultimate.lib.proofs.IAbstractionSanityCheck; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.logic.Script; @@ -99,7 +100,7 @@ * * @author heizmann@informatik.uni-freiburg.de */ -public abstract class AbstractCegarLoop, A extends IAutomaton, T> { +public abstract class AbstractCegarLoop, A extends IAutomaton, P, T extends IProofProducer> { private static final boolean DUMP_BIGGEST_AUTOMATON = false; protected final ILogger mLogger; @@ -330,13 +331,13 @@ public IStatisticsDataProvider getCegarLoopBenchmark() { */ protected abstract void finish(); - public final CegarLoopResult runCegar() { - final CegarLoopResult r = startCegar(); + public final CegarLoopResult runCegar() { + final CegarLoopResult r = startCegar(); finish(); return r; } - private final CegarLoopResult startCegar() { + private final CegarLoopResult startCegar() { mIteration = 0; if (mLogger.isInfoEnabled()) { mLogger.info("======== Iteration %s == of CEGAR loop == %s ========", mIteration, mName); @@ -610,7 +611,7 @@ private IUltimateServiceProvider updateTimeBudget(final IcfgLocation currentErro return parentServices; } - private CegarLoopResult performLimitReachedActions(final IRunningTaskStackProvider e) { + private CegarLoopResult performLimitReachedActions(final IRunningTaskStackProvider e) { mLogger.warn("Verification canceled: %s", e.printRunningTaskMessage()); final Result res; @@ -854,7 +855,7 @@ public CegarLoopResultBuilder addResult(final IcfgLocation loc, final Result res } - public CegarLoopResult getResult() { + public CegarLoopResult getResult() { final IStatisticsDataProvider cegarLoopBenchmarkGenerator = getCegarLoopBenchmark(); final List, IPredicateUnifier>> floydHoareAutomata; @@ -864,20 +865,24 @@ public CegarLoopResult getResult() { floydHoareAutomata = null; } - // TODO #proofRefactor let CEGAR loops transmit info to proof producers (e.g. in finish() or isAbsEmpty()) + // TODO #proofRefactor let CEGAR loops transmit info to proof producers (in isAbstractionEmpty()) // TODO #proofRefactor let callers decide what to do with proofs (use CegarLoopResult::hasProvenAnything) - // if (mComputeHoareAnnotation && mResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE)) { - // computeIcfgHoareAnnotation(); - // writeHoareAnnotationToLogger(); - // } else { - // mLogger.debug("Omitting computation of Hoare annotation"); - // } - return new CegarLoopResult<>(mResults, cegarLoopBenchmarkGenerator, getArtifact(), floydHoareAutomata); + P proof; + if (mProofUpdater != null && mResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE)) { + assert mProofUpdater.isReadyToComputeProof() : "Not ready to compute proof"; + mLogger.debug("Computing proof for CEGAR loop..."); + proof = mProofUpdater.getOrComputeProof(); + } else { + mLogger.debug("Omitting computation of proof for CEGAR loop"); + proof = null; + } + + return new CegarLoopResult<>(mResults, cegarLoopBenchmarkGenerator, getArtifact(), proof, + floydHoareAutomata); } public int remainingErrorLocs() { return mErrorLocs.size() - mResults.size(); } } - } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java index f67f811a022..cf61066a411 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/BasicCegarLoop.java @@ -95,6 +95,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskIterationIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult.BasicRefinementEngineResult; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaFloydHoareValidityCheck; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.cfg2automaton.Cfg2Automaton; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolationTechnique; @@ -134,8 +135,8 @@ * @param * The type of abstraction refined by the CEGAR loop */ -public abstract class BasicCegarLoop, A extends IAutomaton, T> - extends AbstractCegarLoop { +public abstract class BasicCegarLoop, A extends IAutomaton, P, T extends IProofProducer> + extends AbstractCegarLoop { private static final boolean NON_EA_INDUCTIVITY_CHECK = false; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 56b95df24b5..58a34fe5721 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -123,7 +123,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr * * @return the newly created CEGAR loop */ - public BasicCegarLoop constructCegarLoop(final IUltimateServiceProvider services, + public BasicCegarLoop constructCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, final IIcfg root, final Set errorLocs, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton, final List> rawFloydHoareAutomataFromFile) { @@ -141,9 +141,8 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr if (languageOperation != LanguageOperation.DIFFERENCE) { final var abstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); - // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new IncrementalInclusionCegarLoop<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, null, mComputeHoareAnnotation, services, languageOperation, mTransitionClazz, + errorLocs, mComputeHoareAnnotation, services, languageOperation, mTransitionClazz, stateFactoryForRefinement); } @@ -152,7 +151,7 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr stateFactoryForRefinement, witnessAutomaton); // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop return new CegarLoopSWBnonRecursive<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, null, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); + errorLocs, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); } if ((FORCE_FINITE_AUTOMATA_FOR_SEQUENTIAL_PROGRAMS && !IcfgUtils.isConcurrent(root)) @@ -204,14 +203,13 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService return new PredicateFactory(services, csToolkit.getManagedScript(), csToolkit.getSymbolTable()); } - private BasicCegarLoop createFiniteAutomataCegarLoop(final IUltimateServiceProvider services, + private NwaCegarLoop createFiniteAutomataCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, final IIcfg root, final PredicateFactory predicateFactory, final Set errorLocs, final List> rawFloydHoareAutomataFromFile, final PredicateFactoryRefinement stateFactoryForRefinement, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton) { - // TODO #proofRefactor extract proof producer from IInitialAbstractionProvider and pass to CEGAR loops final INestedWordAutomaton initialAbstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); final CfgSmtToolkit csToolkit = root.getCfgSmtToolkit(); @@ -219,15 +217,15 @@ private static PredicateFactory constructPredicateFactory(final IUltimateService switch (mPrefs.getFloydHoareAutomataReuse()) { case EAGER: return new EagerReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, null, mComputeHoareAnnotation, services, Collections.emptyList(), + errorLocs, mComputeHoareAnnotation, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case LAZY_IN_ORDER: return new LazyReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, null, mComputeHoareAnnotation, services, Collections.emptyList(), + errorLocs, mComputeHoareAnnotation, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); case NONE: return new NwaCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, errorLocs, - null, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); + mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); default: throw new AssertionError("Unknown Setting: " + mPrefs.getFloydHoareAutomataReuse()); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java index aca32c04fde..af4640e24e8 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResult.java @@ -39,18 +39,29 @@ import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; -public class CegarLoopResult { +/** + * Collects result information of a CEGAR loop. + * + * @param + * The type of transitions in the program analysed by the CEGAR loop + * @param

+ * The type of proof contained in this result (if any proof has been computed) + */ +public class CegarLoopResult { + private final Map> mLocalResults; private final IStatisticsDataProvider mCegarLoopStatisticsGenerator; private final IElement mArtifact; + private final P mProof; + private final List, IPredicateUnifier>> mFloydHoareAutomata; - private final Map> mLocalResults; public CegarLoopResult(final Map> localResults, - final IStatisticsDataProvider cegarLoopStatisticsGenerator, final IElement artifact, + final IStatisticsDataProvider cegarLoopStatisticsGenerator, final IElement artifact, final P proof, final List, IPredicateUnifier>> floydHoareAutomata) { mLocalResults = Collections.unmodifiableMap(localResults); mCegarLoopStatisticsGenerator = cegarLoopStatisticsGenerator; mArtifact = artifact; + mProof = proof; mFloydHoareAutomata = floydHoareAutomata; } @@ -70,11 +81,18 @@ public IElement getArtifact() { return mArtifact; } - public List, IPredicateUnifier>> getFloydHoareAutomata() { - return mFloydHoareAutomata; - } - public boolean hasProvenAnything() { return mLocalResults.values().stream().anyMatch(a -> a.getResult() == Result.SAFE); } + + /** + * A proof computed by the CEGAR loop which certifies the result. Returns null if no proof was computed. + */ + public P getProof() { + return mProof; + } + + public List, IPredicateUnifier>> getFloydHoareAutomata() { + return mFloydHoareAutomata; + } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResultReporter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResultReporter.java index 3dda230bd94..c88214d1641 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResultReporter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopResultReporter.java @@ -95,7 +95,7 @@ public CegarLoopResultReporter(final IUltimateServiceProvider services, final IL mReportFunction = reportFunction; } - public void reportCegarLoopResult(final CegarLoopResult clres) { + public void reportCegarLoopResult(final CegarLoopResult clres) { for (final Entry> entry : clres.getResults().entrySet()) { final CegarLoopLocalResult localResult = entry.getValue(); final IcfgLocation errorLoc = entry.getKey(); @@ -123,11 +123,11 @@ public void reportCegarLoopResult(final CegarLoopResult clres) { } } - public void reportAllSafeResultIfNecessary(final CegarLoopResult clres, final int numberOfErrorLocs) { + public void reportAllSafeResultIfNecessary(final CegarLoopResult clres, final int numberOfErrorLocs) { reportAllSafeResultIfNecessary(Collections.singletonList(clres), numberOfErrorLocs); } - public void reportAllSafeResultIfNecessary(final Collection> clres, + public void reportAllSafeResultIfNecessary(final Collection> clres, final int numberOfErrorLocs) { if (clres.stream().allMatch(a -> a.resultStream().allMatch(r -> r == Result.SAFE))) { final AllSpecificationsHoldResult result = diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 3bdb8a8ed3e..03cc660b7f6 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -63,9 +63,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.tracecheck.ITraceCheckPreferences.AssertCodeBlockOrder; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheckCraig; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheck; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; @@ -165,18 +162,17 @@ public class CegarLoopSWBnonRecursive> extends NwaC * @param csToolkit * @param taPrefs * @param errorLocs - * @param computeHoareAnnotation + * @param computeProof * @param services * @param transitionClazz */ - public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> CegarLoopSWBnonRecursive( - final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, - final IIcfg icfg, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, - final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + public CegarLoopSWBnonRecursive(final DebugIdentifier name, + final INestedWordAutomaton initialAbstraction, final IIcfg icfg, + final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, + final Set errorLocs, final boolean computeProof, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, - computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, services, + transitionClazz, stateFactoryForRefinement); mErrorPathHistory = new ArrayList<>(); mnofStates = new ArrayList<>(); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index c5a7ced5e5b..bb2f0df0406 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -48,9 +48,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; @@ -76,17 +73,16 @@ private enum MinimizeInitially { private static final boolean IDENTIFY_USELESS_FLOYDHOARE_AUTOMATA = false; // TODO can this method be removed? - public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> EagerReuseCegarLoop( - final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + public EagerReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, - final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, - computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFile, - transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFile, transitionClazz, + stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index 10ae8a0d489..a7f9ab4ba80 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -65,9 +65,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.NondeterministicInterpolantAutomaton; @@ -82,18 +79,17 @@ public class IncrementalInclusionCegarLoop> extends protected final List> mInterpolantAutomata = new ArrayList<>(); protected final List mHoareTripleChecker = new ArrayList<>(); - public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> IncrementalInclusionCegarLoop( - final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, - final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, - final boolean computeHoareAnnotation, final IUltimateServiceProvider services, - final LanguageOperation languageOperation, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, - computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + public IncrementalInclusionCegarLoop(final DebugIdentifier name, + final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, + final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, + final Set errorLocs, final boolean computeProof, + final IUltimateServiceProvider services, final LanguageOperation languageOperation, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + services, transitionClazz, stateFactoryForRefinement); mLanguageOperation = languageOperation; - if (proofUpdater != null) { + if (mProofUpdater != null) { throw new UnsupportedOperationException( "while using this CEGAR loop computation of proofs is unsupported "); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index 4af9d102d30..44c3abeaa19 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -52,9 +52,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; @@ -75,17 +72,16 @@ public class LazyReuseCegarLoop> extends ReuseCegar private Pair, IPredicateUnifier> mAutomatonAcceptingCounterexample; - public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> LazyReuseCegarLoop( - final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + public LazyReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, - final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFiles, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, - computeHoareAnnotation, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFiles, - transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFiles, transitionClazz, + stateFactoryForRefinement); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index e84a73bb85d..9c84ee8125f 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -57,7 +57,6 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.IsEmptyHeuristic.AStarHeuristic; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.IsEmptyHeuristic.IHeuristic; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.PowersetDeterminizer; -import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.ProductNwa; import de.uni_freiburg.informatik.ultimate.automata.nestedword.operations.oldapi.IOpWithDelayedDeadEndRemoval; import de.uni_freiburg.informatik.ultimate.automata.nestedword.senwa.DifferenceSenwa; import de.uni_freiburg.informatik.ultimate.core.lib.exceptions.RunningTaskInfo; @@ -83,9 +82,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskIterationIdentifier; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IFloydHoareAnnotation; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.solverbuilder.SMTFeatureExtractionTermClassifier.ScoringMethod; @@ -93,7 +91,6 @@ import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.PathProgram; import de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.cfg.PathProgram.PathProgramConstructionResult; -import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.NwaCegarLoop.ProofUpdater; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimization; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.automataminimization.AutomataMinimization.AutomataMinimizationTimeout; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.errorabstraction.ErrorGeneralizationEngine; @@ -115,8 +112,8 @@ * @author Christian Schilling (schillic@informatik.uni-freiburg.de) * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) */ -public class NwaCegarLoop> - extends BasicCegarLoop, ProofUpdater> { +public class NwaCegarLoop> extends + BasicCegarLoop, IFloydHoareAnnotation, NwaHoareProofProducer> { private enum AutomatonType { FLOYD_HOARE("FloydHoare", "Fh"), ERROR("Error", "Err"); @@ -157,16 +154,17 @@ public String getShortString() { private final AStarHeuristic mAStarHeuristic; private final Integer mAStarRandomHeuristicSeed; - public & IUpdateOnMinimization & IFinishWithFinalAbstraction>> NwaCegarLoop( - final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + public NwaCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, - final boolean computeHoareAnnotation, final IUltimateServiceProvider services, - final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, + final IUltimateServiceProvider services, final Class transitionClazz, + final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - proofUpdater == null ? null : new ProofUpdater<>(proofUpdater), services, transitionClazz, - stateFactoryForRefinement); - + computeProof + ? new NwaHoareProofProducer(services, initialAbstraction, csToolkit, predicateFactory, + taPrefs.getHoareSettings(), null /* TODO #proofRefactor */) + : null, + services, transitionClazz, stateFactoryForRefinement); mErrorGeneralizationEngine = new ErrorGeneralizationEngine<>(services); final IPreferenceProvider prefs = mServices.getPreferenceProvider(Activator.PLUGIN_ID); @@ -572,44 +570,4 @@ private static SearchStrategy getSearchStrategy(final IPreferenceProvider mPrefs throw new IllegalArgumentException(); } } - - // Annoyingly, this wrapper seems currently necessary due to Java's limited support for intersection types. - // The alternative is including a type parameter as below in the NwaCegarLoop itself. - protected static final class ProofUpdater & IUpdateOnDifference & IFinishWithFinalAbstraction>> - implements IUpdateOnMinimization, IUpdateOnDifference, - IFinishWithFinalAbstraction> { - private final T mUpdater; - - public ProofUpdater(final T updater) { - mUpdater = updater; - } - - @Override - public boolean exploitSigmaStarConcatOfIa() { - return mUpdater.exploitSigmaStarConcatOfIa(); - } - - @Override - public void updateOnIntersection( - final Map.ProductState>> fst2snd2res, - final IDoubleDeckerAutomaton result) { - mUpdater.updateOnIntersection(fst2snd2res, result); - } - - @Override - public void addDeadEndDoubleDeckers(final IOpWithDelayedDeadEndRemoval diff) { - mUpdater.addDeadEndDoubleDeckers(diff); - } - - @Override - public void updateOnMinimization(final Map old2New, - final INwaOutgoingLetterAndTransitionProvider abstraction) { - mUpdater.updateOnMinimization(old2New, abstraction); - } - - @Override - public void finish(final INestedWordAutomaton finalAbstraction) { - mUpdater.finish(finalAbstraction); - } - } } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java index 000b8cc447b..c7578da4c67 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java @@ -66,9 +66,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; @@ -107,16 +104,15 @@ public class ReuseCegarLoop> extends NwaCegarLoop & IUpdateOnMinimization & IFinishWithFinalAbstraction>> ReuseCegarLoop( - final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, + public ReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final T proofUpdater, - final boolean computeHoareAnnotation, final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, + final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofUpdater, - computeHoareAnnotation, services, transitionClazz, stateFactoryForRefinement); + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + services, transitionClazz, stateFactoryForRefinement); mFloydHoareAutomataFromOtherErrorLocations = floydHoareAutomataFromOtherLocations; mRawFloydHoareAutomataFromFile = rawFloydHoareAutomataFromFile; mFloydHoareAutomataFromFile = new ArrayList<>(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java index ca41c09fa70..a7ab8e10455 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/TraceAbstractionStarter.java @@ -158,7 +158,7 @@ private void runCegarLoops(final IIcfg icfg) { } mArtifact = null; - final List> results; + final List> results; if (IcfgUtils.isConcurrent(icfg)) { results = analyseConcurrentProgram(icfg); } else { @@ -209,7 +209,7 @@ private void logSettings() { * The CFG for the program (unpetrified). * @return */ - private List> analyseConcurrentProgram(final IIcfg icfg) { + private List> analyseConcurrentProgram(final IIcfg icfg) { if (icfg.getInitialNodes().size() > 1) { throw new UnsupportedOperationException("Library mode is not supported for concurrent programs. " + "There must be a unique entry procedure."); @@ -235,9 +235,9 @@ private List> analyseConcurrentProgram(final IIcfg> boolean - resultsHaveSufficientInstances(final List> results) { + resultsHaveSufficientInstances(final List> results) { boolean res = true; - for (final CegarLoopResult r : results) { + for (final CegarLoopResult r : results) { if (r.resultStream().allMatch(a -> a != Result.UNSAFE)) { continue; } @@ -256,7 +256,7 @@ private List> analyseConcurrentProgram(final IIcfg> analyseSequentialProgram(final IIcfg icfg) { + private List> analyseSequentialProgram(final IIcfg icfg) { return analyseProgram(icfg, x -> true); } @@ -271,9 +271,9 @@ private List> analyseSequentialProgram(final IIcfg> analyseProgram(final IIcfg icfg, - final Predicate> continueAnalysis) { - final List> results = new ArrayList<>(); + private List> analyseProgram(final IIcfg icfg, + final Predicate> continueAnalysis) { + final List> results = new ArrayList<>(); final List>> errorPartitions = partitionErrorLocations(icfg); final boolean multiplePartitions = errorPartitions.size() > 1; @@ -296,7 +296,7 @@ private List> analyseProgram(final IIcfg icfg, } final TraceAbstractionBenchmarks traceAbstractionBenchmark = createNewBenchmark(name, icfg); - final CegarLoopResult clres = + final CegarLoopResult clres = executeCegarLoop(services, name, icfg, traceAbstractionBenchmark, errorLocs); results.add(clres); finishedErrorSets++; @@ -405,10 +405,10 @@ private List>> partitionErrorLocations(f return List.of(new Pair<>(AllErrorsAtOnceDebugIdentifier.INSTANCE, errNodesOfAllProc)); } - private CegarLoopResult executeCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, + private CegarLoopResult executeCegarLoop(final IUltimateServiceProvider services, final DebugIdentifier name, final IIcfg icfg, final TraceAbstractionBenchmarks taBenchmark, final Set errorLocs) { - final CegarLoopResult clres = mCegarFactory + final CegarLoopResult clres = mCegarFactory .constructCegarLoop(services, name, icfg, errorLocs, mWitnessAutomaton, mRawFloydHoareAutomataFromFile) .runCegar(); @@ -557,7 +557,8 @@ public IElement getRootOfNewModel() { return mRootOfNewModel; } - private static > boolean hasSufficientThreadInstances(final CegarLoopResult clres) { + private static > boolean + hasSufficientThreadInstances(final CegarLoopResult clres) { return clres.getResults().entrySet().stream().filter(a -> a.getValue().getResult() == Result.UNSAFE) .noneMatch(a -> isInsufficientThreadsLocation(a.getKey())); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java index ca9daf3d653..21fa8203f2d 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/CegarLoopForPetriNet.java @@ -79,6 +79,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateCoverageChecker; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskIterationIdentifier; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.ILooperCheck; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.BasicCegarLoop; @@ -97,8 +98,8 @@ import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Triple; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; -public class CegarLoopForPetriNet> - extends BasicCegarLoop, Object> { +public class CegarLoopForPetriNet> extends + BasicCegarLoop, Object, IProofProducer, Object>> { public enum SizeReduction { REMOVE_DEAD, REMOVE_REDUNDANT_FLOW diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java index 83691e77294..ff01ab7d901 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java @@ -82,6 +82,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateWithConjuncts; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.BetterLockstepOrder; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.partialorder.LoopLockstepOrder.PredicateWithLastThread; @@ -113,8 +114,8 @@ * @param * The type of statements in the program. */ -public class PartialOrderCegarLoop> - extends BasicCegarLoop, Object> { +public class PartialOrderCegarLoop> extends + BasicCegarLoop, Object, IProofProducer, Object>> { private final PartialOrderMode mPartialOrderMode; private final InformationStorageFactory mFactory = new InformationStorageFactory(); diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index 726e26f93e8..f5437b737a9 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -78,7 +78,7 @@ public CegarLoopConcurrentAutomata(final DebugIdentifier name, final IIcfg ro final Set errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, createInitialAbstraction(services, csToolkit, predicateFactory, taPrefs, rootNode), rootNode, - csToolkit, predicateFactory, taPrefs, errorLocs, null, false, services, transitionClazz, + csToolkit, predicateFactory, taPrefs, errorLocs, false, services, transitionClazz, stateFactoryForRefinement); } diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java index 7949dd787c5..eaa73ee107d 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/TraceAbstractionConcurrentObserver.java @@ -113,27 +113,27 @@ public boolean process(final IElement root) { } } - BasicCegarLoop abstractCegarLoop; + BasicCegarLoop basicCegarLoop; final AllErrorsAtOnceDebugIdentifier name = TraceAbstractionStarter.AllErrorsAtOnceDebugIdentifier.INSTANCE; final PredicateFactoryRefinement stateFactoryForRefinement = new PredicateFactoryRefinement(mServices, csToolkit.getManagedScript(), predicateFactory, false, Collections.emptySet()); if (taPrefs.getAutomataTypeConcurrency() == Concurrency.PETRI_NET) { final IcfgCompositionFactory compositionFactory = new IcfgCompositionFactory(mServices, csToolkit); - abstractCegarLoop = new CegarLoopForPetriNet<>(name, + basicCegarLoop = new CegarLoopForPetriNet<>(name, CegarLoopFactory.createPetriAbstraction(mServices, compositionFactory, predicateFactory, IcfgEdge.class, taPrefs, false, (IIcfg) petrifiedIcfg, errNodesOfAllProc), petrifiedIcfg, csToolkit, predicateFactory, taPrefs, errNodesOfAllProc, mServices, IcfgEdge.class, stateFactoryForRefinement); } else if (taPrefs.getAutomataTypeConcurrency() == Concurrency.FINITE_AUTOMATA) { - abstractCegarLoop = new CegarLoopConcurrentAutomata<>(name, petrifiedIcfg, csToolkit, predicateFactory, + basicCegarLoop = new CegarLoopConcurrentAutomata<>(name, petrifiedIcfg, csToolkit, predicateFactory, taPrefs, errNodesOfAllProc, mServices, IcfgEdge.class, stateFactoryForRefinement); } else { throw new IllegalArgumentException(); } final TraceAbstractionBenchmarks traceAbstractionBenchmark = new TraceAbstractionBenchmarks(petrifiedIcfg); - final CegarLoopResult result = abstractCegarLoop.runCegar(); - final IStatisticsDataProvider cegarLoopBenchmarkGenerator = abstractCegarLoop.getCegarLoopBenchmark(); + final CegarLoopResult result = basicCegarLoop.runCegar(); + final IStatisticsDataProvider cegarLoopBenchmarkGenerator = basicCegarLoop.getCegarLoopBenchmark(); traceAbstractionBenchmark.aggregateBenchmarkData(cegarLoopBenchmarkGenerator); reportBenchmark(traceAbstractionBenchmark); @@ -161,19 +161,19 @@ public boolean process(final IElement root) { // abstractCegarLoop.mBiggestAbstractionIteration + " had "; // stat += abstractCegarLoop.mBiggestAbstractionSize; - if (abstractCegarLoop instanceof CegarLoopForPetriNet) { + if (basicCegarLoop instanceof CegarLoopForPetriNet) { stat += " conditions "; - final CegarLoopForPetriNet clj = (CegarLoopForPetriNet) abstractCegarLoop; + final CegarLoopForPetriNet clj = (CegarLoopForPetriNet) basicCegarLoop; stat += "and " + clj.mBiggestAbstractionTransitions + " transitions. "; stat += "Overall " + clj.mCoRelationQueries + "co-relation queries"; - } else if (abstractCegarLoop instanceof CegarLoopConcurrentAutomata) { + } else if (basicCegarLoop instanceof CegarLoopConcurrentAutomata) { stat += " states "; } else { throw new IllegalArgumentException(); } mLogger.warn(stat); - mGraphroot = abstractCegarLoop.getArtifact(); + mGraphroot = basicCegarLoop.getArtifact(); return false; } diff --git a/trunk/source/TraceAbstractionWithAFAs/META-INF/MANIFEST.MF b/trunk/source/TraceAbstractionWithAFAs/META-INF/MANIFEST.MF index 4e6b8128ea4..7c5ffcca793 100644 --- a/trunk/source/TraceAbstractionWithAFAs/META-INF/MANIFEST.MF +++ b/trunk/source/TraceAbstractionWithAFAs/META-INF/MANIFEST.MF @@ -9,6 +9,7 @@ Require-Bundle: de.uni_freiburg.informatik.ultimate.core, de.uni_freiburg.informatik.ultimate.lib.core, de.uni_freiburg.informatik.ultimate.lib.smtlibutils, de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils, + de.uni_freiburg.informatik.ultimate.lib.proofs, de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils, de.uni_freiburg.informatik.ultimate.boogie.preprocessor, de.uni_freiburg.informatik.ultimate.lib.smtlib, diff --git a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TraceAbstractionWithAFAsObserver.java b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TraceAbstractionWithAFAsObserver.java index 3c35e80405f..2f2bdd5c3e4 100644 --- a/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TraceAbstractionWithAFAsObserver.java +++ b/trunk/source/TraceAbstractionWithAFAs/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionwithafas/TraceAbstractionWithAFAsObserver.java @@ -98,7 +98,7 @@ public boolean process(final IElement root) { TraceAbstractionStarter.AllErrorsAtOnceDebugIdentifier.INSTANCE, rootAnnot, csToolkit, predicateFactory, taPrefs, errNodesOfAllProc, mServices, IcfgEdge.class, stateFactoryForRefinement); - final CegarLoopResult result = cegarLoop.runCegar(); + final CegarLoopResult result = cegarLoop.runCegar(); final CegarLoopResultReporter clrReporter = new CegarLoopResultReporter<>(mServices, mLogger, Activator.PLUGIN_ID, Activator.PLUGIN_NAME); From d3528af9f4e898bf6ec2a9fd4de9d8c44d9cd8e5 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Fri, 9 Feb 2024 08:53:30 +0100 Subject: [PATCH 62/91] work towards actually producing proofs --- .../ultimate/lib/proofs/IProofConverter.java | 98 ------------------- ...tProcessor.java => IProofTransformer.java} | 22 ++--- .../floydhoare/NwaHoareProofProducer.java | 7 -- .../IInitialAbstractionProvider.java | 7 +- .../NwaInitialAbstractionProvider.java | 17 ++-- ...ri2FiniteAutomatonAbstractionProvider.java | 19 +++- .../traceabstraction/CegarLoopFactory.java | 65 ++++++------ .../CegarLoopSWBnonRecursive.java | 8 +- .../traceabstraction/EagerReuseCegarLoop.java | 7 +- .../IncrementalInclusionCegarLoop.java | 5 +- .../traceabstraction/LazyReuseCegarLoop.java | 7 +- .../traceabstraction/NwaCegarLoop.java | 12 +-- .../traceabstraction/ReuseCegarLoop.java | 7 +- .../CegarLoopConcurrentAutomata.java | 2 +- 14 files changed, 104 insertions(+), 179 deletions(-) delete mode 100644 trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofConverter.java rename trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/{IProofPostProcessor.java => IProofTransformer.java} (81%) diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofConverter.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofConverter.java deleted file mode 100644 index 8b3efeac8bf..00000000000 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofConverter.java +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright (C) 2023 Dominik Klumpp (klumpp@informatik.uni-freiburg.de) - * Copyright (C) 2023 University of Freiburg - * - * This file is part of the ULTIMATE ModelCheckerUtils Library. - * - * The ULTIMATE ModelCheckerUtils Library is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published - * by the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * The ULTIMATE ModelCheckerUtils Library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with the ULTIMATE ModelCheckerUtils Library. If not, see . - * - * Additional permission under GNU GPL version 3 section 7: - * If you modify the ULTIMATE ModelCheckerUtils Library, or any covered work, by linking - * or combining it with Eclipse RCP (or a modified version of Eclipse RCP), - * containing parts covered by the terms of the Eclipse Public License, the - * licensors of the ULTIMATE ModelCheckerUtils Library grant you additional permission - * to convey the resulting work. - */ -package de.uni_freiburg.informatik.ultimate.lib.proofs; - -import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; - -/** - * A specialization of {@link IProofPostProcessor} for post-processings that implement only a proof format conversion, - * but do not reflect a program transformation. - * - * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) - * - * @param - * The type of program for which proofs are converted - * @param - * The type of proofs provided as input for the conversion - * @param - * The type of proofs produced as output of the conversion - */ -public interface IProofConverter - extends IProofPostProcessor { - PROGRAM getProgram(); - - @Override - default PROGRAM getOriginalProgram() { - return getProgram(); - } - - @Override - default PROGRAM getTransformedProgram() { - return getProgram(); - } - - static IProofConverter identity(final PROGRAM program) { - return new IProofConverter<>() { - @Override - public PROGRAM getProgram() { - return program; - } - - @Override - public PROOF processProof(final PROOF proof) { - return proof; - } - - @Override - public IStatisticsDataProvider getStatistics() { - throw new UnsupportedOperationException(); - } - }; - } - - static IProofConverter compose( - final IProofConverter left, - final IProofConverter right) { - assert right.getProgram() == left.getProgram(); - return new IProofConverter<>() { - @Override - public PROGRAM getProgram() { - return right.getProgram(); - } - - @Override - public OUTPROOF processProof(final INPROOF proof) { - return right.processProof(left.processProof(proof)); - } - - @Override - public IStatisticsDataProvider getStatistics() { - throw new UnsupportedOperationException(); - } - }; - } -} diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofPostProcessor.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofTransformer.java similarity index 81% rename from trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofPostProcessor.java rename to trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofTransformer.java index ebaa235c04e..f65fee790bd 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofPostProcessor.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/IProofTransformer.java @@ -29,14 +29,14 @@ import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; /** - * Post-processes a proof artifact of some kind, resulting in a new proof artifact. This post-processing may for - * instance be intended to accommodate a transformation of the program whose correctness is proven by the proof, or to - * implement a change of proof format, or both. + * Transforms a proof artifact of some kind, resulting in a new proof artifact. This transformation may for instance be + * intended to accommodate a transformation of the program whose correctness is proven by the proof, or to implement a + * change of proof format, or both. * * An instance of this interface is always bound to a specific pair of an original program and a transformed program * (which may be equal, if no program transformation took place). These programs should not change, and are typically * provided to the constructor. If a transformation took place, additional information may also be provided to the - * constructor, and be used to implement the post-processing. + * constructor, and be used to implement this transformation. * * @author Dominik Klumpp (klumpp@informatik.uni-freiburg.de) * @@ -49,7 +49,7 @@ * @param * The type of proof resulting from the post-processing */ -public interface IProofPostProcessor { +public interface IProofTransformer { OUTPROGRAM getOriginalProgram(); INPROGRAM getTransformedProgram(); @@ -65,8 +65,8 @@ public interface IProofPostProcessor { IStatisticsDataProvider getStatistics(); - static IProofPostProcessor identity(final PROGRAM program) { - return new IProofPostProcessor<>() { + static IProofTransformer identity(final PROGRAM program) { + return new IProofTransformer<>() { @Override public PROGRAM getOriginalProgram() { return program; @@ -90,11 +90,11 @@ public IStatisticsDataProvider getStatistics() { } static - IProofPostProcessor - compose(final IProofPostProcessor left, - final IProofPostProcessor right) { + IProofTransformer + compose(final IProofTransformer left, + final IProofTransformer right) { assert right.getTransformedProgram() == left.getOriginalProgram(); - return new IProofPostProcessor<>() { + return new IProofTransformer<>() { @Override public OUTPROGRAM getOriginalProgram() { return right.getOriginalProgram(); diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index 541396f1a71..d519964e2bf 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -45,7 +45,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.proofs.IFinishWithFinalAbstraction; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnDifference; import de.uni_freiburg.informatik.ultimate.lib.proofs.IUpdateOnMinimization; @@ -61,12 +60,6 @@ * * @param * The type of letters in the program automaton - * @param - * The type of abstraction for which a proof is produced. By default, this is {@link INestedWordAutomaton}, - * but it may differ if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. - * @param

- * The type of proof which is produced. By default, this is {@link IFloydHoareAnnotation}, but it may differ - * if the proof is post-processed (see {@link #withPostProcessor(IProofPostProcessor)}. */ public final class NwaHoareProofProducer implements IProofProducer, IFloydHoareAnnotation>, diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java index 3eb967acf8b..f4f9115eb26 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/IInitialAbstractionProvider.java @@ -34,7 +34,6 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; import de.uni_freiburg.informatik.ultimate.util.statistics.AbstractStatisticsDataProvider; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; @@ -93,10 +92,10 @@ A getInitialAbstraction(IIcfg icfg, Set IProofPostProcessor, OUTPROOF> - getProofConverter(final Class inputProof, final Class outputProof) { + default OUTPROOF backtranslateProof(final INPROOF inputProof, + final Class outputProofType) { throw new UnsupportedOperationException(getClass().getSimpleName() - + " does not support producing proofs of type " + outputProof.getSimpleName()); + + " does not support producing proofs of type " + outputProofType.getSimpleName()); } default IStatisticsDataProvider getStatistics() { diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java index ab1b1de8bfc..5e289db58ca 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/NwaInitialAbstractionProvider.java @@ -37,7 +37,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; -import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofPostProcessor; +import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofTransformer; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.HoareProofSettings; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IFloydHoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; @@ -95,19 +95,24 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg IProofPostProcessor, INPROOF, IIcfg, OUTPROOF> - getProofConverter(final Class inputProof, final Class outputProof) { + public OUTPROOF backtranslateProof(final INPROOF inputProof, + final Class outputProofType) { if (!mPrefs.computeHoareAnnotation()) { return null; } // TODO #proofRefactor implement retrieval of suitable proof converter, if one exists - final IProofPostProcessor, IFloydHoareAnnotation, IIcfg, OUTPROOF> converter = + final IProofTransformer, IFloydHoareAnnotation, IIcfg, OUTPROOF> converter = null; if (converter != null) { - return (IProofPostProcessor) converter; + return null; // (IProofTransformer) converter; } - return IInitialAbstractionProvider.super.getProofConverter(inputProof, outputProof); + return IInitialAbstractionProvider.super.backtranslateProof(inputProof, outputProofType); + } + + public NwaHoareProofProducer getProofProducer() { + return new NwaHoareProofProducer<>(mServices, mAbstraction, mCsToolkit, mPredicateFactory, mPrefs, + mHoareStates); } } diff --git a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java index 26065eee4f5..591809350ef 100644 --- a/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java +++ b/trunk/source/Library-TraceCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/tracecheckerutils/initialabstraction/Petri2FiniteAutomatonAbstractionProvider.java @@ -41,12 +41,17 @@ import de.uni_freiburg.informatik.ultimate.automata.petrinet.operations.LazyPetriNet2FiniteAutomaton; import de.uni_freiburg.informatik.ultimate.automata.petrinet.operations.PetriNet2FiniteAutomaton; import de.uni_freiburg.informatik.ultimate.automata.statefactory.IPetriNet2FiniteAutomatonStateFactory; +import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.CfgSmtToolkit; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.IcfgUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfg; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IIcfgTransition; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.HoareProofSettings; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.util.statistics.IStatisticsDataProvider; @@ -132,6 +137,9 @@ public IStatisticsDataProvider getStatistics() { public static class Eager> extends Petri2FiniteAutomatonAbstractionProvider> { + private INestedWordAutomaton mAbstraction; + private CfgSmtToolkit mCsToolkit; + /** * Create a new instance of the provider. * @@ -151,11 +159,14 @@ public Eager(final IInitialAbstractionProvider getInitialAbstraction(final IIcfg icfg, final Set errorLocs) throws AutomataLibraryException { + mCsToolkit = icfg.getCfgSmtToolkit(); + final IPetriNet net = mUnderlying.getInitialAbstraction(icfg, errorLocs); try { final Map hopelessCache = new HashMap<>(); - return new PetriNet2FiniteAutomaton<>(mServices, mStateFactory, net, + mAbstraction = new PetriNet2FiniteAutomaton<>(mServices, mStateFactory, net, s -> areAllLocationsHopeless(hopelessCache, errorLocs, s)).getResult(); + return mAbstraction; } catch (final PetriNetNot1SafeException e) { final Collection unsafePlaces = e.getUnsafePlaces(); if (unsafePlaces == null) { @@ -166,6 +177,12 @@ public INestedWordAutomaton getInitialAbstraction(final IIcfg getProofProducer(final IUltimateServiceProvider services, + final PredicateFactory predicateFactory, final HoareProofSettings prefs) { + return new NwaHoareProofProducer<>(services, mAbstraction, mCsToolkit, predicateFactory, prefs, + mAbstraction.getStates()); + } } /** diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java index 58a34fe5721..5e597b3294f 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopFactory.java @@ -53,6 +53,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.IInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.NwaInitialAbstractionProvider; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.initialabstraction.PartialOrderAbstractionProvider; @@ -70,6 +71,7 @@ import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.InterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TraceAbstractionPreferenceInitializer.LanguageOperation; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.witnesschecking.WitnessUtils.Property; +import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; import de.uni_freiburg.informatik.ultimate.witnessparser.graph.WitnessEdge; import de.uni_freiburg.informatik.ultimate.witnessparser.graph.WitnessNode; @@ -139,19 +141,18 @@ public CegarLoopFactory(final Class transitionClazz, final TAPreferences taPr csToolkit.getManagedScript(), predicateFactory, mComputeHoareAnnotation, hoareAnnotationLocs); if (languageOperation != LanguageOperation.DIFFERENCE) { - final var abstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, + final var pair = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); - return new IncrementalInclusionCegarLoop<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mComputeHoareAnnotation, services, languageOperation, mTransitionClazz, + return new IncrementalInclusionCegarLoop<>(name, pair.getFirst(), root, csToolkit, predicateFactory, mPrefs, + errorLocs, pair.getSecond(), services, languageOperation, mTransitionClazz, stateFactoryForRefinement); } if (mPrefs.interpolantAutomaton() == InterpolantAutomaton.TOTALINTERPOLATION) { - final var abstraction = createAutomataAbstraction(services, root, errorLocs, predicateFactory, + final var pair = createAutomataAbstraction(services, root, errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); - // TODO extract proof producer from IInitialAbstractionProvider and pass to CEGAR loop - return new CegarLoopSWBnonRecursive<>(name, abstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); + return new CegarLoopSWBnonRecursive<>(name, pair.getFirst(), root, csToolkit, predicateFactory, mPrefs, + errorLocs, pair.getSecond(), services, mTransitionClazz, stateFactoryForRefinement); } if ((FORCE_FINITE_AUTOMATA_FOR_SEQUENTIAL_PROGRAMS && !IcfgUtils.isConcurrent(root)) @@ -210,62 +211,68 @@ private NwaCegarLoop createFiniteAutomataCegarLoop(final IUltimateServiceProv final PredicateFactoryRefinement stateFactoryForRefinement, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton) { - final INestedWordAutomaton initialAbstraction = createAutomataAbstraction(services, root, - errorLocs, predicateFactory, stateFactoryForRefinement, witnessAutomaton); + final var pair = createAutomataAbstraction(services, root, errorLocs, predicateFactory, + stateFactoryForRefinement, witnessAutomaton); + final INestedWordAutomaton initialAbstraction = pair.getFirst(); + final NwaHoareProofProducer proofProducer = pair.getSecond(); final CfgSmtToolkit csToolkit = root.getCfgSmtToolkit(); switch (mPrefs.getFloydHoareAutomataReuse()) { case EAGER: return new EagerReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mComputeHoareAnnotation, services, Collections.emptyList(), - rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); + errorLocs, proofProducer, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, + mTransitionClazz, stateFactoryForRefinement); case LAZY_IN_ORDER: return new LazyReuseCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, - errorLocs, mComputeHoareAnnotation, services, Collections.emptyList(), - rawFloydHoareAutomataFromFile, mTransitionClazz, stateFactoryForRefinement); + errorLocs, proofProducer, services, Collections.emptyList(), rawFloydHoareAutomataFromFile, + mTransitionClazz, stateFactoryForRefinement); case NONE: return new NwaCegarLoop<>(name, initialAbstraction, root, csToolkit, predicateFactory, mPrefs, errorLocs, - mComputeHoareAnnotation, services, mTransitionClazz, stateFactoryForRefinement); + proofProducer, services, mTransitionClazz, stateFactoryForRefinement); default: throw new AssertionError("Unknown Setting: " + mPrefs.getFloydHoareAutomataReuse()); } } - private INestedWordAutomaton createAutomataAbstraction(final IUltimateServiceProvider services, - final IIcfg icfg, final Set errorLocs, final PredicateFactory predicateFactory, - final PredicateFactoryRefinement stateFactory, + private Pair, NwaHoareProofProducer> createAutomataAbstraction( + final IUltimateServiceProvider services, final IIcfg icfg, final Set errorLocs, + final PredicateFactory predicateFactory, final PredicateFactoryRefinement stateFactory, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton) { - return constructInitialAbstraction(createAutomataAbstractionProvider(services, IcfgUtils.isConcurrent(icfg), - predicateFactory, stateFactory, witnessAutomaton), icfg, errorLocs); + final var pair = createAutomataAbstractionProvider(services, IcfgUtils.isConcurrent(icfg), predicateFactory, + stateFactory, witnessAutomaton); + final var abstraction = constructInitialAbstraction(pair.getFirst(), icfg, errorLocs); + return new Pair<>(abstraction, pair.getSecond()); } - private IInitialAbstractionProvider> + private Pair>, NwaHoareProofProducer> createAutomataAbstractionProvider(final IUltimateServiceProvider services, final boolean isConcurrent, final PredicateFactory predicateFactory, final PredicateFactoryRefinement stateFactory, final INwaOutgoingLetterAndTransitionProvider witnessAutomaton) { if (!isConcurrent) { - final IInitialAbstractionProvider> provider = - new NwaInitialAbstractionProvider<>(services, stateFactory, mPrefs.interprocedural(), - predicateFactory, mPrefs.getHoareSettings()); + final var provider = new NwaInitialAbstractionProvider(services, stateFactory, mPrefs.interprocedural(), + predicateFactory, mPrefs.getHoareSettings()); if (witnessAutomaton == null) { - return provider; + return new Pair<>(provider, provider.getProofProducer()); } - return new WitnessAutomatonAbstractionProvider<>(services, predicateFactory, stateFactory, provider, - witnessAutomaton, Property.NON_REACHABILITY); + return new Pair<>(new WitnessAutomatonAbstractionProvider<>(services, predicateFactory, stateFactory, + provider, witnessAutomaton, Property.NON_REACHABILITY), null); } final var netProvider = createPetriAbstractionProvider(services, predicateFactory, false); if (!mPrefs.applyOneShotPOR()) { - return new Petri2FiniteAutomatonAbstractionProvider.Eager<>(netProvider, stateFactory, + final var petriProvider = new Petri2FiniteAutomatonAbstractionProvider.Eager<>(netProvider, stateFactory, new AutomataLibraryServices(services)); + return new Pair<>(petriProvider, + petriProvider.getProofProducer(services, predicateFactory, mPrefs.getHoareSettings())); } - return new PartialOrderAbstractionProvider<>( + + return new Pair<>(new PartialOrderAbstractionProvider<>( // Partial Order reductions aim to avoid the explicit construction of the full finite automaton. // Hence we use the lazy abstraction provider. new Petri2FiniteAutomatonAbstractionProvider.Lazy<>(netProvider, stateFactory, new AutomataLibraryServices(services)), services, stateFactory, predicateFactory, mPrefs.getPartialOrderMode(), mPrefs.getDfsOrderType(), - mPrefs.getDfsOrderSeed()); + mPrefs.getDfsOrderSeed()), null); } @Deprecated diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java index 03cc660b7f6..7bd465d0f84 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/CegarLoopSWBnonRecursive.java @@ -63,6 +63,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.tracecheck.ITraceCheckPreferences.AssertCodeBlockOrder; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.InterpolatingTraceCheckCraig; import de.uni_freiburg.informatik.ultimate.lib.tracecheckerutils.singletracecheck.TraceCheck; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; @@ -169,9 +170,10 @@ public class CegarLoopSWBnonRecursive> extends NwaC public CegarLoopSWBnonRecursive(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg icfg, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final boolean computeProof, final IUltimateServiceProvider services, - final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, services, + final Set errorLocs, final NwaHoareProofProducer proofProducer, + final IUltimateServiceProvider services, final Class transitionClazz, + final PredicateFactoryRefinement stateFactoryForRefinement) { + super(name, initialAbstraction, icfg, csToolkit, predicateFactory, taPrefs, errorLocs, proofProducer, services, transitionClazz, stateFactoryForRefinement); mErrorPathHistory = new ArrayList<>(); mnofStates = new ArrayList<>(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java index bb2f0df0406..1f05bd89208 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/EagerReuseCegarLoop.java @@ -48,6 +48,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.preferences.TAPreferences; import de.uni_freiburg.informatik.ultimate.util.datastructures.relation.Pair; @@ -75,12 +76,12 @@ private enum MinimizeInitially { // TODO can this method be removed? public EagerReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, - final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, + final NwaHoareProofProducer proofProducer, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofProducer, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFile, transitionClazz, stateFactoryForRefinement); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java index a7f9ab4ba80..ec0fde764d7 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/IncrementalInclusionCegarLoop.java @@ -65,6 +65,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.DeterministicInterpolantAutomaton; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.NondeterministicInterpolantAutomaton; @@ -82,10 +83,10 @@ public class IncrementalInclusionCegarLoop> extends public IncrementalInclusionCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, final TAPreferences taPrefs, - final Set errorLocs, final boolean computeProof, + final Set errorLocs, final NwaHoareProofProducer proofProducer, final IUltimateServiceProvider services, final LanguageOperation languageOperation, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofProducer, services, transitionClazz, stateFactoryForRefinement); mLanguageOperation = languageOperation; diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java index 44c3abeaa19..46c356d787b 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/LazyReuseCegarLoop.java @@ -52,6 +52,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.logic.Script.LBool; import de.uni_freiburg.informatik.ultimate.logic.Term; import de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.interpolantautomata.transitionappender.AbstractInterpolantAutomaton; @@ -74,12 +75,12 @@ public class LazyReuseCegarLoop> extends ReuseCegar public LazyReuseCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, - final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, + final NwaHoareProofProducer proofProducer, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFiles, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofProducer, services, floydHoareAutomataFromOtherLocations, rawFloydHoareAutomataFromFiles, transitionClazz, stateFactoryForRefinement); } diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 9c84ee8125f..465e9d5c8a0 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -156,14 +156,10 @@ public String getShortString() { public NwaCegarLoop(final DebugIdentifier name, final INestedWordAutomaton initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, - final IUltimateServiceProvider services, final Class transitionClazz, - final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, - computeProof - ? new NwaHoareProofProducer(services, initialAbstraction, csToolkit, predicateFactory, - taPrefs.getHoareSettings(), null /* TODO #proofRefactor */) - : null, + final TAPreferences taPrefs, final Set errorLocs, + final NwaHoareProofProducer proofProducer, final IUltimateServiceProvider services, + final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofProducer, services, transitionClazz, stateFactoryForRefinement); mErrorGeneralizationEngine = new ErrorGeneralizationEngine<>(services); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java index c7578da4c67..e3e306b0717 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/ReuseCegarLoop.java @@ -66,6 +66,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.IncrementalPlicationChecker.Validity; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.SimplificationTechnique; import de.uni_freiburg.informatik.ultimate.lib.smtlibutils.SmtUtils.XnfConversionTechnique; @@ -106,12 +107,12 @@ public class ReuseCegarLoop> extends NwaCegarLoop initialAbstraction, final IIcfg rootNode, final CfgSmtToolkit csToolkit, final PredicateFactory predicateFactory, - final TAPreferences taPrefs, final Set errorLocs, final boolean computeProof, - final IUltimateServiceProvider services, + final TAPreferences taPrefs, final Set errorLocs, + final NwaHoareProofProducer proofProducer, final IUltimateServiceProvider services, final List, IPredicateUnifier>> floydHoareAutomataFromOtherLocations, final List> rawFloydHoareAutomataFromFile, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { - super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, computeProof, + super(name, initialAbstraction, rootNode, csToolkit, predicateFactory, taPrefs, errorLocs, proofProducer, services, transitionClazz, stateFactoryForRefinement); mFloydHoareAutomataFromOtherErrorLocations = floydHoareAutomataFromOtherLocations; mRawFloydHoareAutomataFromFile = rawFloydHoareAutomataFromFile; diff --git a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java index f5437b737a9..527cb9d4ca2 100644 --- a/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java +++ b/trunk/source/TraceAbstractionConcurrent/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstractionconcurrent/CegarLoopConcurrentAutomata.java @@ -78,7 +78,7 @@ public CegarLoopConcurrentAutomata(final DebugIdentifier name, final IIcfg ro final Set errorLocs, final IUltimateServiceProvider services, final Class transitionClazz, final PredicateFactoryRefinement stateFactoryForRefinement) { super(name, createInitialAbstraction(services, csToolkit, predicateFactory, taPrefs, rootNode), rootNode, - csToolkit, predicateFactory, taPrefs, errorLocs, false, services, transitionClazz, + csToolkit, predicateFactory, taPrefs, errorLocs, null, services, transitionClazz, stateFactoryForRefinement); } From be8f228c274d8893d0ccdaf350adef5d4ecdd587 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 8 Aug 2024 14:01:49 +0200 Subject: [PATCH 63/91] deduplicate and unify helper methods --- .../buchiautomizer/BuchiAutomizerUtils.java | 17 ----------------- .../generator/buchiautomizer/LassoCheck.java | 3 ++- .../cegar/BuchiAutomatonCegarLoop.java | 4 ++-- .../smt/predicates/PredicateUtils.java | 14 ++++++++++++-- .../floydhoare/NwaHoareProofProducer.java | 2 +- .../traceabstraction/NwaCegarLoop.java | 10 ++-------- .../concurrency/PartialOrderCegarLoop.java | 9 ++------- 7 files changed, 21 insertions(+), 38 deletions(-) diff --git a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/BuchiAutomizerUtils.java b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/BuchiAutomizerUtils.java index 944b7d4fc4a..176aa625eb5 100644 --- a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/BuchiAutomizerUtils.java +++ b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/BuchiAutomizerUtils.java @@ -29,10 +29,6 @@ package de.uni_freiburg.informatik.ultimate.plugins.generator.buchiautomizer; -import java.util.Arrays; -import java.util.Set; -import java.util.stream.Collectors; - import de.uni_freiburg.informatik.ultimate.automata.AutomataLibraryServices; import de.uni_freiburg.informatik.ultimate.automata.AutomatonDefinitionPrinter; import de.uni_freiburg.informatik.ultimate.automata.AutomatonDefinitionPrinter.Format; @@ -41,10 +37,7 @@ import de.uni_freiburg.informatik.ultimate.automata.nestedword.NestedRun; import de.uni_freiburg.informatik.ultimate.automata.nestedword.VpAlphabet; import de.uni_freiburg.informatik.ultimate.core.model.services.IUltimateServiceProvider; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IMLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; /** * @author Matthias Heizmann (heizmann@informatik.uni-freiburg.de) @@ -67,16 +60,6 @@ public static boolean isEmptyStem(final NestedRun stem) { return stem.getLength() == 1; } - public static Set getLocations(final IPredicate pred) { - if (pred instanceof ISLPredicate) { - return Set.of(((ISLPredicate) pred).getProgramPoint()); - } - if (pred instanceof IMLPredicate) { - return Arrays.stream(((IMLPredicate) pred).getProgramPoints()).collect(Collectors.toSet()); - } - throw new UnsupportedOperationException("Unsupported type " + pred.getClass()); - } - public static VpAlphabet getVpAlphabet(final IAutomaton automaton) { if (automaton instanceof INwaBasis) { return ((INwaBasis) automaton).getVpAlphabet(); diff --git a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/LassoCheck.java b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/LassoCheck.java index 6703819ec6b..44f53cec386 100644 --- a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/LassoCheck.java +++ b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/LassoCheck.java @@ -79,6 +79,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.variables.IProgramNonOldVar; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.TaskIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngine; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; @@ -238,7 +239,7 @@ public LassoCheck(final CfgSmtToolkit csToolkit, final PredicateFactory predicat mBspm = bspm; mCounterexample = counterexample; final IPredicate honda = counterexample.getLoop().getStateAtPosition(0); - mModifiableGlobalsAtHonda = BuchiAutomizerUtils.getLocations(honda).stream() + mModifiableGlobalsAtHonda = PredicateUtils.streamLocations(honda) .flatMap(x -> mCsToolkit.getModifiableGlobalsTable().getModifiedBoogieVars(x.getProcedure()).stream()) .collect(Collectors.toSet()); mLassoCheckIdentifier = lassoCheckIdentifier; diff --git a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiAutomatonCegarLoop.java b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiAutomatonCegarLoop.java index fd5faf931e6..b898e36cdf7 100644 --- a/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiAutomatonCegarLoop.java +++ b/trunk/source/BuchiAutomizer/src/de/uni_freiburg/informatik/ultimate/plugins/generator/buchiautomizer/cegar/BuchiAutomatonCegarLoop.java @@ -56,8 +56,8 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.plugins.generator.buchiautomizer.Activator; -import de.uni_freiburg.informatik.ultimate.plugins.generator.buchiautomizer.BuchiAutomizerUtils; import de.uni_freiburg.informatik.ultimate.plugins.generator.buchiautomizer.BuchiCegarLoopBenchmark; import de.uni_freiburg.informatik.ultimate.plugins.generator.buchiautomizer.BuchiCegarLoopBenchmarkGenerator; import de.uni_freiburg.informatik.ultimate.plugins.generator.buchiautomizer.RankVarConstructor; @@ -222,7 +222,7 @@ protected INwaOutgoingLetterAndTransitionProvider reduceAbstracti try { am = new AutomataMinimization<>(mServices, result, automataMinimization, false, mIteration, mStateFactoryForRefinement, -1, null, null, -1, mPredicateFactoryResultChecking, - BuchiAutomizerUtils::getLocations, false); + PredicateUtils::getLocations, false); } catch (final AutomataMinimizationTimeout e) { mBenchmarkGenerator.addAutomataMinimizationData(e.getStatistics()); throw e.getAutomataOperationCanceledException(); diff --git a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java index e966129848c..39b969c70a3 100644 --- a/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java +++ b/trunk/source/Library-ModelCheckerUtils/src/de/uni_freiburg/informatik/ultimate/lib/modelcheckerutils/smt/predicates/PredicateUtils.java @@ -414,14 +414,24 @@ public static IcfgLocation getLocation(final IPredicate pred) { throw new IllegalArgumentException("predicate does not offer program point: " + pred); } - public static Stream getLocations(final IPredicate pred) { + public static Set getLocations(final IPredicate pred) { + if (pred instanceof ISLPredicate) { + return Set.of(((ISLPredicate) pred).getProgramPoint()); + } + if (pred instanceof IMLPredicate) { + return Set.of(((IMLPredicate) pred).getProgramPoints()); + } + throw new UnsupportedOperationException("Unsupported type " + pred.getClass()); + } + + public static Stream streamLocations(final IPredicate pred) { if (pred instanceof ISLPredicate) { return Stream.of(((ISLPredicate) pred).getProgramPoint()); } if (pred instanceof IMLPredicate) { return Arrays.stream(((IMLPredicate) pred).getProgramPoints()); } - return Stream.of(); + throw new UnsupportedOperationException("Unsupported type " + pred.getClass()); } private static Term eliminateVars(final IUltimateServiceProvider services, final ManagedScript mgdScript, diff --git a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java index d519964e2bf..b50161da8b6 100644 --- a/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java +++ b/trunk/source/Library-Proofs/src/de/uni_freiburg/informatik/ultimate/lib/proofs/floydhoare/NwaHoareProofProducer.java @@ -98,7 +98,7 @@ public static Set computeHoareStates(final IIcfg abstraction, final HoareAnnotationPositions hoarePositions) { final var hoareLocs = hoarePositions.getLocations(icfg); return abstraction.getStates().stream() - .filter(p -> PredicateUtils.getLocations(p).anyMatch(hoareLocs::contains)).collect(Collectors.toSet()); + .filter(p -> PredicateUtils.streamLocations(p).anyMatch(hoareLocs::contains)).collect(Collectors.toSet()); } @Override diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java index 465e9d5c8a0..14f0ba7b92b 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/NwaCegarLoop.java @@ -30,10 +30,8 @@ package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; -import java.util.HashSet; import java.util.Map; import java.util.Map.Entry; import java.util.Set; @@ -75,12 +73,11 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.IcfgLocation; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.cfg.structure.debugidentifiers.DebugIdentifier; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.hoaretriple.IHoareTripleChecker; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IMLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.IPredicateUnifier; -import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUnifier; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.taskidentifier.SubtaskIterationIdentifier; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.IFloydHoareAnnotation; import de.uni_freiburg.informatik.ultimate.lib.proofs.floydhoare.NwaHoareProofProducer; @@ -503,15 +500,12 @@ protected void minimizeAbstraction(final PredicateFactoryRefinement predicateFac final PredicateFactoryResultChecking resultCheckPredFac, final Minimization minimization) throws AutomataOperationCanceledException, AutomataLibraryException, AssertionError { - final Function> lcsProvider = - x -> (x instanceof ISLPredicate ? Collections.singleton(((ISLPredicate) x).getProgramPoint()) - : new HashSet<>(Arrays.asList(((IMLPredicate) x).getProgramPoints()))); AutomataMinimization, IPredicate, L> am; try { final boolean computeOld2New = mProofUpdater != null; am = new AutomataMinimization<>(getServices(), mAbstraction, minimization, computeOld2New, getIteration(), predicateFactoryRefinement, MINIMIZE_EVERY_KTH_ITERATION, mStoredRawInterpolantAutomata, - mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, lcsProvider, true); + mInterpolAutomaton, MINIMIZATION_TIMEOUT, resultCheckPredFac, PredicateUtils::getLocations, true); } catch (final AutomataMinimizationTimeout e) { mCegarLoopBenchmark.addAutomataMinimizationData(e.getStatistics()); throw e.getAutomataOperationCanceledException(); diff --git a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java index bd71abcbd8d..78ff9513ab4 100644 --- a/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java +++ b/trunk/source/TraceAbstraction/src/de/uni_freiburg/informatik/ultimate/plugins/generator/traceabstraction/concurrency/PartialOrderCegarLoop.java @@ -27,7 +27,6 @@ */ package de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.concurrency; -import java.util.Arrays; import java.util.Comparator; import java.util.LinkedList; import java.util.List; @@ -79,6 +78,7 @@ import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.ISLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.MLPredicate; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateFactory; +import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateUtils; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.smt.predicates.PredicateWithConjuncts; import de.uni_freiburg.informatik.ultimate.lib.modelcheckerutils.tracehandling.IRefinementEngineResult; import de.uni_freiburg.informatik.ultimate.lib.proofs.IProofProducer; @@ -350,12 +350,7 @@ private boolean isGoalState(final IPredicate state) { assert state instanceof IMLPredicate || state instanceof ISLPredicate : "unexpected type of predicate: " + state.getClass(); - final boolean isErrorState; - if (state instanceof ISLPredicate) { - isErrorState = mErrorLocs.contains(((ISLPredicate) state).getProgramPoint()); - } else { - isErrorState = Arrays.stream(((IMLPredicate) state).getProgramPoints()).anyMatch(mErrorLocs::contains); - } + final boolean isErrorState = PredicateUtils.streamLocations(state).anyMatch(mErrorLocs::contains); return isErrorState && !isProvenState(state); } From bbace9026e89c430397cae98359b21abe9c90204 Mon Sep 17 00:00:00 2001 From: "maul.esel" Date: Thu, 8 Aug 2024 14:03:19 +0200 Subject: [PATCH 64/91] fix copyright --- trunk/source/Library-Proofs/pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/trunk/source/Library-Proofs/pom.xml b/trunk/source/Library-Proofs/pom.xml index 3e2fd81b2b2..546ac48c497 100644 --- a/trunk/source/Library-Proofs/pom.xml +++ b/trunk/source/Library-Proofs/pom.xml @@ -1,6 +1,6 @@