sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Add validated assumptions to set

main
Jip Spel 7 years ago
parent
e23a222605
commit
24a40bba80
7 changed files with 82 additions and 64 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/storm-pars-cli/storm-pars.cpp
  2. 97
      src/storm-pars/analysis/AssumptionChecker.cpp
  3. 3
      src/storm-pars/analysis/AssumptionChecker.h
  4. 32
      src/storm-pars/analysis/AssumptionMaker.cpp
  5. 6
      src/storm-pars/analysis/AssumptionMaker.h
  6. 4
      src/storm-pars/analysis/MonotonicityChecker.cpp
  7. 2
      src/storm-pars/analysis/MonotonicityChecker.h

2
src/storm-pars-cli/storm-pars.cpp
View File

@ -549,7 +549,7 @@ namespace storm {
auto assumptionChecker = storm::analysis::AssumptionChecker<ValueType>(formulas[0], dtmcModel, 3); auto assumptionChecker = storm::analysis::AssumptionChecker<ValueType>(formulas[0], dtmcModel, 3);
auto assumptionMaker = storm::analysis::AssumptionMaker<ValueType>(extender, &assumptionChecker, sparseModel->getNumberOfStates()); auto assumptionMaker = storm::analysis::AssumptionMaker<ValueType>(extender, &assumptionChecker, sparseModel->getNumberOfStates());
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> result = assumptionMaker.makeAssumptions(
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> result = assumptionMaker.makeAssumptions(
std::get<0>(criticalPair), std::get<1>(criticalPair), std::get<2>(criticalPair)); std::get<0>(criticalPair), std::get<1>(criticalPair), std::get<2>(criticalPair));
latticeWatch.stop(); latticeWatch.stop();

97
src/storm-pars/analysis/AssumptionChecker.cpp
View File

@ -78,59 +78,72 @@ namespace storm {
template <typename ValueType> template <typename ValueType>
bool AssumptionChecker<ValueType>::validateAssumption(std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption, storm::analysis::Lattice* lattice) { bool AssumptionChecker<ValueType>::validateAssumption(std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption, storm::analysis::Lattice* lattice) {
bool result = false;
std::set<storm::expressions::Variable> vars = std::set<storm::expressions::Variable>({});
assumption->gatherVariables(vars);
STORM_LOG_THROW(assumption->getRelationType() == storm::expressions::BinaryRelationExpression::RelationType::GreaterOrEqual, storm::exceptions::NotSupportedException, "Only Greater Or Equal assumptions supported");
bool result = validated(assumption);
if (!result) {
std::set<storm::expressions::Variable> vars = std::set<storm::expressions::Variable>({});
assumption->gatherVariables(vars);
auto val1 = std::stoi(assumption->getFirstOperand()->asVariableExpression().getVariableName());
auto val2 = std::stoi(assumption->getSecondOperand()->asVariableExpression().getVariableName());
auto row1 = matrix.getRow(val1);
auto row2 = matrix.getRow(val2);
if (row1.getNumberOfEntries() != 2 && row2.getNumberOfEntries() != 2) {
assert (false);
}
STORM_LOG_THROW(assumption->getRelationType() ==
storm::expressions::BinaryRelationExpression::RelationType::GreaterOrEqual,
storm::exceptions::NotSupportedException,
"Only Greater Or Equal assumptions supported");
auto succ11 = row1.begin();
auto succ12 = (++row1.begin());
auto succ21 = row2.begin();
auto succ22 = (++row2.begin());
auto val1 = std::stoi(assumption->getFirstOperand()->asVariableExpression().getVariableName());
auto val2 = std::stoi(assumption->getSecondOperand()->asVariableExpression().getVariableName());
auto row1 = matrix.getRow(val1);
auto row2 = matrix.getRow(val2);
if (row1.getNumberOfEntries() != 2 && row2.getNumberOfEntries() != 2) {
assert (false);
}
if (succ12->getColumn() == succ21->getColumn() && succ11->getColumn() == succ22->getColumn()) {
auto temp = succ12;
succ12 = succ11;
succ11 = temp;
}
auto succ11 = row1.begin();
auto succ12 = (++row1.begin());
auto succ21 = row2.begin();
auto succ22 = (++row2.begin());
if (succ11->getColumn() == succ21->getColumn() && succ12->getColumn() == succ22->getColumn()) {
ValueType prob;
auto comp = lattice->compare(succ11->getColumn(), succ12->getColumn());
if (comp == storm::analysis::Lattice::ABOVE) {
prob = succ11->getValue() - succ21->getValue();
} else if (comp == storm::analysis::Lattice::BELOW) {
prob = succ12->getValue() - succ22->getValue();
if (succ12->getColumn() == succ21->getColumn() && succ11->getColumn() == succ22->getColumn()) {
auto temp = succ12;
succ12 = succ11;
succ11 = temp;
} }
auto vars = prob.gatherVariables();
// TODO: Type
std::map<storm::RationalFunctionVariable, storm::RationalFunctionCoefficient> substitutions;
for (auto var:vars) {
auto derivative = prob.derivative(var);
assert(derivative.isConstant());
if (derivative.constantPart() >=0) {
substitutions[var] = 0;
} else if(derivative.constantPart() <= 0) {
substitutions[var] = 1;
if (succ11->getColumn() == succ21->getColumn() && succ12->getColumn() == succ22->getColumn()) {
ValueType prob;
auto comp = lattice->compare(succ11->getColumn(), succ12->getColumn());
if (comp == storm::analysis::Lattice::ABOVE) {
prob = succ11->getValue() - succ21->getValue();
} else if (comp == storm::analysis::Lattice::BELOW) {
prob = succ12->getValue() - succ22->getValue();
}
auto vars = prob.gatherVariables();
// TODO: Type
std::map<storm::RationalFunctionVariable, storm::RationalFunctionCoefficient> substitutions;
for (auto var:vars) {
auto derivative = prob.derivative(var);
assert(derivative.isConstant());
if (derivative.constantPart() >= 0) {
substitutions[var] = 0;
} else if (derivative.constantPart() <= 0) {
substitutions[var] = 1;
}
} }
result = prob.evaluate(substitutions) >= 0;
}
if (result) {
validatedAssumptions.insert(assumption);
} else {
STORM_PRINT("Could not validate: " << *assumption << std::endl);
} }
result = prob.evaluate(substitutions) >= 0;
}
if (!result) {
STORM_PRINT("Could not validate: " << *assumption << std::endl);
} }
return result; return result;
} }
template <typename ValueType>
bool AssumptionChecker<ValueType>::validated(std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption) {
return find(validatedAssumptions.begin(), validatedAssumptions.end(), assumption) != validatedAssumptions.end();
}
template class AssumptionChecker<storm::RationalFunction>; template class AssumptionChecker<storm::RationalFunction>;
} }
} }

