diff --git a/src/discretise/discrete_model.rs b/src/discretise/discrete_model.rs
index 2108d86..17d5ac8 100644
--- a/src/discretise/discrete_model.rs
+++ b/src/discretise/discrete_model.rs
@@ -1208,6 +1208,7 @@ mod tests {
     );
 
     tensor_tests!(
+        prefix_minus: "A { 1.0 / -2.0 }" expect "A" = "A { (): 1 / (-2) }",
         time: "A_i { t }" expect "A" = "A_i (1) { (0)(1):  t }",
         named_blk: "A_i { (0:3): y = 1, 2 }" expect "A" = "A_i (4) { (0)(3): y = 1, (3)(1): 2 }",
         dense_vect_implicit: "A_i { 1, 2, 3 }" expect "A" = "A_i (3) { (0)(1): 1, (1)(1): 2, (2)(1): 3 }",
diff --git a/src/parser/ds_grammar.pest b/src/parser/ds_grammar.pest
index 2218968..12f2399 100644
--- a/src/parser/ds_grammar.pest
+++ b/src/parser/ds_grammar.pest
@@ -6,9 +6,9 @@ indices   = { "(" ~ indice ~ ("," ~ indice)* ~ ")" ~ ":" }
 indice      = { integer ~ ( range_sep ~ integer )? }
 tensor_elmt = { indices? ~ (assignment | expression) }
 assignment = { name ~ "=" ~ expression }
-expression = { sign? ~ term ~ (term_op ~ term)* }
+expression = { term ~ (term_op ~ term)* }
 term       = { factor ~ (factor_op ~ factor)* }
-factor     = { call | real | integer | name_ij | "(" ~ expression ~ ")" }
+factor     = { sign? ~ ( call | real | integer | name_ij | "(" ~ expression ~ ")" ) }
 call       = { name ~ "(" ~ call_arg ~ ("," ~ call_arg )* ~ ")" }
 call_arg   = { expression }
 name_ij    = ${ name ~ ("_" ~ name)? }
diff --git a/src/parser/ds_parser.rs b/src/parser/ds_parser.rs
index 287904b..fd46d50 100644
--- a/src/parser/ds_parser.rs
+++ b/src/parser/ds_parser.rs
@@ -84,24 +84,10 @@ fn parse_value(pair: Pair<'_, Rule>) -> Ast<'_> {
             }
         }
 
-        //expression = { sign? ~ term ~ (term_op ~ term)* }
+        //expression = { term ~ (term_op ~ term)* }
         Rule::expression => {
             let mut inner = pair.into_inner();
-            let sign = if inner.peek().unwrap().as_rule() == Rule::sign {
-                Some(parse_sign(inner.next().unwrap()))
-            } else {
-                None
-            };
-            let mut head_term = match sign {
-                Some(s) => Ast {
-                    kind: AstKind::Monop(ast::Monop {
-                        op: s,
-                        child: Box::new(parse_value(inner.next().unwrap())),
-                    }),
-                    span,
-                },
-                None => parse_value(inner.next().unwrap()),
-            };
+            let mut head_term = parse_value(inner.next().unwrap());
             while inner.peek().is_some() {
                 //term_op    = @{ "-"|"+" }
                 let term_op = parse_sign(inner.next().unwrap());
@@ -145,8 +131,25 @@ fn parse_value(pair: Pair<'_, Rule>) -> Ast<'_> {
             head_factor
         }
 
-        // factor     = { call | name | real | integer | "(" ~ expression ~ ")" }
-        Rule::factor => parse_value(pair.into_inner().next().unwrap()),
+        // factor     = { sign? ~ (call | name | real | integer | "(" ~ expression ~ ")" ) }
+        Rule::factor => {
+            let mut inner = pair.into_inner();
+            let sign = if inner.peek().unwrap().as_rule() == Rule::sign {
+                Some(parse_sign(inner.next().unwrap()))
+            } else {
+                None
+            };
+            match sign {
+                Some(s) => Ast {
+                    kind: AstKind::Monop(ast::Monop {
+                        op: s,
+                        child: Box::new(parse_value(inner.next().unwrap())),
+                    }),
+                    span,
+                },
+                None => parse_value(inner.next().unwrap()),
+            }
+        }
 
         // name_ij    = { name ~ ("_" ~ name)? }
         Rule::name_ij => {