La convolución de Dirichlet es un tipo especial de convolución que aparece como una herramienta muy útil en la teoría de números. Funciona en el conjunto de funciones aritméticas .

Desafío

Dadas dos funciones aritméticas (es decir, funciones ) calculan la convolución de Dirichlet como se define a continuación. $f,g$ $f,g: \mathbb N \to \mathbb R$ $(f * g): \mathbb N \to \mathbb R$

Detalles

Usamos la convención . $0 \notin \mathbb N = \{1,2,3,\ldots \}$
La convolución de Dirichlet de dos funciones aritméticas es nuevamente una función aritmética, y se define como(Ambas sumas son equivalentes. La expresión significa divide , por lo tanto, la suma es sobre los divisores naturales de . De manera similar, podemos sustituir $f*g$ $f,g$ $(F * sol) (norte) = \sum_{re El | norte} F (\frac{norte}{re}) \cdot sol (re) = \sum_{yo \cdot j = norte} F (yo) \cdot sol (j) .$ $(f * g)(n) = \sum_\limits{d|n} f\left(\frac{n}{d}\right)\cdot g(d) = \sum_{i\cdot j = n} f(i)\cdot g(j).$ $d|n$ $d \in \mathbb N$ $n$ $n$ $i = \frac{n}{d} \in \mathbb N, j =d \in \mathbb N$ y obtenemos la segunda formulación equivalente. Si no está acostumbrado a esta notación, hay un ejemplo paso a paso a continuación. Solo para elaborar (esto no es directamente relevante para este desafío): la definición proviene de calcular el producto de la serie Dirichlet : $(\sum_{norte \in norte} \frac{F (norte)}{{norte}^{s}}) \cdot (\sum_{norte \in norte} \frac{sol (norte)}{{norte}^{s}}) = \sum_{norte \in norte} \frac{(F * sol) (norte)}{{norte}^{s}}$ $\left(\sum_{n\in\mathbb N}\frac{f(n)}{n^s}\right)\cdot \left(\sum_{n\in\mathbb N}\frac{g(n)}{n^s}\right) = \sum_{n\in\mathbb N}\frac{(f * g)(n)}{n^s}$
La entrada se da como dos funciones de recuadro negro . Alternativamente, también podría usar una lista infinita, un generador, una secuencia o algo similar que podría producir un número ilimitado de valores.
Hay dos métodos de salida: se devuelve una función o, alternativamente, puede tomar una entrada adicional y devolver directamente. $f*g$ $n \in \mathbb N$ $(f*g)(n)$
Para simplificar, puede suponer que cada elemento de puede representarse con, por ejemplo, un int positivo de 32 bits. $\mathbb N$
Para simplificar, también puede suponer que cada entrada puede representarse, por ejemplo, con un solo número de punto flotante real. $\mathbb R$

Ejemplos

Primero definamos algunas funciones. Tenga en cuenta que la lista de números debajo de cada definición representa los primeros valores de esa función.

la identidad multiplicativa ( A000007 ) $ϵ (n) = {\begin{cases} 1 & n = 1 \\ 0 & n > 1 \end{cases}$ $\epsilon(n) = \begin{cases}1 & n=1 \\ 0 & n>1 \end{cases}$ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...
la función de unidad constante ( A000012 ) $1 (n) = 1 \forall n$ $\mathbb 1(n) = 1 \: \forall n$ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
la función de identidad ( A000027 ) $i d (n) = n \forall n$ $id(n) = n \: \forall n$ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, ...
la función Möbius ( A008683 ) $μ (n) = {\begin{cases} (- 1)^{k} & if n is squarefree and k is the number of Primefactors of n \\ 0 & otherwise \end{cases}$ $\mu(n) = \begin{cases} (-1)^k & \text{ if } n \text{ is squarefree and } k \text{ is the number of Primefactors of } n \\ 0 & \text{ otherwise } \end{cases}$ 1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0, -1, ...
la función totient de Euler ( A000010 ) $φ (n) = n \prod_{p | n} (1 - \frac{1}{p})$ $\varphi(n) = n\prod_{p|n} \left( 1 - \frac{1}{p}\right)$ 1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8, ...
la función de Liouville ( A008836 ) donde es el número de factores primos de contados con multiplicidad $λ (n) = (- 1)^{k}$ $\lambda (n) = (-1)^k$ $k$ $n$ 1, -1, -1, 1, -1, 1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, -1, ...
la función de suma de divisores ( A000203 ) $σ (n) = \sum_{d | n} d$ $\sigma(n) = \sum_{d | n} d$ 1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, ...
la función de conteo de divisores ( A000005 ) $τ (n) = \sum_{d | n} 1$ $\tau(n) = \sum_{d | n} 1$ 1, 2, 2, 3, 2, 4, 2, 4, 3, 4, 2, 6, 2, 4, 4, 5, 2, 6, 2, 6, 4, 4, 2, 8, ...
la función característica de los números cuadrados ( A010052 ) $s q (norte) = {\begin{cases} 1 & Si norte es un número cuadrado \\ 0 0 & de otra manera \end{cases}$ $sq(n) = \begin{cases} 1 & \text{ if } n \text{ is a square number} \\ 0 & \text{otherwise}\end{cases}$ 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, ...

Luego tenemos los siguientes ejemplos:

$\epsilon = \mathbb 1 * \mu$
$f = \epsilon * f \: \forall f$
$\epsilon = \lambda * \vert \mu \vert$
$\sigma = \varphi * \tau$
$id = \sigma * \mu$ y $\sigma = id * \mathbb 1$
$sq = \lambda * \mathbb 1$ y $\lambda = \mu * sq$
$\tau = \mathbb 1 * \mathbb 1$ y $\mathbb 1 = \tau * \mu$
$id = \varphi * \mathbb 1$ y $\varphi = id * \mu$

Los últimos son consecuencia de la inversión de Möbius : para cualquier $f,g$ la ecuación $g = f * 1$ es equivalente a $f = g * \mu$ .

Ejemplo paso a paso

Este es un ejemplo que se calcula paso a paso para quienes no están familiarizados con la notación utilizada en la definición. Considere las funciones $f = \mu$ y $g = \sigma$ . Ahora evaluaremos su convolución $\mu * \sigma$ en $n=12$ . Sus primeros términos se enumeran en la tabla a continuación.

\begin{array}{cccccccccccccc} F & F (1) & F (2) & F (3) & F (4 4) & F (5 5) & F (6 6) & F (7 7) & F (8) & F (9 9) & F (10) & F (11) & F (12) \\ μ & 1 & - 1 & - 1 & 0 0 & - 1 & 1 & - 1 & 0 0 & 0 0 & 1 & - 1 & 0 0 \\ σ & 1 & 3 & 4 4 & 7 7 & 6 6 & 12 & 8 & 15 & 13 & 18 años & 12 & 28 \end{array}

$\begin{array}{c|ccccccccccccc} f & f(1) & f(2) & f(3) & f(4) & f(5) & f(6) & f(7) & f(8) & f(9) & f(10) & f(11) & f(12) \\ \hline \mu & 1 & -1 & -1 & 0 & -1 & 1 & -1 & 0 & 0 & 1 & -1 & 0 \\ \sigma & 1 & 3 & 4 & 7 & 6 & 12 & 8 & 15 & 13 & 18 & 12 & 28 \\ \end{array}$

La suma itera sobre todos los números naturales $d \in \mathbb N$ que dividen $n=12$ , por lo tanto $d$ asume todos los divisores naturales de $n=12 = 2^2\cdot 3$ . Estos son $d =1,2,3,4,6,12$ . En cada sumando, evaluamos $g= \sigma$ en $d$ y lo multiplicamos por $f = \mu$ evaluado en $\frac{n}{d}$ . Ahora podemos concluir

\begin{aligned} (μ * σ) (12) & = μ (12) σ (1) & + μ (6 6) σ (2) & + μ (4 4) σ (3) & + μ (3) σ (4 4) & + μ (2) σ (6 6) & + μ (1) σ (12) \\ = 0 0 \cdot 1 & + 1 \cdot 3 & + 0 0 \cdot 4 4 & + (- 1) \cdot 7 7 & + (- 1) \cdot 12 & + 1 \cdot 28 \\ = 0 0 & + 3 & 1 0 0 & - 7 7 & - 12 & + 28 \\ = 12 \\ = yo re (12) \end{aligned}

$\begin{array}{rlccccc} (\mu * \sigma)(12) &= \mu(12)\sigma(1) &+\mu(6)\sigma(2) &+\mu(4)\sigma(3) &+\mu(3)\sigma(4) &+\mu(2)\sigma(6) &+\mu(1)\sigma(12) \\ &= 0\cdot 1 &+ 1\cdot 3 &+ 0 \cdot 4 &+ (-1)\cdot 7 &+ (-1) \cdot 12 &+ 1 \cdot 28 \\ &= 0 & + 3 & 1 0 & -7 & - 12 & + 28 \\ &= 12 \\ & = id(12) \end{array}$

— falla
fuente

4

Magras , 108 100 95 78 75 bytes

def d(f g:_->int)(n):=(list.iota n).foldr(λd s,ite(n%d=0)(s+f d*g(n/d))s)0

Pruébalo en línea!

Más casos de prueba con todas las funciones.

— Monja permeable
fuente

¿Es lambda realmente más caro que cuatro bytes fun ?

— Mario Carneiro

lambda es de tres bytes, supongo

— Leaky Nun

Creo que son dos en UTF8 (el griego es bastante bajo Unicode)

— Mario Carneiro

Tienes razón. También jugué golf a la importación

— Leaky Nun

También solía condguardar 5 bytes

— Leaky Nun

4

Haskell , 46 bytes

(f!g)n=sum[f i*g(div n i)|i<-[1..n],mod n i<1]

Pruébalo en línea!

¡Gracias a flawr por -6 bytes y un gran desafío! ¡Y gracias a H.PWiz por otro -6!

— Mego
fuente

Más simple es más corto aquí

— H.PWiz

@ H.PWiz Eso es bastante inteligente, ¡ni siquiera pensé en hacerlo de esa manera!

— Mego

3

Python 3 , 59 bytes

lambda f,g,n:sum(f(d)*g(n//d)for d in range(1,n+1)if 1>n%d)

Pruébalo en línea!

— Monja permeable
fuente

¿Es //realmente necesario en lugar de /?

— Sr. Xcoder

/produciría flotadores, ¿verdad?

— Leaky Nun

Debido a que des un divisor de, npor definición, la parte fraccional de n/des cero, por lo que no debería haber problemas con la aritmética de coma flotante. Los flotadores con fracción cero fraccionaria están lo suficientemente cerca de los ints para fines pitónicos, y la salida de la función es un número real, por lo que hacerlo en n/dlugar de n//ddebería estar bien.

— Mego

3

Wolfram Language (Mathematica) , 17 bytes

Por supuesto, Mathematica tiene una función incorporada. También sucede que conoce muchas de las funciones de ejemplo. He incluido algunos ejemplos de trabajo.

DirichletConvolve

Pruébalo en línea!

— Kelly Lowder
fuente

2

Agregar ++ , 51 bytes

D,g,@~,$z€¦~¦*
D,f,@@@,@b[VdF#B]dbRzGb]$dbL$@*z€g¦+

Pruébalo en línea!

Toma dos funciones predefinidas como argumentos, más $n$ y salidas $(f * g)(n)$

Cómo funciona

D,g,		; Define a helper function, $g
	@~,	; $g takes a single argument, an array, and splats that array to the stack
		; $g takes the argument e.g. [[τ(x) φ(x)] [3 4]]
		; STACK : 			[[τ(x) φ(x)] [3 4]]
	$z	; Swap and zip:			[[3 τ(x)] [4 φ(x)]]
	€¦~	; Reduce each by execution:	[[τ(3) φ(4)]]
	¦*	; Take the product and return:	τ(3)⋅φ(4) = 4

D,f,		; Define the main function, $f
	@@@,	; $f takes three arguments: φ(x), τ(x) and n (Let n = 12)
		; STACK:			[φ(x) τ(x) 12]
	@	; Reverse the stack:		[12 τ(x) φ(x)]
	b[V	; Pair and save:		[12]			Saved: [τ(x) φ(x)]
	dF#B]	; List of factors:		[[1 2 3 4 6 12]]
	dbR	; Copy and reverse:		[[1 2 3 4 6 12] [12 6 4 3 2 1]]
	z	; Zip together:			[[[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]]]
	Gb]	; Push Saved:			[[[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]] [[τ(x) φ(x)]]]
	$dbL	; Number of dividors:		[[[τ(x) φ(x)]] [[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]] 6]
	$@*	; Repeat:			[[[1 12] [2 6] [3 4] [4 3] [6 2] [12 1]] [[τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)] [τ(x) φ(x)]]]
	z	; Zip:				[[[τ(x) φ(x)] [1 12]] [[τ(x) φ(x)] [2 6]] [[τ(x) φ(x)] [3 4]] [[τ(x) φ(x)] [4 3]] [[τ(x) φ(x)] [6 2]] [[τ(x) φ(x)] [12 1]]]
	€g	; Run $g over each subarray:	[[4 4 4 6 4 6]]
	¦+	; Take the sum and return:	28

— caird coinheringaahing
fuente

2

R , 58 bytes

function(n,f,g){for(i in (1:n)[!n%%1:n])F=F+f(i)*g(n/i)
F}

Pruébalo en línea!

Toma n, fy g. Afortunadamente, el numberspaquete ya tiene implementadas algunas de las funciones.

Si las versiones vectorizadas estuvieran disponibles, lo cual es posible envolviendo cada una Vectorize, entonces es posible la siguiente versión de 45 bytes:

R , 45 bytes

function(n,f,g,x=1:n,i=x[!n%%x])f(i)%*%g(n/i)

Pruébalo en línea!

— Giuseppe
fuente

2

APL (Dyalog Classic) , 20 bytes

{(⍺⍺¨∘⌽+.×⍵⍵¨)∪⍵∨⍳⍵}

con ⎕IO←1

Pruébalo en línea!

Fácil de resolver, difícil de probar, generalmente no es mi tipo de desafío. ¡Sin embargo, disfruté mucho de este!

{ }define un operador diádico cuyos operandos ⍺⍺y ⍵⍵son las dos funciones convolucionadas; ⍵es el argumento numérico

∪⍵∨⍳⍵son los divisores de ⍵en orden ascendente, es decir, únicos ( ∪) de los MCM ( ∨) de ⍵con todos los números naturales hasta él ( ⍳)

⍵⍵¨ aplicar el operando correcto a cada

⍺⍺¨∘⌽ aplicar el operando izquierdo a cada uno a la inversa

+.× producto interno: multiplica los elementos correspondientes y la suma

Lo mismo en ngn / apl se ve mejor debido a los identificadores Unicode, pero toma 2 bytes adicionales debido a la indexación 1.

— ngn
fuente

Bastante seguro de que toma 27 bytes adicionales en ngn / apl ...

— Erik the Outgolfer

1

Jalea , 9 bytes

ÆDṚÇ€ḋÑ€Ʋ

Pruébalo en línea!

La línea en la parte superior es la línea principal de $f$ , la línea en la parte inferior es la línea principal de $g$ . $n$ se pasa como argumento a esta función.

— Erik el Outgolfer
fuente

1

Swift 4 , 74 70 54 bytes

{n in(1...n).map{n%$0<1 ?f(n/$0)*g($0):0}.reduce(0,+)}

Pruébalo en línea!

— Sr. Xcoder
fuente

1

JavaScript (ES6), 47 bytes

Toma entrada como (f)(g)(n).

f=>g=>h=(n,d=n)=>d&&!(n%d)*f(n/d)*g(d)+h(n,d-1)

Pruébalo en línea!

Ejemplos

liouville =
n => (-1) ** (D = (n, k = 2) => k > n ? 0 : (n % k ? D(n, k + 1) : 1 + D(n / k, k)))(n)

mobius =
n => (M = (n, k = 1) => n % ++k ? k > n || M(n, k) : n / k % k && -M(n / k, k))(n)

sq =
n => +!((n ** 0.5) % 1)

identity =
n => 1

// sq = liouville * identity
console.log([...Array(25)].map((_, n) => F(liouville)(identity)(n + 1)))

// liouville = mobius * sq
console.log([...Array(20)].map((_, n) => F(mobius)(sq)(n + 1)))

— Arnauld
fuente

1

C (gcc) , 108 bytes

#define F float
F c(F(*f)(int),F(*g)(int),int n){F s=0;for(int d=0;d++<n;)if(n%d<1)s+=f(n/d)*g(d);return s;}

Implementación directa, descaradamente robada de la respuesta Python de Leaky Nun .

Sin golf:

float c(float (*f)(int), float (*g)(int), int n) {
    float s = 0;
    for(int d = 1; d <= n;++d) {
        if(n % d == 0) {
            s += f(n / d) * g(d);
        }
    }
    return s;
}

Pruébalo en línea!

— joH1
fuente

1

F #, 72 bytes

let x f g n=Seq.filter(fun d->n%d=0){1..n}|>Seq.sumBy(fun d->f(n/d)*g d)

Toma las dos funciones fy gy un número natural n. Filtra los valores dque no se dividen naturalmente en n. Luego evalúa f(n/d) y g(d), los multiplica, y suma los resultados.

— Ciaran_McCarthy
fuente

0

Pari / GP , 32 bytes

(f,g,n)->sumdiv(n,d,f(n/d)*g(d))

Pruébalo en línea!

Hay una dirmulfunción incorporada, pero solo admite secuencias finitas .

— alephalpha
fuente

0

APL (NARS), 47 caracteres, 94 bytes

{(m⍵[1])×n⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}

donde myn son la función que uno tiene que usar (esto porque no sé cómo llamar a una matriz de funciones en una función en APL). Usando el ejemplo anterior, la función de multiplicación de Mobius (aquí es 12π) y la función de suma de divisores (aquí es 11π) para el valor 12, esa multiplicación sería:

  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}12
12

si uno tiene que calcular algún otro valor:

  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}1002
1002
  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}1001
1001
  {(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}20000x
20000

Se puede ver si, por ejemplo, el primer número 2000 del resultado de la función es la identidad

  (⍳2000)≡{(12π⍵[1])×11π⍵[2]}{+/⍺⍺¨{k←⍳⍵⋄(⍵÷b),¨b←k/⍨0=k∣⍵}⍵}¨⍳2000
1

— RosLuP
fuente

Convolución de Dirichlet

Desafío

Detalles

Ejemplos

Ejemplo paso a paso

Magras , 108 100 95 78 75 bytes

Haskell , 46 bytes

Python 3 , 59 bytes

Wolfram Language (Mathematica) , 17 bytes

Agregar ++ , 51 bytes

Cómo funciona

R , 58 bytes

R , 45 bytes

APL (Dyalog Classic) , 20 bytes

Jalea , 9 bytes

Swift 4 , 74 70 54 bytes

JavaScript (ES6), 47 bytes

Ejemplos

C (gcc) , 108 bytes

F #, 72 bytes

Pari / GP , 32 bytes

APL (NARS), 47 caracteres, 94 bytes