| 
 
            
               
            
            
            
            
            
               Think of
               
            
              being an approximation to a hut function (put straddle). The  is calculated in the section
               (
            
              Decomposition
                of payoff function in one dimension
            
            ). We place a lot of high level
               wavelets around the singularity at the strike. When we evolve  with Backward Kolmogorov's equation, the singularity disappears. Therefore,
               the weights  placed on high order wavelets around the strike should redistribute to lower
               order wavelets. 
            
               We
               produce
            
              by taking  with maximal weights  .
               Those  ,
               not included in  ,
               would have a small weight  if included in the sum. When we apply the transformation  ,
               the weights redistribute. The
               function  gives us partial information about such redistribution. 
            
               We form the
               set
            
               
            
               We form the set
               
            
              recursively via distinct
               unions  The optimal function  have to depend on diffusive properties of operator  .
               However, due to iterative nature of this
               procedure,  would work too. In addition, we add propagation into higher scales as follows: 
            
               
            
              We denote the construction of  from  as   
            
               We
               calculate
            
              Then we
               calculate    We
               continue    for  We stop when  becomes small. 
            
               After completion, the final set
               
            
              is reduced by removing indexes with lowest contribution. The result is  . 
            
               Another possibility is simply to take
               
            
              to be a large number and do one iteration. |