11
$\begingroup$

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.

$\endgroup$
  • $\begingroup$ It looks to me like it works. Starting from a fresh kernel, I executed $Assumptions = {a[__] > 0};Refine[a[3] > 0], and the result was True. You should have just tried it! :) (As "simple" as this is, I never thought of it.) $\endgroup$ – march Sep 18 '15 at 21:38
  • $\begingroup$ @march Thanks. Indeed your example works. Can you comment on my experiment added now? $\endgroup$ – Sungmin Sep 18 '15 at 21:47
  • $\begingroup$ 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. $\endgroup$ – march Sep 18 '15 at 21:50
  • $\begingroup$ @march Your suggestion fixed the problem. Thank you. $\endgroup$ – Sungmin Sep 18 '15 at 21:54
  • $\begingroup$ Don't use uppercase initials on your symbols... that's just asking for trouble. $\endgroup$ – ciao Sep 18 '15 at 22:08
7
$\begingroup$

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[1]*t], {t, 0, \[Infinity]}],
   Integrate[Exp[-c[x]*t], {t, 0, \[Infinity]}],
   Integrate[Exp[-f*t], {t, 0, \[Infinity]}]}]

{ConditionalExpression[1/c[1], Re[c[1]] > 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.

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

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.