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
Split 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 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));
latticeWatch.stop();

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

@ -78,59 +78,72 @@ namespace storm {
template <typename ValueType>
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;
}
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>;
}
}

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 validated(std::shared_ptr<storm::expressions::BinaryRelationExpression> assumption);
private:
std::shared_ptr<storm::logic::Formula const> formula;
@ -49,6 +50,8 @@ namespace storm {
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>
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,
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) {
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 {
storm::expressions::Variable var1 = expressionManager->getVariable(std::to_string(critical1));
storm::expressions::Variable var2 = expressionManager->getVariable(std::to_string(critical2));
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);
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);
result.insert(myMap.begin(), myMap.end());
}
@ -43,17 +43,17 @@ namespace storm {
}
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
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();
}
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 {
auto val1 = std::get<1>(criticalTriple);
auto val2 = std::get<2>(criticalTriple);
@ -61,7 +61,7 @@ namespace storm {
storm::expressions::Variable var2 = expressionManager->getVariable(std::to_string(val2));
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);
auto myMap = createAssumptions(var1, var2, latticeCopy, assumptionsCopy);
result.insert(myMap.begin(), myMap.end());
@ -73,15 +73,17 @@ namespace storm {
}
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::make_shared<storm::expressions::BinaryRelationExpression>(storm::expressions::BinaryRelationExpression(*expressionManager, expressionManager->getBooleanType(),
var1.getExpression().getBaseExpressionPointer(), var2.getExpression().getBaseExpressionPointer(),
storm::expressions::BinaryRelationExpression::RelationType::GreaterOrEqual));
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));
} else {
delete lattice;

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

@ -35,13 +35,13 @@ namespace storm {
* @param critical2 State number
* @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);
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;

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

@ -9,7 +9,7 @@
namespace storm {
namespace analysis {
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;
for (auto itr = map.begin(); itr != map.end(); ++itr) {
auto lattice = itr->first;
@ -31,7 +31,7 @@ namespace storm {
first = false;
}
std::shared_ptr<storm::expressions::BinaryRelationExpression> expression = itr2->first;
std::shared_ptr<storm::expressions::BinaryRelationExpression> expression = *itr2;
auto var1 = expression->getFirstOperand();
auto var2 = expression->getSecondOperand();
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 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:
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