This site is supported by donations to The OEIS Foundation.

Euler transformation

From OeisWiki
Jump to: navigation, search


This article needs more work.

Please help by expanding it!


Magma code

Try the following in the Magma Calculator.


EulerTransformation :=
  function(
    a
  )
    c :=
      [
        Universe(a)
      |
        &+[
          Universe(a)
        |
          d * a[d]
        :
          d in
            Divisors(
              n
            )
        ]
      :
        n in
          [1..#a]
      ]
    ;
    b :=
      [c[1]];
    for
      n in
        [2..#c]
    do
      nb_n :=
          c[n]
        +
          &+[
            Universe(a)
          |
              c[k]
            *
              b[n-k]
          :
            k in
              [1..n-1]
          ];
      assert
        IsDivisibleBy(
          nb_n,
          n
        );
      b[n] :=
        nb_n div n;
    end for;
    return
      b;
  end function
;

InverseEulerTransformation :=
  function(
    b
  )
    c :=
      [
        Integers()
      |
          n * b[n]
        -
          &+[
            Integers()
          |
            self_c[
              k
            ] *
            b[
              n - k
            ]
          :
            k in
              [1..n-1]
          ]
        where
          self_c
        is
          Self()
      :
        n in
          [1..#b]
      ];
    a :=
      [];
    for
      n in [1..#c]
    do
      a[n] :=
        &+[
          Integers()
        |
          MoebiusMu(
            n div d
          ) *
          c[
            d
          ]
        :
          d in
            Divisors(
              n
            )
        ];
      assert
        a[n] mod n eq 0;
      a[n] div:=
        n;
    end for;
    return
      a;
  end function
;

DisconnectedEuler :=
  function(
    A
  )
    assert
      exists(
        f
      ){
        i
      :
        i in
          [1..#A]
      |
        A[i] ne 0
      };
    P<[x]> :=
      PolynomialRing(
        Integers(),
        f + #A
      );
    C :=
      [
        P
      |
          i le #A
        select
          A[i]
        else
          x[i]
      :
        i in
          [1..#A+f]
      ];
    E :=
      EulerTransformation(
        C
      );
    D :=
      [
        Integers()
      |
        E[i] - C[i]
      :
        i in
          [1..#A+f]
      ];
    E :=
      [
        Integers()
      |
        E[i]
      :
        i in
          [1..#A]
      ];
    return
      D, E;
  end function;