kill(all)$

calculus : scaling property delta(c*x) ,version 1.0
peter.vlasschaert@gmail.com,11/02/2020

load packages
===========

load(lrats)$

 definition : delta(c*x)
================
scaling property :dirac delta function.

p1:delta(c*x) = 1/abs(c)*delta(x);

integral representation
================

first : pos, c > 0
--------------------

assume(c>0);

p2:integrate(f(x)*delta(c*x),x,minf,inf);

set :y = c*x

p2a:changevar(p2, y=c*x, y, x);

delta(y=0) =1

p2b:args(p2a);

p2c:args(p2b[1]);

p2d:subst([y=0],p2c[1])/p2b[2];

p3:subst([delta(0)=1],p2=p2d);

second : neg, c < 0
------------------------
c = -a

p4:subst([c=-a],p2);

set : y= -a*x

assume(a>0);

p4a:changevar(p4, y=-a*x, y, x);

p4b:args(p4a);

p4c:args(p4b[1]);

p4d:subst([y=0],p4c[1])/p4b[2];

set : c=-a

p4e: c=-a;
p4e1:solve(p4e,a)[1];

p5:subst([p4e1,delta(0)=1],p4=p4d);

combination :p3,p5
==============

p6:lhs(p5) = f(0)/abs(c);

c=abs(c);

use :f(0),

p7:f(0)=integrate(f(x)*delta(x),x,minf,inf);

p6a:subst([p7],p6);

by check of both sides
-----------------------------

p8a:args(lhs(p6a));
p8b:args(rhs(p6a));
p8b1:args(p8b[1]);
p8b2:p8b[2];

proof :see 'p1'

p9:(p8a[1]=p8b1[1]/p8b2)/f(x);

rem :c =abs(c)