towards reward-bounded properties

src/storm-dft-cli/storm-dyftee.cpp

@@ -185,7 +185,7 @@ int main(const int argc, const char** argv) {
 
             storm::expressions::Expression targetExpression = exprManager->integer(1) == topfailedVar.getExpressionVariable().getExpression();
             auto evtlFormula = std::make_shared<storm::logic::AtomicExpressionFormula>(targetExpression);
-            auto tbFormula = std::make_shared<storm::logic::BoundedUntilFormula>(std::make_shared<storm::logic::BooleanLiteralFormula>(true), evtlFormula, storm::logic::TimeBound(false, exprManager->integer(0)), storm::logic::TimeBound(false, exprManager->integer(10)), storm::logic::TimeBoundType::Time);
+            auto tbFormula = std::make_shared<storm::logic::BoundedUntilFormula>(std::make_shared<storm::logic::BooleanLiteralFormula>(true), evtlFormula, storm::logic::TimeBound(false, exprManager->integer(0)), storm::logic::TimeBound(false, exprManager->integer(10)), storm::logic::TimeBoundReference(storm::logic::TimeBoundType::Time));
             auto tbUntil = std::make_shared<storm::logic::ProbabilityOperatorFormula>(tbFormula);
             
             auto evFormula = std::make_shared<storm::logic::EventuallyFormula>(evtlFormula, storm::logic::FormulaContext::Time);

src/storm-pars/modelchecker/region/SparseDtmcParameterLiftingModelChecker.cpp

@@ -75,7 +75,7 @@ namespace storm {
             // get the step bound
             STORM_LOG_THROW(!checkTask.getFormula().hasLowerBound(), storm::exceptions::NotSupportedException, "Lower step bounds are not supported.");
             STORM_LOG_THROW(checkTask.getFormula().hasUpperBound(), storm::exceptions::NotSupportedException, "Expected a bounded until formula with an upper bound.");
-            STORM_LOG_THROW(checkTask.getFormula().isStepBounded(), storm::exceptions::NotSupportedException, "Expected a bounded until formula with step bounds.");
+            STORM_LOG_THROW(checkTask.getFormula().getTimeBoundReference().isStepBound(), storm::exceptions::NotSupportedException, "Expected a bounded until formula with step bounds.");
             stepBound = checkTask.getFormula().getUpperBound().evaluateAsInt();
             STORM_LOG_THROW(*stepBound > 0, storm::exceptions::NotSupportedException, "Can not apply parameter lifting on step bounded formula: The step bound has to be positive.");
             if (checkTask.getFormula().isUpperBoundStrict()) {

src/storm-pars/modelchecker/region/SparseMdpParameterLiftingModelChecker.cpp

@@ -76,7 +76,7 @@ namespace storm {
             // get the step bound
             STORM_LOG_THROW(!checkTask.getFormula().hasLowerBound(), storm::exceptions::NotSupportedException, "Lower step bounds are not supported.");
             STORM_LOG_THROW(checkTask.getFormula().hasUpperBound(), storm::exceptions::NotSupportedException, "Expected a bounded until formula with an upper bound.");
-            STORM_LOG_THROW(checkTask.getFormula().isStepBounded(), storm::exceptions::NotSupportedException, "Expected a bounded until formula with step bounds.");
+            STORM_LOG_THROW(checkTask.getFormula().getTimeBoundReference().isStepBound(), storm::exceptions::NotSupportedException, "Expected a bounded until formula with step bounds.");
             stepBound = checkTask.getFormula().getUpperBound().evaluateAsInt();
             STORM_LOG_THROW(*stepBound > 0, storm::exceptions::NotSupportedException, "Can not apply parameter lifting on step bounded formula: The step bound has to be positive.");
             if (checkTask.getFormula().isUpperBoundStrict()) {

src/storm-pars/transformer/SparseParametricDtmcSimplifier.cpp

@@ -111,7 +111,7 @@ namespace storm {
             
             // obtain the simplified formula for the simplified model
             auto labelFormula = std::make_shared<storm::logic::AtomicLabelFormula const> (targetLabel);
-            auto boundedUntilFormula = std::make_shared<storm::logic::BoundedUntilFormula const>(storm::logic::Formula::getTrueFormula(), labelFormula, boost::none, storm::logic::TimeBound(formula.getSubformula().asBoundedUntilFormula().isUpperBoundStrict(), formula.getSubformula().asBoundedUntilFormula().getUpperBound()), storm::logic::TimeBoundType::Steps);
+            auto boundedUntilFormula = std::make_shared<storm::logic::BoundedUntilFormula const>(storm::logic::Formula::getTrueFormula(), labelFormula, boost::none, storm::logic::TimeBound(formula.getSubformula().asBoundedUntilFormula().isUpperBoundStrict(), formula.getSubformula().asBoundedUntilFormula().getUpperBound()), storm::logic::TimeBoundReference(storm::logic::TimeBoundType::Steps));
             this->simplifiedFormula = std::make_shared<storm::logic::ProbabilityOperatorFormula const>(boundedUntilFormula, formula.getOperatorInformation());
             
             return true;

src/storm-pars/transformer/SparseParametricMdpSimplifier.cpp

@@ -135,7 +135,7 @@ namespace storm {
             
             // obtain the simplified formula for the simplified model
             auto labelFormula = std::make_shared<storm::logic::AtomicLabelFormula const> (targetLabel);
-            auto boundedUntilFormula = std::make_shared<storm::logic::BoundedUntilFormula const>(storm::logic::Formula::getTrueFormula(), labelFormula, boost::none, storm::logic::TimeBound(formula.getSubformula().asBoundedUntilFormula().isUpperBoundStrict(), formula.getSubformula().asBoundedUntilFormula().getUpperBound()), storm::logic::TimeBoundType::Steps);
+            auto boundedUntilFormula = std::make_shared<storm::logic::BoundedUntilFormula const>(storm::logic::Formula::getTrueFormula(), labelFormula, boost::none, storm::logic::TimeBound(formula.getSubformula().asBoundedUntilFormula().isUpperBoundStrict(), formula.getSubformula().asBoundedUntilFormula().getUpperBound()), storm::logic::TimeBoundReference(storm::logic::TimeBoundType::Steps));
             this->simplifiedFormula = std::make_shared<storm::logic::ProbabilityOperatorFormula const>(boundedUntilFormula, formula.getOperatorInformation());
             
             return true;

src/storm-pars/transformer/SparseParametricModelSimplifier.cpp

@@ -78,21 +78,21 @@ namespace storm {
         template<typename SparseModelType>
         bool SparseParametricModelSimplifier<SparseModelType>::simplifyForBoundedUntilProbabilities(storm::logic::ProbabilityOperatorFormula const& formula) {
             // If this method was not overriden by any subclass, simplification is not possible
-            STORM_LOG_DEBUG("Simplification not possible because the formula is not suppoerted. Formula: " << formula);
+            STORM_LOG_DEBUG("Simplification not possible because the formula is not supported. Formula: " << formula);
             return false;
         }
         
         template<typename SparseModelType>
         bool SparseParametricModelSimplifier<SparseModelType>::simplifyForReachabilityRewards(storm::logic::RewardOperatorFormula const& formula) {
             // If this method was not overriden by any subclass, simplification is not possible
-            STORM_LOG_DEBUG("Simplification not possible because the formula is not suppoerted. Formula: " << formula);
+            STORM_LOG_DEBUG("Simplification not possible because the formula is not supported. Formula: " << formula);
             return false;
         }
         
         template<typename SparseModelType>
         bool SparseParametricModelSimplifier<SparseModelType>::simplifyForCumulativeRewards(storm::logic::RewardOperatorFormula const& formula) {
             // If this method was not overriden by any subclass, simplification is not possible
-            STORM_LOG_DEBUG("Simplification not possible because the formula is not suppoerted. Formula: " << formula);
+            STORM_LOG_DEBUG("Simplification not possible because the formula is not supported. Formula: " << formula);
             return false;
         }
         

src/storm/logic/BoundedUntilFormula.cpp

@@ -10,7 +10,7 @@
 
 namespace storm {
     namespace logic {
-        BoundedUntilFormula::BoundedUntilFormula(std::shared_ptr<Formula const> const& leftSubformula, std::shared_ptr<Formula const> const& rightSubformula, boost::optional<TimeBound> const& lowerBound, boost::optional<TimeBound> const& upperBound, TimeBoundType const& timeBoundType) : BinaryPathFormula(leftSubformula, rightSubformula), timeBoundType(timeBoundType), lowerBound(lowerBound), upperBound(upperBound) {
+        BoundedUntilFormula::BoundedUntilFormula(std::shared_ptr<Formula const> const& leftSubformula, std::shared_ptr<Formula const> const& rightSubformula, boost::optional<TimeBound> const& lowerBound, boost::optional<TimeBound> const& upperBound, TimeBoundReference const& timeBoundReference) : BinaryPathFormula(leftSubformula, rightSubformula), timeBoundReference(timeBoundReference), lowerBound(lowerBound), upperBound(upperBound) {
             STORM_LOG_THROW(lowerBound || upperBound, storm::exceptions::InvalidArgumentException, "Bounded until formula requires at least one bound.");
         }
         
@@ -26,17 +26,11 @@ namespace storm {
             return visitor.visit(*this, data);
         }
         
-        TimeBoundType const& BoundedUntilFormula::getTimeBoundType() const {
-            return timeBoundType;
+        TimeBoundReference const& BoundedUntilFormula::getTimeBoundReference() const {
+            return timeBoundReference;
         }
         
-        bool BoundedUntilFormula::isStepBounded() const {
-            return timeBoundType == TimeBoundType::Steps;
-        }
-        
-        bool BoundedUntilFormula::isTimeBounded() const {
-            return timeBoundType == TimeBoundType::Time;
-        }
+
         
         bool BoundedUntilFormula::isLowerBoundStrict() const {
             return lowerBound.get().isStrict();

src/storm/logic/BoundedUntilFormula.h

@@ -12,7 +12,7 @@ namespace storm {
     namespace logic {
         class BoundedUntilFormula : public BinaryPathFormula {
         public:
-            BoundedUntilFormula(std::shared_ptr<Formula const> const& leftSubformula, std::shared_ptr<Formula const> const& rightSubformula, boost::optional<TimeBound> const& lowerBound, boost::optional<TimeBound> const& upperBound, TimeBoundType const& timeBoundType = TimeBoundType::Time);
+            BoundedUntilFormula(std::shared_ptr<Formula const> const& leftSubformula, std::shared_ptr<Formula const> const& rightSubformula, boost::optional<TimeBound> const& lowerBound, boost::optional<TimeBound> const& upperBound, TimeBoundReference const& timeBoundReference);
             
             virtual bool isBoundedUntilFormula() const override;
 
@@ -20,9 +20,8 @@ namespace storm {
             
             virtual boost::any accept(FormulaVisitor const& visitor, boost::any const& data) const override;
             
-            TimeBoundType const& getTimeBoundType() const;
-            bool isStepBounded() const;
-            bool isTimeBounded() const;
+            TimeBoundReference const& getTimeBoundReference() const;
+
             
             bool isLowerBoundStrict() const;
             bool hasLowerBound() const;
@@ -49,7 +48,7 @@ namespace storm {
         private:
             static void checkNoVariablesInBound(storm::expressions::Expression const& bound);
             
-            TimeBoundType timeBoundType;
+            TimeBoundReference timeBoundReference;
             boost::optional<TimeBound> lowerBound;
             boost::optional<TimeBound> upperBound;
         };

src/storm/logic/FragmentChecker.cpp

@@ -58,10 +58,14 @@ namespace storm {
                 result = result && !f.getLeftSubformula().isPathFormula();
                 result = result && !f.getRightSubformula().isPathFormula();
             }
-            if (f.isStepBounded()) {
+            auto tbr = f.getTimeBoundReference();
+            if (tbr.isStepBound()) {
                 result = result && inherited.getSpecification().areStepBoundedUntilFormulasAllowed();
-            } else {
+            } else if(tbr.isTimeBound()) {
                 result = result && inherited.getSpecification().areTimeBoundedUntilFormulasAllowed();
+            } else {
+                assert(tbr.isRewardBound());
+                result = result && inherited.getSpecification().areRewardBoundedUntilFormulasAllowed();
             }
             result = result && boost::any_cast<bool>(f.getLeftSubformula().accept(*this, data));
             result = result && boost::any_cast<bool>(f.getRightSubformula().accept(*this, data));

src/storm/logic/FragmentSpecification.cpp

@@ -141,6 +141,7 @@ namespace storm {
             onlyEventuallyFormuluasInConditionalFormulas = true;
             stepBoundedUntilFormulas = false;
             timeBoundedUntilFormulas = false;
+            rewardBoundedUntilFormulas = false;
             varianceAsMeasureType = false;
             
             qualitativeOperatorResults = true;
@@ -423,7 +424,16 @@ namespace storm {
             this->timeBoundedUntilFormulas = newValue;
             return *this;
         }
-        
+
+        bool FragmentSpecification::areRewardBoundedUntilFormulasAllowed() const {
+            return this->rewardBoundedUntilFormulas;
+        }
+
+        FragmentSpecification& FragmentSpecification::setRewardBoundedUntilFormulasAllowed(bool newValue) {
+            this->rewardBoundedUntilFormulas = newValue;
+            return *this;
+        }
+
         FragmentSpecification& FragmentSpecification::setOperatorsAllowed(bool newValue) {
             this->setProbabilityOperatorsAllowed(newValue);
             this->setRewardOperatorsAllowed(newValue);

src/storm/logic/FragmentSpecification.h

@@ -102,6 +102,9 @@ namespace storm {
             
             bool areTimeBoundedUntilFormulasAllowed() const;
             FragmentSpecification& setTimeBoundedUntilFormulasAllowed(bool newValue);
+
+            bool areRewardBoundedUntilFormulasAllowed() const;
+            FragmentSpecification& setRewardBoundedUntilFormulasAllowed(bool newValue);
             
             bool isVarianceMeasureTypeAllowed() const;
             FragmentSpecification& setVarianceMeasureTypeAllowed(bool newValue);
@@ -162,6 +165,7 @@ namespace storm {
             bool onlyEventuallyFormuluasInConditionalFormulas;
             bool stepBoundedUntilFormulas;
             bool timeBoundedUntilFormulas;
+            bool rewardBoundedUntilFormulas;
             bool varianceAsMeasureType;
             bool quantitativeOperatorResults;
             bool qualitativeOperatorResults;

src/storm/logic/TimeBoundType.h

@@ -2,11 +2,42 @@
 
 namespace storm {
     namespace logic {
-        
+
         enum class TimeBoundType {
             Steps,
-            Time
+            Time,
+            Reward
         };
 
+
+        class TimeBoundReference {
+            TimeBoundType type;
+            std::string rewardName;
+
+        public:
+            explicit TimeBoundReference(TimeBoundType t) : type(t) {
+                // For rewards, use the other constructor.
+                assert(t != TimeBoundType::Reward);
+            }
+
+            explicit TimeBoundReference(std::string const& rewardName) : type(TimeBoundType::Reward), rewardName(rewardName) {
+                assert(rewardName != ""); // Empty reward name is reserved.
+            }
+
+
+            bool isStepBound() const {
+                return type ==  TimeBoundType::Steps;
+            }
+
+            bool isTimeBound() const {
+                return type == TimeBoundType::Time;
+            }
+
+            bool isRewardBound() const {
+                return type == TimeBoundType::Reward;
+            }
+        };
+
+
     }
 }

src/storm/logic/VariableSubstitutionVisitor.cpp

@@ -47,7 +47,7 @@ namespace storm {
                 upperBound = TimeBound(f.isUpperBoundStrict(), f.getUpperBound().substitute(substitution));
             }
 
-            return std::static_pointer_cast<Formula>(std::make_shared<BoundedUntilFormula>(left, right, lowerBound, upperBound, f.getTimeBoundType()));
+            return std::static_pointer_cast<Formula>(std::make_shared<BoundedUntilFormula>(left, right, lowerBound, upperBound, f.getTimeBoundReference()));
         }
         
         boost::any VariableSubstitutionVisitor::visit(CumulativeRewardFormula const& f, boost::any const&) const {

src/storm/modelchecker/csl/HybridCtmcCslModelChecker.cpp

@@ -83,7 +83,7 @@ namespace storm {
             SymbolicQualitativeCheckResult<DdType> const& leftResult = leftResultPointer->asSymbolicQualitativeCheckResult<DdType>();
             SymbolicQualitativeCheckResult<DdType> const& rightResult = rightResultPointer->asSymbolicQualitativeCheckResult<DdType>();
             
-            STORM_LOG_THROW(!pathFormula.isStepBounded(), storm::exceptions::NotImplementedException, "Currently step-bounded properties on CTMCs are not supported.");
+            STORM_LOG_THROW(!pathFormula.getTimeBoundReference().isStepBound(), storm::exceptions::NotImplementedException, "Currently step-bounded properties on CTMCs are not supported.");
             double lowerBound = 0;
             double upperBound = 0;
             if (pathFormula.hasLowerBound()) {

src/storm/modelchecker/csl/SparseCtmcCslModelChecker.cpp

@@ -60,7 +60,7 @@ namespace storm {
             ExplicitQualitativeCheckResult const& leftResult = leftResultPointer->asExplicitQualitativeCheckResult();;
             ExplicitQualitativeCheckResult const& rightResult = rightResultPointer->asExplicitQualitativeCheckResult();
 
-            STORM_LOG_THROW(!pathFormula.isStepBounded(), storm::exceptions::NotImplementedException, "Currently step-bounded properties on CTMCs are not supported.");
+            STORM_LOG_THROW(!pathFormula.getTimeBoundReference().isStepBound(), storm::exceptions::NotImplementedException, "Currently step-bounded properties on CTMCs are not supported.");
             double lowerBound = 0;
             double upperBound = 0;
             if (pathFormula.hasLowerBound()) {

src/storm/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp

@@ -54,7 +54,7 @@ namespace storm {
             std::unique_ptr<CheckResult> rightResultPointer = this->check(pathFormula.getRightSubformula());
             ExplicitQualitativeCheckResult const& rightResult = rightResultPointer->asExplicitQualitativeCheckResult();
 
-            STORM_LOG_THROW(!pathFormula.isStepBounded(), storm::exceptions::NotImplementedException, "Currently step-bounded properties on MAs are not supported.");
+            STORM_LOG_THROW(!pathFormula.getTimeBoundReference().isStepBound(), storm::exceptions::NotImplementedException, "Currently step-bounded properties on MAs are not supported.");
             double lowerBound = 0;
             double upperBound = 0;
             if (pathFormula.hasLowerBound()) {

src/storm/modelchecker/multiobjective/SparseMultiObjectivePreprocessor.cpp

@@ -266,7 +266,7 @@ namespace storm {
             
             template<typename SparseModelType>
             void SparseMultiObjectivePreprocessor<SparseModelType>::preprocessBoundedUntilFormula(storm::logic::BoundedUntilFormula const& formula, PreprocessorData& data) {
-                STORM_LOG_THROW(!data.originalModel.isOfType(storm::models::ModelType::MarkovAutomaton) || !formula.isStepBounded(), storm::exceptions::InvalidPropertyException, "Multi-objective model checking currently does not support STEP-bounded properties for Markov automata.");
+                STORM_LOG_THROW(!data.originalModel.isOfType(storm::models::ModelType::MarkovAutomaton) || !formula.getTimeBoundReference().isStepBound(), storm::exceptions::InvalidPropertyException, "Multi-objective model checking currently does not support STEP-bounded properties for Markov automata.");
                 
                 if (formula.hasLowerBound()) {
                     STORM_LOG_THROW(!formula.getLowerBound().containsVariables(), storm::exceptions::InvalidPropertyException, "The lower time bound for the formula " << formula << " still contains variables");

src/storm/parser/FormulaParserGrammar.cpp

@@ -257,7 +257,7 @@ namespace storm {
         
         std::shared_ptr<storm::logic::Formula const> FormulaParserGrammar::createEventuallyFormula(boost::optional<std::pair<boost::optional<storm::logic::TimeBound>, boost::optional<storm::logic::TimeBound>>> const& timeBound, storm::logic::FormulaContext context, std::shared_ptr<storm::logic::Formula const> const& subformula) const {
             if (timeBound) {
-                return std::shared_ptr<storm::logic::Formula const>(new storm::logic::BoundedUntilFormula(createBooleanLiteralFormula(true), subformula, timeBound.get().first, timeBound.get().second, storm::logic::TimeBoundType::Time));
+                return std::shared_ptr<storm::logic::Formula const>(new storm::logic::BoundedUntilFormula(createBooleanLiteralFormula(true), subformula, timeBound.get().first, timeBound.get().second, storm::logic::TimeBoundReference(storm::logic::TimeBoundType::Time)));
             } else {
                 return std::shared_ptr<storm::logic::Formula const>(new storm::logic::EventuallyFormula(subformula, context));
             }
@@ -273,7 +273,7 @@ namespace storm {
         
         std::shared_ptr<storm::logic::Formula const> FormulaParserGrammar::createUntilFormula(std::shared_ptr<storm::logic::Formula const> const& leftSubformula, boost::optional<std::pair<boost::optional<storm::logic::TimeBound>, boost::optional<storm::logic::TimeBound>>> const& timeBound, std::shared_ptr<storm::logic::Formula const> const& rightSubformula) {
             if (timeBound) {
-                return std::shared_ptr<storm::logic::Formula const>(new storm::logic::BoundedUntilFormula(leftSubformula, rightSubformula, timeBound.get().first, timeBound.get().second, storm::logic::TimeBoundType::Time));
+                return std::shared_ptr<storm::logic::Formula const>(new storm::logic::BoundedUntilFormula(leftSubformula, rightSubformula, timeBound.get().first, timeBound.get().second, storm::logic::TimeBoundReference(storm::logic::TimeBoundType::Time)));
             } else {
                 return std::shared_ptr<storm::logic::Formula const>(new storm::logic::UntilFormula(leftSubformula, rightSubformula));
             }

src/storm/parser/JaniParser.cpp

@@ -297,7 +297,7 @@ namespace storm {
                             }
                         }
                     } else if (propertyStructure.count("reward-instants") > 0) {
-                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Instant/Cumul. Reward for reward constraints not supported currently.");
+                        STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Instant Reward for reward constraints not supported currently.");
                     }
                     
                     //STORM_LOG_THROW(!accTime && !accSteps, storm::exceptions::NotSupportedException, "Storm only allows accumulation if a step- or time-bound is given.");
@@ -353,7 +353,7 @@ namespace storm {
                             upperBound--;
                         }
                         STORM_LOG_THROW(upperBound >= 0, storm::exceptions::InvalidJaniException, "Step-bounds cannot be negative");
-                        return std::make_shared<storm::logic::BoundedUntilFormula const>(args[0], args[1], storm::logic::TimeBound(pi.lowerBoundStrict, pi.lowerBound), storm::logic::TimeBound(pi.upperBoundStrict, pi.upperBound), storm::logic::TimeBoundType::Steps);
+                        return std::make_shared<storm::logic::BoundedUntilFormula const>(args[0], args[1], storm::logic::TimeBound(pi.lowerBoundStrict, pi.lowerBound), storm::logic::TimeBound(pi.upperBoundStrict, pi.upperBound), storm::logic::TimeBoundReference(storm::logic::TimeBoundType::Steps));
                     } else if (propertyStructure.count("time-bounds") > 0) {
                         storm::jani::PropertyInterval pi = parsePropertyInterval(propertyStructure.at("time-bounds"));
                         STORM_LOG_THROW(pi.hasUpperBound(), storm::exceptions::NotSupportedException, "Storm only supports time-bounded until with an upper bound.");
@@ -364,10 +364,26 @@ namespace storm {
                         double upperBound = pi.upperBound.evaluateAsDouble();
                         STORM_LOG_THROW(lowerBound >= 0, storm::exceptions::InvalidJaniException, "(Lower) time-bounds cannot be negative");
                         STORM_LOG_THROW(upperBound >= 0, storm::exceptions::InvalidJaniException, "(Upper) time-bounds cannot be negative");
-                        return std::make_shared<storm::logic::BoundedUntilFormula const>(args[0], args[1], storm::logic::TimeBound(pi.lowerBoundStrict, pi.lowerBound), storm::logic::TimeBound(pi.upperBoundStrict, pi.upperBound), storm::logic::TimeBoundType::Time);
+                        return std::make_shared<storm::logic::BoundedUntilFormula const>(args[0], args[1], storm::logic::TimeBound(pi.lowerBoundStrict, pi.lowerBound), storm::logic::TimeBound(pi.upperBoundStrict, pi.upperBound), storm::logic::TimeBoundReference(storm::logic::TimeBoundType::Time));
                         
                     } else if (propertyStructure.count("reward-bounds") > 0 ) {
+                        storm::jani::PropertyInterval pi = parsePropertyInterval(propertyStructure.at("reward-bounds"));
+                        STORM_LOG_THROW(pi.hasUpperBound(), storm::exceptions::NotSupportedException, "Storm only supports time-bounded until with an upper bound.");
+                        STORM_LOG_THROW(propertyStructure.at("reward-bounds").count("exp") == 1, storm::exceptions::InvalidJaniException, "Expecting reward-expression for operator " << opString << " in  " << context);
+                        storm::expressions::Expression rewExpr = parseExpression(propertyStructure.at("reward-bounds").at("exp"), "Reward expression in " + context, globalVars, constants);
+                        STORM_LOG_THROW(!rewExpr.isVariable(), storm::exceptions::NotSupportedException, "Storm currently does not support complex reward expressions.");
+                        std::string rewardName = rewExpr.getVariables().begin()->getName();
+                        STORM_LOG_WARN("Reward-type (steps, time) is deduced from model type.");
+                        double lowerBound = 0.0;
+                        if(pi.hasLowerBound()) {
+                            lowerBound = pi.lowerBound.evaluateAsDouble();
+                        }
+                        double upperBound = pi.upperBound.evaluateAsDouble();
+                        STORM_LOG_THROW(lowerBound >= 0, storm::exceptions::InvalidJaniException, "(Lower) time-bounds cannot be negative");
+                        STORM_LOG_THROW(upperBound >= 0, storm::exceptions::InvalidJaniException, "(Upper) time-bounds cannot be negative");
                         STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Reward bounded properties are not supported by storm");
+                        return std::make_shared<storm::logic::BoundedUntilFormula const>(args[0], args[1], storm::logic::TimeBound(pi.lowerBoundStrict, pi.lowerBound), storm::logic::TimeBound(pi.upperBoundStrict, pi.upperBound), storm::logic::TimeBoundReference(rewardName));
+
                     }
                     if (args[0]->isTrueFormula()) {
                         return std::make_shared<storm::logic::EventuallyFormula const>(args[1], formulaContext);

src/storm/storage/jani/JSONExporter.cpp

@@ -194,11 +194,14 @@ namespace storm {
                 upperExclusive = f.isUpperBoundStrict();
             }
             modernjson::json propertyInterval = constructPropertyInterval(lower, lowerExclusive, upper, upperExclusive);
-            
-            if(f.isStepBounded()) {
+
+            auto tbr = f.getTimeBoundReference();
+            if(tbr.isStepBound()) {
                 opDecl["step-bounds"] = propertyInterval;
-            } else {
+            } else if(tbr.isRewardBound()) {
                 opDecl["time-bounds"] = propertyInterval;
+            } else {
+                opDecl["reward-bounds"] = propertyInterval;
             }
             return opDecl;
         }