The FromOrePolyToLinearEquation(Ore, f, A) calling sequence converts the Ore polynomial Ore to the corresponding linear functional equation.

The FromLinearEquationToOrePoly(expr, f, A) calling sequence converts the linear functional equation expr to the corresponding Ore polynomial. The Ore polynomial is returned as an OrePoly structure.

The FromLinearEquationToOrePoly command currently supports only the shift and differential cases.

The AddConversionRule(CaseName, ConvertProc) command adds a new conversion rule from a linear equation to an Ore polynomial to be used by the FromLinearEquationToOrePoly command.

The ConvertProc procedure must accept three arguments: linear functional equation, name of dependent variable, and Ore algebra; and return an Ore polynomial as an OrePoly structure.

The FromOrePolyToPoly(Ore, x) calling sequence converts the Ore polynomial Ore to the corresponding polynomial.

The FromPolyToOrePoly(P, x) calling sequence converts the polynomial P to the corresponding Ore polynomial. The Ore polynomial is returned as an OrePoly structure.

A := SetOreRing(n, 'difference', 'sigma' = proc(p, x) eval(p, x=x+1) end,
'sigma_inverse' = proc(p, x) eval(p, x=x-1) end,
'delta' = proc(p, x) eval(p, x=x+1) - p end,
'theta1' = 0);

Error, (in OreTools:-Converters:-FromLinearEquationToOrePoly) unable to handle the difference case

difference_case := proc(eq, func, A)
     local reqn, info, fcn, E, receq, req, func_set, n, place, i, var;
      var := OreTools[Properties][GetVariable](A);
      # Do some argument checking and processing
      reqn := LREtools['REcreate'](eq, func(var), {});
      info := eval(op(4, reqn));
      if info['linear']=false then
          error "only linear equations are handled"
      end if;
      n := info['vars'];
      if not (nops([n])=1 and type(n, name)) then
          error "only single equations are handled"
      end if;
      fcn := op(2, reqn)[1];
      # locate n in arguments to fcn
      for place to nops(fcn) while op(place, fcn) <> n do end do;
      # Transform the equation from a difference equation to a
      # difference operator
      req := args[1];
      func_set := indets(req, specfunc(anything, info['functions']));
      receq := collect( subs( map( (x, y, z, i) -> x = (z+1)^(op(i, x)-y),
          func_set, n, 'E', place), req), 'E', Normalizer);
      'OrePoly'(seq(coeff(receq, 'E', i), i=0..degree(receq, 'E')))
   end proc: