Building a function that uses $Assumptions and works like Simplify, FunctionExpand, etc

Question

I want to write a function MySimplify (like built-in Simplify) that takes a second argument to specify additional $Assumptions and that also has an overriding Assumptions option. Here's how I start:

MySimplify::usage = "MySimplify[expr] simplifies expr using QuantumDot's code.
MySimplify[expr, assum] does simplification using assumptions.";

Options[MySimplify] = {Assumptions :> $Assumptions};
SyntaxInformation[MySimplify] = {"ArgumentsPattern" -> {_, _., OptionsPattern[]}};

Question How do I write the boiler-plate code to mimic the behavior of built-in Simplify? Here's my attempt:

MySimplify[e_, o:OptionsPattern[]] := MySimplify[e, True, o];

MySimplify[e_, a_, OptionsPattern[]] :=
  Assuming[a,
    Block[{$Assumptions=OptionValue[Assumptions]},
      Null
     (*QuantumDot's code for simplification goes here*)
    ]
  ];

The outer Assuming appends any assumptions in the second argument to $Assumptions, and the inner Block uses $Assumptions, just like built-in Simplify.

Problem If I supply assumptions that are contradicting or false, it throws $Assumptions::cas instead of MySimplify::cas, or $Assumptions::fas instead of MySimplify::fas. How do I make the following cases

$Assumptions = True;
MySimplify[Sin[x], x > 0 && x < 0];

or

$Assumptions = a > 0;
MySimplify[Sin[x], x < 0]

or

MySimplify[Sin[x], Assumptions->False]

generate a MySimplify::cas and MySimplify::fas errors instead of a $Assumptions::cas and $Assumptions::fas error?

Is this the correct way to build a function that uses assumptions?

Answer 1

You are already mimicking the behavior of MMA built-in functions. The following code prints a $Assumptions::cas message not a TensorDimensions::cas.

$Assumptions = A \[Element] Arrays[{2, 2, 2, 2}];
Assuming[A \[Element] Arrays[{2, 2}], Print["QD was here…"];TensorDimensions[A]]
(*error message before QD gets there*)

Note that the error is printed before the message. That suggests that Assuming processes the assumptions before moving on to the evaluation of the code in the second parameter. Checking the attributes further supports that suggestion:

Attributes[Assuming]
{HoldRest, Protected}

If one must have one's own message, one could try evaluating $Assumptions within a Quiet block.

Options[qdSimplify] = {Assumptions :> $Assumptions};

qdSimplify[e_, o : OptionsPattern[]] := qdSimplify[e, True, o];

qdSimplify[e_, a_, OptionsPattern[]] := 
  With[{qdAssumptions = 
     Quiet[Check[
       Assuming[a && OptionValue[Assumptions], $Assumptions], 
       Print["Your ad here"]; True], {$Assumptions::cas}]}, 
   Print["Bleached assumptions: ", qdAssumptions]; 
   Assuming[qdAssumptions, Print[qdAssumptions]; 
    Print[$Assumptions];]];

$Assumptions = True;
qdSimplify[Sin[x], x > 0 && x < 0];

Of course, one would have to determine what to do in case of contradiction (perhaps devising some preference semantics) … but that is the subject for another question.

---

Update

I am not sure that I understand your request.

If it about suppressing the message $Assumptions::fas, you could just add it to the list that contains $Assumptions::cas.

If it is about printing your own message, you can replace Print["Your ad here"] with your own Message[blah].

If you want to reproduce the fact that Simplify with contradictory assumptions evaluates to True, you can do it by changing the True after Print with a flag that you check in the body.

Maybe you want all of the above.

Options[qdSimplify] = {Assumptions :> $Assumptions};

(*As pointed out by b3m2a1, the next two lines are not necessary*)
(*
qdSimplify::fas="Warning: one or more assumptions evaluated to False";
qdSimplify::cas="Warning: contradictory assumption(s) encountered: `1`."*)
qdSimplifyContr::usage = "This is a flag indicating contradictory assumptions.";
qdSimplifyFalse::usage = "This is a flag indicating false assumptions.";

qdSimplify[e_, o : OptionsPattern[]] := qdSimplify[e, True, o];

qdSimplify[e_, a_, OptionsPattern[]] := With[{qdAssumptions = Quiet[
      Check[
       Check[
        Assuming[a && OptionValue[Assumptions], $Assumptions], 
        Message[qdSimplify::cas, a && OptionValue[Assumptions]]; qdSimplifyContr,
        {$Assumptions::cas}],
       Message[qdSimplify::fas]; qdSimplifyFalse,
       {$Assumptions::fas}],
      {$Assumptions::cas, $Assumptions::fas}]}, 
   Print["Bleached assumptions: ", qdAssumptions];
   Which[
    (*A*)! FreeQ[qdAssumptions, qdSimplifyContr], True,
    (*B*)! FreeQ[qdAssumptions, qdSimplifyFalse], "Handled false assumptions",
    (*C*)True, 
    Assuming[qdAssumptions, Print[qdAssumptions]; Print[$Assumptions];
      "Normal code"]]];

A. Simulates the fact that Simplify with contradictory assumptions evaluates to True. B. This is where you would handle the situation with false assumptions. C. This is where you would put the body of the function.