The problem is that (a . b) . c doesn't match the rule even
though a . c or b . c does match the rule.
Try extending basisp to recognize products of operators:
basisp (x) := op (x) = 'ket or (op (x) = "." and every (basisp, args (x)));
I didn't try that; it might be wrong.
It turns out the problem doesn't really have anything to do with
using intermediate variables, for what it's worth.
best
Robert Dodier
On 4/27/11, Fernando Aguayo <beren.olvar at gmail.com> wrote:
> Oops!
> It seems I oversimplified the example, and my mistake of writing an "i"
> instead of 1 lead me to think it was good enough. Let me show you a more
> complete (non) working example of what my problem is:
>
> I need to use several operators over a "vector", so I make the following:
>
> kill(rules)$
> dotdistrib:true$
> dotscrules:true$
> basis:{a,ad}$
>
> basisp(x):=elementp(x,basis)$
> ketp(x):=is(equal(op(x),ket))$
>
> matchdeclare (i,integerp)$
> matchdeclare([Z1,Z2,Z3],basisp)$
> matchdeclare(K1,ketp )$
>
> simp:false$
> tellsimp(Z1[i] . K1, ket(evolve(Z1,i,K1)))$
> simp:true$
>
> phi:ket(n)$
> r:a[1].ad[2]$
> a[1].ad[2] . phi;
> r.phi;
>
> So, is basically the same, but now I'm using two operators. The output
> of this is:
> (%o33) |evolve(a,1,|evolve(ad,2,|n>)>)>
> (%o34) a[1] . |evolve(ad,2,|n>)>
>
> (I have defined the output of ket(n) as |n>)
> So If I write the complete expression it will work, but if I use an
> auxilary variable it
> will apply the rule correctly once, but not the second time. This happes
> for any
> number of operators. How can I make it apply the rules for the whole
> expression?
>
> Thanks!
>
> On 4/27/2011 12:00 AM, Robert Dodier wrote:
>> Well, the problem is that i is not known to be an integer.
>> You could try this:
>> matchdeclare (i, lambda ([e], integerp (e) or featurep (e, integer)));
>> and then after the rule,
>> declare (i, integer);
>> or you relax the matchdeclare for i to accept any symbol:
>> matchdeclare (i, symbolp);
>> and then it will match i without any declaration for i.
>>
>> HTH
>>
>> Robert Dodier
>>
>> On 4/26/11, beren olvar<beren.olvar at gmail.com> wrote:
>>> Hi,
>>>
>>> I'm using tellsimp to write some simple rules to work with some operators
>>> (a, ad) acting on some vectors(ket,bra).
>>> So far I have something like this:
>>>
>>> basis:{a,ad}$
>>> basisp(x):=elementp(x,basis)$
>>> ketp(x):=is(equal(op(x),ket))$
>>>
>>> matchdeclare(K1,ketp )$
>>> matchdeclare(Z1,basisp)$
>>> matchdeclare (i,integerp)$
>>>
>>> simp:false$
>>> tellsimp(Z1[i].K1, evolve(Z1,i,K1))$ /*operator acting over a state
>>> (ket)*/
>>> simp:true$
>>>
>>> where evolve is a function I have defined before.
>>> The problem is that if I use the basis elements "a" or "ad" explicitly it
>>> works,for example:
>>> a[1].ket(0,0,0,0);
>>> gives
>>> (%o1) evolve(a,1,ket(0,0,0,0))
>>>
>>> but if I do something like
>>> r:a[i]$
>>> r.ket(0,0,0,0);
>>>
>>> it will just write
>>> (%o2) a[i] . ket(0,0,0,0)
>>>
>>> and "evolve" will not be called as it should. Is there a way I can force
>>> the
>>> last expansion before the simplification is attempted so my rules are
>>> used?
>>> Do you know of any other way I should try doing this?
>>>
>>> Thank you very much
>>> Regards
>>> Fernando
>>>
>
>