# Is it possible to add some pattern to $Assumptions I apologize if it is a too elementary question but I could not find the appropriate documentation so far. My goal is simple. I would like to add some assumptions that are defined in terms of patterns rather than symbols. For example, I would like to something like this $Assumptions = { a[ ___ ] > 0 };


In my ideal world, this should set every expression with the Head a should be considered positive. Is it possible in Mathematica?

EDIT: Thanks. Following the first comment and the first answer, I did the following experiment. I still got puzzled about the result. Maybe it is just because of the intricate interaction between Integrate and $Assumptions. $Assumptions = {A[___] > 0, B > 0};

Integrate[ Exp[ - A[x] t] , {t, 0, \[Infinity]}]
Integrate[ Exp[ - B t] , {t, 0, \[Infinity]}]
(* output *)
ConditionalExpression[1/A[x], Re[A[x]] > 0]
1/B


In this example, Integrate does not make use of the fact A[___]>0.

• It looks to me like it works. Starting from a fresh kernel, I executed $Assumptions = {a[__] > 0};Refine[a > 0], and the result was True. You should have just tried it! :) (As "simple" as this is, I never thought of it.) – march Sep 18 '15 at 21:38 • @march Thanks. Indeed your example works. Can you comment on my experiment added now? – Sungmin Sep 18 '15 at 21:47 • Well, Integrate assumes that its argument (and all variables) are all complex. It seems like $Assumptions is very conservative, in the sense that it will only apply the A[___] >0 assumption if it knows it's real. if it knows A[___] is real. Add Element[A[___], Reals] to $Assumptions, and you don't get the conditional expression. I'm not sure about the differences between those two, though. That's interesting. – march Sep 18 '15 at 21:50 • @march Your suggestion fixed the problem. Thank you. – Sungmin Sep 18 '15 at 21:54 • Don't use uppercase initials on your symbols... that's just asking for trouble. – ciao Sep 18 '15 at 22:08 ## 1 Answer This is correct; you can also use the following forms, which are generally considered better suited to functional-programming style (in that you don't change the variables globally, just locally): Block[ {$Assumptions = (a[___] > 0)},
code]


or, better yet,

Assuming[
a[___] > 0,
code]


Edit:

(In respond to the OP's code sample) I'm a bit surprised that the code treats A[x] and B differently, but the problem seems to come from an assumption that A[x] could be a complex number. This can be fixed with an additional assumption (also pointed out by march):

Assuming[
{A[___] > 0, B > 0, A[___] \[Element] Reals},
{Integrate[Exp[-A[x] t], {t, 0, \[Infinity]}],
Integrate[Exp[-B t], {t, 0, \[Infinity]}]}]


{1/A[x], 1/B}

I would be interested to hear if anyone else knows why A[x] and B are treated differently by the integration system. I initially thought it might be the assumption that x is a variable, but this example is slightly more illustrative:

Assuming[
{c[___] > 0, c[x] > 0, f > 0},
{Integrate[Exp[-c*t], {t, 0, \[Infinity]}],
Integrate[Exp[-c[x]*t], {t, 0, \[Infinity]}],
Integrate[Exp[-f*t], {t, 0, \[Infinity]}]}]


{ConditionalExpression[1/c, Re[c] > 0], 1/c[x], 1/f}

It seems to me that assumptions containing patterns are treated differently than explicit assumptions, yet it is clear from my previous example (with A[___] \[Element] Reals) that assumptions with patterns are not just being ignored.

• Thanks. Can you also comment on the added example? – Sungmin Sep 18 '15 at 21:47