3
src/storm-pars/analysis/AssumptionChecker.h
View File

@ -42,6 +42,7 @@ namespace storm {
*/ */
bool validateAssumption(std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption, storm::analysis::Lattice* lattice); bool validateAssumption(std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption, storm::analysis::Lattice* lattice);
bool validated(std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption);
private: private:
std::shared_ptr<storm::logic::Formula const> formula; std::shared_ptr<storm::logic::Formula const> formula;
@ -49,6 +50,8 @@ namespace storm {
std::vector<std::vector<double>> results; std::vector<std::vector<double>> results;
std::set<std::shared_ptr<storm::expressions::BinaryRelationExpression>> validatedAssumptions;
}; };
} }
} }

32
src/storm-pars/analysis/AssumptionMaker.cpp
View File

@ -18,24 +18,24 @@ namespace storm {
} }
template<typename ValueType> template<typename ValueType>
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>>
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>>
AssumptionMaker<ValueType>::makeAssumptions(storm::analysis::Lattice *lattice, uint_fast64_t critical1, AssumptionMaker<ValueType>::makeAssumptions(storm::analysis::Lattice *lattice, uint_fast64_t critical1,
uint_fast64_t critical2) { uint_fast64_t critical2) {
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> result;
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> result;
std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>> emptySet;
std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> emptySet;
if (critical1 == numberOfStates || critical2 == numberOfStates) { if (critical1 == numberOfStates || critical2 == numberOfStates) {
result.insert(std::pair<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>>(lattice, emptySet));
result.insert(std::pair<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>>(lattice, emptySet));
} else { } else {
storm::expressions::Variable var1 = expressionManager->getVariable(std::to_string(critical1)); storm::expressions::Variable var1 = expressionManager->getVariable(std::to_string(critical1));
storm::expressions::Variable var2 = expressionManager->getVariable(std::to_string(critical2)); storm::expressions::Variable var2 = expressionManager->getVariable(std::to_string(critical2));
auto latticeCopy = new Lattice(lattice); auto latticeCopy = new Lattice(lattice);
std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>> assumptions;
std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> assumptions;
auto myMap = createAssumptions(var1, var2, latticeCopy, assumptions); auto myMap = createAssumptions(var1, var2, latticeCopy, assumptions);
result.insert(myMap.begin(), myMap.end()); result.insert(myMap.begin(), myMap.end());
std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>> assumptions2;
std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> assumptions2;
myMap = createAssumptions(var2, var1, lattice, assumptions2); myMap = createAssumptions(var2, var1, lattice, assumptions2);
result.insert(myMap.begin(), myMap.end()); result.insert(myMap.begin(), myMap.end());
} }
@ -43,17 +43,17 @@ namespace storm {
} }
template<typename ValueType> template<typename ValueType>
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> AssumptionMaker<ValueType>::runRecursive(storm::analysis::Lattice* lattice, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>,bool>> assumptions) {
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>,bool>>> result;
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> AssumptionMaker<ValueType>::runRecursive(storm::analysis::Lattice* lattice, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> assumptions) {
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> result;
// only the last assumption is new // only the last assumption is new
std::tuple<storm::analysis::Lattice*, uint_fast64_t, uint_fast64_t> criticalTriple = this->latticeExtender->extendLattice(lattice, assumptions.back().first);
std::tuple<storm::analysis::Lattice*, uint_fast64_t, uint_fast64_t> criticalTriple = this->latticeExtender->extendLattice(lattice, assumptions.back());
if (assumptions.back().second) {
if (assumptionChecker->validated(assumptions.back())) {
assumptions.pop_back(); assumptions.pop_back();
} }
if (std::get<1>(criticalTriple) == numberOfStates) { if (std::get<1>(criticalTriple) == numberOfStates) {
result.insert(std::pair<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>,bool>>>(lattice, assumptions));
result.insert(std::pair<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>>(lattice, assumptions));
} else { } else {
auto val1 = std::get<1>(criticalTriple); auto val1 = std::get<1>(criticalTriple);
auto val2 = std::get<2>(criticalTriple); auto val2 = std::get<2>(criticalTriple);
@ -61,7 +61,7 @@ namespace storm {
storm::expressions::Variable var2 = expressionManager->getVariable(std::to_string(val2)); storm::expressions::Variable var2 = expressionManager->getVariable(std::to_string(val2));
auto latticeCopy = new Lattice(lattice); auto latticeCopy = new Lattice(lattice);
std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>> assumptionsCopy = std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>(
std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> assumptionsCopy = std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>(
assumptions); assumptions);
auto myMap = createAssumptions(var1, var2, latticeCopy, assumptionsCopy); auto myMap = createAssumptions(var1, var2, latticeCopy, assumptionsCopy);
result.insert(myMap.begin(), myMap.end()); result.insert(myMap.begin(), myMap.end());
@ -73,15 +73,17 @@ namespace storm {
} }
template <typename ValueType> template <typename ValueType>
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> AssumptionMaker<ValueType>::createAssumptions(storm::expressions::Variable var1, storm::expressions::Variable var2, storm::analysis::Lattice* lattice, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>> assumptions) {
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> result;
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> AssumptionMaker<ValueType>::createAssumptions(storm::expressions::Variable var1, storm::expressions::Variable var2, storm::analysis::Lattice* lattice, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> assumptions) {
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> result;
std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption
= std::make_shared<storm::expressions::BinaryRelationExpression>(storm::expressions::BinaryRelationExpression(*expressionManager, expressionManager->getBooleanType(), = std::make_shared<storm::expressions::BinaryRelationExpression>(storm::expressions::BinaryRelationExpression(*expressionManager, expressionManager->getBooleanType(),
var1.getExpression().getBaseExpressionPointer(), var2.getExpression().getBaseExpressionPointer(), var1.getExpression().getBaseExpressionPointer(), var2.getExpression().getBaseExpressionPointer(),
storm::expressions::BinaryRelationExpression::RelationType::GreaterOrEqual)); storm::expressions::BinaryRelationExpression::RelationType::GreaterOrEqual));
if (assumptionChecker->checkOnSamples(assumption)) { if (assumptionChecker->checkOnSamples(assumption)) {
assumptions.push_back(std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>(assumption, assumptionChecker->validateAssumption(assumption, lattice)));
// TODO: only if validation on
assumptionChecker->validateAssumption(assumption, lattice);
assumptions.push_back(std::shared_ptr<storm::expressions::BinaryRelationExpression>(assumption));
result = (runRecursive(lattice, assumptions)); result = (runRecursive(lattice, assumptions));
} else { } else {
delete lattice; delete lattice;

6
src/storm-pars/analysis/AssumptionMaker.h
View File

@ -35,13 +35,13 @@ namespace storm {
* @param critical2 State number * @param critical2 State number
* @return A mapping from pointers to different lattices and assumptions made to create the specific lattice. * @return A mapping from pointers to different lattices and assumptions made to create the specific lattice.
*/ */
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> makeAssumptions(
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> makeAssumptions(
storm::analysis::Lattice *lattice, uint_fast64_t critical1, uint_fast64_t critical2); storm::analysis::Lattice *lattice, uint_fast64_t critical1, uint_fast64_t critical2);
private: private:
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> runRecursive(storm::analysis::Lattice* lattice, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>> assumptions);
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> runRecursive(storm::analysis::Lattice* lattice, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> assumptions);
std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> createAssumptions(storm::expressions::Variable var1, storm::expressions::Variable var2, storm::analysis::Lattice* lattice,std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>> assumptions);
std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> createAssumptions(storm::expressions::Variable var1, storm::expressions::Variable var2, storm::analysis::Lattice* lattice,std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>> assumptions);
storm::analysis::LatticeExtender<ValueType>* latticeExtender; storm::analysis::LatticeExtender<ValueType>* latticeExtender;

4
src/storm-pars/analysis/MonotonicityChecker.cpp
View File

@ -9,7 +9,7 @@
namespace storm { namespace storm {
namespace analysis { namespace analysis {
template <typename ValueType> template <typename ValueType>
void MonotonicityChecker<ValueType>::checkMonotonicity(std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> map, storm::storage::SparseMatrix<ValueType> matrix) {
void MonotonicityChecker<ValueType>::checkMonotonicity(std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> map, storm::storage::SparseMatrix<ValueType> matrix) {
auto i = 0; auto i = 0;
for (auto itr = map.begin(); itr != map.end(); ++itr) { for (auto itr = map.begin(); itr != map.end(); ++itr) {
auto lattice = itr->first; auto lattice = itr->first;
@ -31,7 +31,7 @@ namespace storm {
first = false; first = false;
} }
std::shared_ptr<storm::expressions::BinaryRelationExpression> expression = itr2->first;
std::shared_ptr<storm::expressions::BinaryRelationExpression> expression = *itr2;
auto var1 = expression->getFirstOperand(); auto var1 = expression->getFirstOperand();
auto var2 = expression->getSecondOperand(); auto var2 = expression->getSecondOperand();
STORM_PRINT(*expression); STORM_PRINT(*expression);

2
src/storm-pars/analysis/MonotonicityChecker.h
View File

@ -24,7 +24,7 @@ namespace storm {
* @param map The map with lattices and the assumptions made to create the lattices. * @param map The map with lattices and the assumptions made to create the lattices.
* @param matrix The transition matrix. * @param matrix The transition matrix.
*/ */
void checkMonotonicity(std::map<storm::analysis::Lattice*, std::vector<std::pair<std::shared_ptr<storm::expressions::BinaryRelationExpression>, bool>>> map, storm::storage::SparseMatrix<ValueType> matrix);
void checkMonotonicity(std::map<storm::analysis::Lattice*, std::vector<std::shared_ptr<storm::expressions::BinaryRelationExpression>>> map, storm::storage::SparseMatrix<ValueType> matrix);
private: private:
std::map<carl::Variable, std::pair<bool, bool>> analyseMonotonicity(uint_fast64_t i, storm::analysis::Lattice* lattice, storm::storage::SparseMatrix<ValueType> matrix) ; std::map<carl::Variable, std::pair<bool, bool>> analyseMonotonicity(uint_fast64_t i, storm::analysis::Lattice* lattice, storm::storage::SparseMatrix<ValueType> matrix) ;

Write Preview
Loading…
Cancel
Save