Laurent series for algebraic functions

[the_pulp]

TL;DR Summary

Is there a kind of "Laurent Serie" for each algebraic function over it´s whole Riemann Surface? Perhaps using radicals in the approximation?

Hi, I'm writting because I sort of had an idea that looks that it should work but, I did not find any paper talking about it. I was thinking about approximating something like algebraic functions. That is to say, a function of a complex variable z,(probably multivalued) that obeys something like:

p₁(z)*y^n + p₂(z)*y^(n-1) + ... + p_n+1(z)*y^0 = 0

I know that given that this is probably multivalued, we have to impose some kind of branch cut and, as a consequence, in general, we can not generate a laurent series using the general formula to obtain its coefficients:

a_n =1/(2*pi*i)* ∫_γ y(z)/(z-c)^(n+1) * dz

In general, what happens is that there is some kind of issue when the loop crosses the branch cut given that when it does, the function does not return to its original value. However, what I thought is that, for example (just to simplify the explanation), for a "bivalued" algebraic function, given that after 2 loops, the function returns to its original value, something like this should work:

a_n/2 =1/(4*pi*i)* ∫_γ y(z)/(z-c)^(n/2+1) * dz

y(z) = ∑a_n/2*z^n/2

In this case γ should be a curve that goes around c two times.

(note that give the "n/2" in the exponent of z, we are approximating the "bivalued" function "y(z)" with "bivalued" "monomials" -so we have apples and apples in both sides of the equation-)

I find that something like these should be true because when you express z as c + r*e^θ*i then you sort of have all the functions that a Fourier series should have in order to approximate any periodic function (in coloquial terms, θ, given that is divided by 2, goes half as fast as in the usual laurent series, and, as a consequence, when you go around the 2 loops of γ, θ/2 performs just one loop so, we go back to the usual laurent series.

This idea sounds that it should work with three valued algebraic functions (using a curve γ that performs three loops and dividing the exponent by 3) or with, in general, "n" valued algebraic functions (using a curve γ that performs "n" loops and dividing the exponent by "n").

Even though these ideas sounds feasible, I do not find anything on the web that describes this setting (the closest thing that I found is something like puseaux series, but it is not estimated, in general with the philosophy used in general in laurent series). Given that there is a negligible probability that this setting has not been studied in the past, I'm asking you guys:

Have you seen any kind of approximation of algebraic function overs its whole Riemann Surface similar to what I'm imagining? (not just local approximations of just one branch)
If not, do you find any hole in the argument, in order to grasp some kind of intuition of why this does not exist?

Thanks in advance for you usual kindful help.

Ps: Sorry, I did not find the mathematical equation writer in order to be more clear. In addition, I'm not an native English speaker so, sorry for any mistake in my explanation. Finally, I'm sorry also for not being precise in my explanation. Given that what I have in mind is an intuition, not a mathematical theorem, this is what you guys are receiving.

 

[fresh_42]

The "mathematical equation writer" is here:

but we all prefer if you would use LaTeX:
Here is explained how you can type formulas on PF: https://www.physicsforums.com/help/latexhelp/

You have written an essay and yet said little about what you want to do.

I (have to) assume you mean real functions.
I (have to) assume that you have two real variables $x,y.$
I (have to) assume that $p_k(x)$ are quotients of polynomials so that Laurent series make sense, although $p$ usually stands for polynomials in which case your expression is purely polynomial, and Laurent series were obsolete.
The term "algebraic function" is very misleading as it normally describes algebraic varieties and less Riemannian surfaces.

I cannot even guess what you intend to do and most of all why?

What I see without any guesses is the polynomial desription a twodimensional Riemannian manifold. This alone has consequences regarding charts, etc. How do your series fit in? You speak about curves. I assume these are paths on your Riemannian surface. What do you want to do with them: analysis, topology, or geometry?

 

[the_pulp]

Yes, you are right, I should have written everything with the same variable "z" and clarifying that I'm talking about a function y(z) of a complex variable z. This function is the solution of this equation:

p₁(z)*y(z)ⁿ + p₂(z)*y(z)^n-1 + ... + p_n+1(z)*y(z)⁰ = 0

And I want to write and approximation of this function using something similar than a laurent series but admitting rational exponents. Something like, for a given k:

y(z) = ∑a_n/k*z^n/k

Being k the amount of values that y(z) takes for each of z (if it is bivalued, k=2, if it is three value ==> k=3 and so on).

Is it clearer now?

Thanks for your quick response

Ps: Given your feedback, I'm editing right now the original post in order to make it clearer.

 

[martinbn]

It is not going to work the way you are hoping. The parameter $z$ is only a local parameter, which doesn't cover the whole Riemann surface. And locally meromorphic functions have Laurent series expansion. There is also a problem with the fractional powers of $z$. The reason you haven't found anything along these lines is because it doesn't work, not because no one has thought of it and it might be a good idea. If you are interested more about how to view algebraic functions defined through algebraic equations you need to look at Riemann surface books, of which there are plenty. Or, depending on your current knowledge, you can look at complex analysis books that have an intro to Riemann surfaces. I would recommend Narasimhan "Complex Analysis in One Variable", but there are many others as well.

 

[the_pulp]

Thanks Martinbn for your answer. Just for you to know my background, I have read a couple of complex analysis books with a bit of Riemann Surfaces in them, but I have not read anything fully focused on Riemann Surfaces. In addition I have seen tons of youtube videos and lessons regarding complex analysis and, as a consequence a bit of Riemann Surfaces.
I will look for something fully focused on Riemann Surfaces as you suggest. In the meantime, I would appreciate if you can expand a bit regarding why it should not work. You mention that the problem is that the parameter z does not cover the whole Riemann Surface, but I was being intuitive with the formulas and not rigurous (among other things, because I have not a rigurous theorem in my hands). In fact, if we work with the usual θ parameter of polar coordinates around c in this equation (working with the "bivalued" example just to simplify):

Summary: Is there a kind of "Laurent Serie" for each algebraic function over it´s whole Riemann Surface? Perhaps using radicals in the approximation?

an/2 =1/(4*pi*i)* ∫γ y(z)/(z-c)^(n/2+1) * dz

We arrive to the following:a_n/2 = 1/(4*pi*i) * ∫₀^4pi y(c+r*exp(iθ)) / (r^(n/2+1)*exp^iθ*(n/2+1)) * d(r*exp(iθ))

And these parametrization arrives to a unique value along the whole domain of θ (0 to 4pi). This parametrization, with the same logic, can be used in the next equation of my original post:

Summary: Is there a kind of "Laurent Serie" for each algebraic function over it´s whole Riemann Surface? Perhaps using radicals in the approximation?

y(z) = ∑an/2 * z^n/2

So, given all of the above, I don´t see how the parametrization or the fractional power poses an unavoidable problem to this idea. Again, could you please be more precise on where this argument fails to offer an idea to approximate multivalued algebraic functions in their whole Riemann Surface with series like, in general:

y(r,θ)=∑a_n/k * r^n/k * e^i*θ*n/k

(with θ going from 0 to 2*pi*k and with "k" being the "degree of multivaluedness" -if that means something at all).

Thanks again for your help and please don´t take this post as if I'm stating that these grey ideas are undoubtely true (it´s just that they seem to me a bit intuitive and I'm not seeing where my intuition is failing)

 

[the_pulp]

Hi all.

While I was waiting for more replies, I developed a Python code in order to check if my intuition works and, surprisingly... IT DOES!
At least for a particular function (sqrt(4-z^2)), this method offers an approximation for both branches of the function. In the following post I will paste my Python code. In this one, I'm going to write more or less the strategy and the conclusions.

1) I'm working with the following parametrization: z=2+r*exp(i*t)
2) "t" can take values from -pi to 3pi
3) I'm integrating around the point "2", because, in this value of z, I understand that the function does not have a derivative and "initiates" a branch cut.
4) I took special care that when the argument of the square root of the function crosses zero (from up to down in the left plane), it changes the branch of the Python Function. As a consequence, along the whole (-pi:3pi) path, the function follows a continuous set of values.
5) In this case, given the "bivaluedness" of the function, only the monomials with fractional exponents remain (the others go to zero)
6) It looks also that, given that this function does not have any singularity / residue / etcetera, only the monomials with positive exponents remain
7) Hence, this function can be approximated with a series that looks like the following:
(4-z²)^0.5=a_1/2*z^1/2+a_3/2*z^3/2+a_5/2*z^5/2+...

8) In this case, the coefficients are the following

a(1/2)	(0.0012566368960692457+1.9999994736211422j)
a(3/2)	(0.00015707961200643082+0.24999993420264288j)
a(5/2)	(-9.81747575031466e-06-0.01562499588766581j)
a(7/2)	(1.2271844646313371e-06+0.0019531244859566422j)
a(9/2)	(-1.9174757579143084e-07-0.00030517570093002277j)
a(11/2)	(3.3555824817698327e-08+5.3405747656568026e-05j)
a(13/2)	(-6.2917264381245094e-09-1.001357768161057e-05j)
a(15/2)	(1.2358724994180215e-09+1.966952753406498e-06j)
a(17/2)	(-2.5104621593358134e-10-3.9953724853547534e-07j)
a(19/2)	(5.238104611518524e-11+8.323692052281118e-08j)

9) This approximation gives one result when you insert a complex input with parameter t from -pi to +pi and another result when you insert the same radius but with parameter t from +pi to +3pi. In this case, given that the algebraic function just has an square root outside, the correspondent second value is equal to the negative of the first
10) Given that the coefficients are complex, I checked that, when this approximation should give a real number (because the argument of the square root is real), it does that.
11) Obviously I checked that this approximation works for different arguments.

As a conclusion, it looks that, at least, there is a set of algebraic functions for which this kind of approximation works.

Ps: As I said, in the following post I will paste the Python Code

 

[the_pulp]

Sorry it has some extra lines that I wrote to check if the code works. If I find time I will upload again the code without the spurious lines. At least, in UPPERCASE, I commented the important lines:

# -*- coding: utf-8 -*-
"""
Created on Wed Aug  3 16:56:17 2022

@author: thepulp
"""
"sqrt(4-z^2)"
import cmath
import math
pi=math.pi
j=complex(0,1)

'I DEFINE THE INPUT IN THE R - THETA SPACE (BEING THETA A VARIABLE GOING FROM 0 TO 4PI IN THIS CASE)'
rou=0.22360679774997894
tou=2.677945044588987+2*pi
'tou=pi+2*pi'
zou=2+rou*cmath.exp(j*tou)
'zou=1.8+0.1j'
delta=zou-2
deltapol=cmath.polar(delta)
'rou=deltapol[0]'
'tou=deltapol[1]'

'I CALCULATE THE DESIRED OUTPUT'
salida1=(4-zou**2)**0.5
salida2=(4-(2+rou*cmath.exp(tou*j))**2)**0.5

M=20
T=10000
arraysize = 2*M+1
a=[complex()]*arraysize
b=[complex()]*arraysize
ZOUTPUT=[complex()]*(T+1)
DZR=0
INTEGRANDOR=0
r=0.5
aproximacion=0
errormax=0
COUNT=0
for n in range (-M,M+1):

    flag=1

    for i in range (1,T+1):

        'I THOUGHT I NEEDED THE IF BUT I DIDNT. I COULD HAVE WRITTEN THE DEFINITION OF THE THETA VARIABLE (t) WITHOUT THE IF'
        if i<=T/2:
            t=(i/(T/2)-1/T)*2*pi-pi
            told=((i-1)/(T/2)-1/T)*2*pi-pi
           
        else:
            't=((i-T/2)/(T/2)-1/T)*2*pi-pi'
            'told=(((i-1)-T/2)/(T/2)-1/T)*2*pi-pi'
            t=(i/(T/2)-1/T)*2*pi-pi
            told=((i-1)/(T/2)-1/T)*2*pi-pi
           
        z=2+r*cmath.exp(t*j)
        zold=2+r*cmath.exp(told*j)
        dz=z-zold
        'dz=j*r*cmath.exp(t*j)*(1/(T/2))*2*pi'
        dzpolar=cmath.polar(dz)
        dzr=dzpolar[0]
        DZR=DZR+dzr/(T*arraysize)
        'print(dz)'
        zint=(4-(2+r*cmath.exp(t*j))**2)
        'print(zint)'
        imaginarionuevo=zint.imag
        realnuevo=zint.real
        if i==1:
            imaginarioviejo=imaginarionuevo

        if i>1:
            calculoold=flag*(4-(2+r*cmath.exp(told*j))**2)**0.5
            'calculoold=((r**((n+1)/2))*cmath.exp(told*j*(n+1)/2))'
            if realnuevo<0:
               
                'HERE I CHECK IF I AM CROSSING A BRANCH CUT AND, HENCE, IF I SHOULD CHANGE THE SIGN OF THE PYTHON FUNCTION'
                if (imaginarionuevo<=0 and imaginarioviejo>0):
                    flag=-flag
                    'print(n,flag,i)'
                   
                   
            calculonew=flag*(4-(2+r*cmath.exp(t*j))**2)**0.5
            ZOUTPUT=calculonew
            'calculonew=((r**((n+1)/2))*cmath.exp(t*j*(n+1)/2))'
            diferencia=calculoold-calculonew
            error=cmath.polar(diferencia)
            if error[0]>errormax:
                errormax=error[0]
                'print(errormax)'
                
            if error[0]>0.1:
                gus=1
                
        'print(flag*(4-(2+r*cmath.exp(t*j))**2)**0.5)'
        
        'HERE I CALCULATE THE RATIO BETWEEN THE FUNCTION AND THIS PSEUDO LAURENT DENOMINATOR WITH FRACTIONAL EXPONENT'
        integrando=(((1/(4*pi*(0+1j)))*flag*((4-(2+r*cmath.exp(t*j))**2)**0.5))/((r**((n/2)+1))*cmath.exp(t*j*((n/2)+1))))
        
        
        integrandopolar=cmath.polar(integrando)
        integrandor=integrandopolar[0]
        INTEGRANDOR=INTEGRANDOR+integrandor/(T*arraysize)

        'HERE I MULTIPLY THE INTEGRAND WITH dz AND ACUMULATE THE RESULTS IN ORDER TO GET THE a(n/2) COEFFICIENTS'
        a[n+M]=a[n+M]+integrando*dz
        
        
        if i==(10):
            gu=1
        'print(n,i,a[n+M])'
        COUNT=COUNT+abs(integrando*dz)
        'print(i,a[n+M])'
        imaginarioviejo=zint.imag

    'NOW THAT I ENDED THE COEFFICIENT ESTIMATION, I MULTIPLY IT WITH ITS MONOMIAL AND THEN ACCUMULATE THE IN VARIABLE CALLED aproximacion'
    b[n+M]=a[n+M]*((rou**((n)/2))*cmath.exp(tou*j*(n)/2))
    aproximacion=aproximacion+b[n+M]
    print(n)'JUST TO CHECK THAT, FOR THIS CASE, THE APPROXIMATION WORKS ONLY USING MONOMIALS WITH FRACTIONAL POSITIVE EXPONENTS'
check=a[21]*((rou**((1)/2))*cmath.exp(tou*j*(1)/2))+a[23]*((rou**((3)/2))*cmath.exp(tou*j*(3)/2))
check=check+a[25]*((rou**((5)/2))*cmath.exp(tou*j*(5)/2))+a[27]*((rou**((7)/2))*cmath.exp(tou*j*(7)/2))
check=check+a[29]*((rou**((9)/2))*cmath.exp(tou*j*(9)/2))+a[31]*((rou**((11)/2))*cmath.exp(tou*j*(11)/2))
check=check+a[33]*((rou**((13)/2))*cmath.exp(tou*j*(13)/2))+a[35]*((rou**((15)/2))*cmath.exp(tou*j*(15)/2))
check=check+a[37]*((rou**((17)/2))*cmath.exp(tou*j*(17)/2))+a[39]*((rou**((19)/2))*cmath.exp(tou*j*(19)/2))

 

[the_pulp]

Hi all. I tried also today with the algebraic function sqrt(z+sqrt(z)) and it is still working.
1) i tried first the case in which the approximation is developed around 1. It approximated perfectly but it did not generated any fractional exponent (only taylor like terms). Perhaps it is because I worked with the branch in which sqrt(z)=1 but I am not sure. I have to check further just in case. It looks ok, but I'll keep on looking at it.
2) then i tried the case in which z=0. Here it only appeared terms with fractional exponents of the form (2n+1)/4, being n equal to 0 or natural numbers. In this case all the coefficients
were real and it approximated again perfectly the 4 values of this multivalued algebraic function.

Regards!

 

[fresh_42]

And I want to write and approximation of this function using something similar than a laurent series but admitting rational exponents. Something like, for a given k:

y(z) = ∑a_n/k*z^n/k

Being k the amount of values that y(z) takes for each of z (if it is bivalued, k=2, if it is three value ==> k=3 and so on).

Is it clearer now?

Not really, but let's see what you have.
$$
y(z) = \sum_n a_{n/k} z^{n/k}=\sum_n a_n (z^{1/k})^n=\sum_{n} a_n w^n
$$
if we set $w:=z^{1/k}$ and ignore the fact that complex roots aren't well-defined without further assumptions. So if we set $f:=y\circ {(.)^k}$ then $f(w)=y(w^k)=y(z)= \sum_{n} a_n w^n$ which is ordinary calculus. All that distinguishes $f$ and $y$ is a simple transformation of the variable. Say, restricted to the main branch of $y(z),$ this is no significant change. If we know all about $f(w)$ then we know all about $y(z).$

 

[the_pulp]

The key word that states the difference between the reasoning that you have written and what I'm doing in Python is "restricted to the main branch". What I'm doing in Python is not restricted to the main branch.

In fact, applying my Python code to the case above stated (sqrt(z+sqrt(z))), we arrive to results that clearly can´t be deduced by a collorary from taylor series. For example, when we work with an anulus of radius 0.5 and center c=1, we have that when the inner square root gives -1 as a result, then it sort of poses a branch point (because the whole result is zero). However, when the inner square root gives +1 as a result, then you can´t access to the other planes of the Riemann surface working with curves with radius<0.5. As a consequence, the python code is giving me two sets of parameters when I work with c=1 depending on wether we are in the branch in which the inner sqrt is +1 or -1:

As you can see, this method is giving taylor like exponents (non fractional exponents) when we are in the branch in with the inner sqrt is equal to 1) and not taylor like exponents (n/2 exponents) when we are in the other branch generated from the inner sqrt. I don´t see how a method based on replicating main branches with taylor series would be able to replicate in this manner.

Ps: In fact, for this case, the taylor method cannot be applied to the branch in which sqrt(c)=-1 because the derivatives goes to infinity