@John Fredsted You write that tau is supposed to be a time-reversal operator acting on some time-dependent function f(t).
Doesn't that mean that the `*` is not multiplication in your actual case, and the one you showed us is only a toy example?

@John Fredsted I realized my mistake before your reply. I have edited my answer.
Actually it is the fact that
subs(a*b=4,a*b*c);
eval(a*b*c,a*b=4);

both work as you intended that surprised me.

@dharr Yes, putting uneval quotes around the procedure name is nice.

@vv The assume project is quite ambitious. It is clearly very difficult.
I don't favor ad hoc solutions to satisfy the crowd (or just me) and I think it is fine to have high ambitions.
Nevertheless, straightforward cases like assume(n = 7) or the implied variety ought to be handled somewhat gracefully, whatever I mean by that.

@Markiyan Hirnyk Yes, assume(n >= 7, n <= 7) is equivalent to assume(n=7), so ought to be handled the same way.

My own simple hack of overloading assuming doesn't handle that because only equalities are handled by eval.
Thus
n assuming n>=0,n<=0;

works as it does without the hack, i.e. it returns n.

@vv I'm not sure what you mean by equality not being the real issue.
Certainly as you say we have from
assume(p<=0,p>=0);
about(p);
the response
Originally p, renamed p~:
  is assumed to be: 0

So we are actually assuming that p = 0, right?
I'm not saying that it is wrong for assuming to accept equality, I'm just asking what the designers want the system to respond to the fact that the assumptions imply equality.
As it is now the response is not easy to guess.

Should anybody return to this let me give the last revision that I have

restart;
assumingoverload:=subsop(3=overload,eval(`assuming`)):
st:=convert(eval(assumingoverload),string):
st2:=StringTools:-Substitute( st, st[1..19], "proc(x::uneval,a::list(Not(satisfies(x->hastype(x,name=constant)))))" ):
STR2:=" if type(a,'list') then assumptions := op(a)":
st3:=StringTools:-Substitute(st2,STR2,cat(STR2[1..-3],"ListTools:-Flatten(evalindets(a,set,[op])))")):
assumingoverload:=parse(st3):

assumingoverload:=parse(st3):
`assuming`:=overload(
       [
          proc(x::uneval,par1::And(list,satisfies(x->hastype(x,name=constant)))) option overload;
           local par,par2,res;
           par:=ListTools:-Flatten(evalindets(par1,set,[op]));
           par,par2:=selectremove(hastype,par,name=constant);
           assign(par);
           try
            res:=eval(x) assuming op(par2);
           catch:
            error;
           finally  
            map(unassign@lhs,eval(par,2));
           end try;
           op(eval(res,par)) assuming op(par2);
          end proc,
          eval(assumingoverload)
        ]
):

#################
Examples.
plot(a*sin(x),x=0..b) assuming {a=-2,b=7};
param := {a=2,b=7}:
plot(a*sin(x),x=0..b) assuming param;
plot(a*sin(x),x=0..b) assuming a=-2,b=7;
plot(a*sin(x),x=0..b) assuming [a=-2],{b=Pi};
simplify(sqrt((x*y)^2)) assuming x>0,y>0;
simplify(sqrt((x*y)^2)) assuming x=10,y>0;
int(exp(a*t),t=0..b) assuming a<0,b=infinity;
int(exp(b*a*t),t=0..infinity) assuming b=2,a<0;
int(exp(b*a*t),t=0..infinity) assuming {a<0,b>2};
A:=Matrix([[a,b],[c,d]]);
LinearAlgebra:-Eigenvectors(A) assuming d=0;

@Markiyan Hirnyk Thank you Markiyan. Yes that's the one.

@vv Several years ago I wrote contrived an overloading of assuming to work as eval when assuming equality.

That works fine, but the question is what the designers of `assuming` and assume intend assuming equality to mean.

I will formulate a question in MaplePrimes with the title "What does assume n=7 mean?"

@Kitonum For the integral int(abs(cos(n*x)), x=0..Pi) try
restart;
int(abs(cos(n*x)), x=0..Pi,method=_RETURNVERBOSE);
#All methods fail.
So it must be an `assuming` problem.
I have always been suspicious of assuming equality.
Try
restart;
assume(n=0);
int(abs(cos(n*x)), x=0..Pi,method=_RETURNVERBOSE); # ftoc = 0, ftocms = 0, all other fail.
about(n);
B:=int(abs(cos(n*x)),x); # Result: sin(n*x)/n
is(n=0); #true
eval(B,x=Pi/2); # 0
restart;
assume(n::integer);
int(abs(cos(n*x)), x=0..Pi,method=_RETURNVERBOSE); #All fail
about(n);
int(abs(cos(n*x)),x); #signum(cos(n*x))*sin(n*x)/n
################
## Totally apart from integrals, take a look at the following, where my question is: What kind of answer do we expect or want?
restart;
assume(n=0);
n^2; # We are getting n^2
eval(%); # no change
sin(n*Pi); # 0
## Why the difference? Is it reasonable?

@awass

Well, method = laplace is not the default.
Notice that when using method=laplace and type=series (or just series) you need to give the unknown function(s) as the second argument:
ode:=diff(x(t),t)=x(t);
dsolve(ode,x(t),method=laplace); #Notice x(0) used as the arbitrary constant (natural with laplace)
dsolve(ode,x(t),series,order=4); #Notice x(0) used as the arbitrary constant (since t=0 is used for expansion point)
dsolve(ode); #No need for x(t), but OK with it.
#_C1 used as arbitrary constant as it also is when the ode is nonlinear (consistency!)
dsolve({ode,x(0)=1},numeric); #No need for x(t), but OK with it
I understand from Edgardo Cheb-Terrab that the difference wrt. the need for x(t) is simply due to the fact that different people are in charge of these things.

@Markiyan Hirnyk I wanted to get rid of the square root, so needed to solve sqrt(x+ln(x))=u for x.

@Rouben Rostamian  In Maple 2016 the code executes without error. In Maple 2015.2 we need the assumption eps>0 as vv mentions. But see note below.
An interesting change from Maple 2015.2 to Maple 2016.
You could say that as long as the integrals are inert there shouldn't be any complaining, the burden of validity rests on the user, as it does for several operations in Maple.
Or you could say that if the one integral is convergent (exists) then so is (does) the other.
##
Note. The burden rests on the user:
In Maple 2015.2 this works too:
Change(J1,s=-t) assuming eps<0;
In this case the integral J1 is divergent, but so is the integral emerging from Change.

@Declan Matrices are indexed from 1 and up. Arrays are more flexible. So you could do:

f := (i,j) -> `if`(j=1, i^2, i^3):
A:=Array(5..14,1..2,f);
A[5,..]; # .. means all of the second range i.e. in this case 1..2
A[7,2];

@adel-00 Your expression w1*(-1/3) is imaginary, as you also seem to realize since you are taken its conjugate in defining f:
f:=conjugate(w1)*(-1/3):

contourplot deals with real-valued expressions only. Thus you can use it on Re(f) or on Im(f) or on abs(f) as you please.
You are asking for only one contour level, -1. If you use Re(f) that level is not reached in the rectangle you chose.