Computing the sum of an infinite series as a variant of a geometric series

I came across the following series when computing the covariance of a transform of a bivariate Gaussian random vector via Hermite polynomials and Mehler’s expansion:

$ $ S = \sum_{n=1}^{\infty} \frac{\rho^n}{n^{1/6}} $ $ for $ \vert \rho \vert < 1$ . We know that $ S$ must be finite and satisfy $ $ S \le \rho (1-\rho)^{-1} $ $ since the original series is dominated by $ \sum_{n=1}^{\infty} \rho^n$ .

However, there is a catch if we use for $ S$ the upper bound $ \rho (1-\rho)^{-1}$ , which tends to $ \infty$ when $ \rho \to 1-$ . This happens when the two marginal random variables in the Gaussian vector are almost surely, positively linearly dependent (asymptotically).

So, the target is to obtain a good upper bound, much better than $ \rho (1-\rho)^{-1}$ when we restrict $ \rho$ to be away from $ 1$ , to reduce the effect of $ \rho \to 1-$ . In other words, let $ 1-\rho = \delta$ for some fixed $ \delta \in (0,1)$ , what is a better upper bound for $ S$ ?

Because of the scaling term $ n^{-1/6}$ that induces a divergent series $ \sum_{n=1}^{\infty} n^{-1/6}$ , probably not much improvement should be expected. I have Googled but did not find an illuminating technique for this. Any pointer or help is appreciated. Thank you.

Question of convergence of an infinite number of series with special conditions

I am trying to think about the following type of problems, and, actually, if we could get some results, they could be applied inside of mathematics, even to some unsolved problems.

I will not now write about potential applications, but proceed to a direct presentation of a problem.

i am studying (although, with no conclusions yet) the sum $ $ \sum_{3 \leq a_{1,1},a_{1,2}< + \infty} \frac {1}{a_{1,1}a_{1,2}}+\sum_{3 \leq a_{2,1},a_{2,2},a_{2,3}< + \infty} \frac {1}{a_{2,1}a_{2,2}a_{2,3}}+…+ \sum_{3 \leq a_{n,1},a_{n,2},…,a_{n,n+1}< + \infty} \frac {1}{a_{n,1}a_{n,2},…a_{n,n+1}}+…$ $ .

where $ \{a_{1,1}a_{1,2}\}$ and $ \{a_{2,1}a_{2,2}a_{2,3}\}$ and … and $ \{a_{n,1}a_{n,2},…a_{n,n+1}\}$ and… are all of density zero in $ \mathbb N$ and every term of every sequence is odd.

Does all of this implies convergence of this infinite sum of infinite sums?

Scrollbars for an infinite plane

I’m designing a web application to plan Minecraft builds. Basically, it’s a pixel editor except that each tile has a texture instead of a color. I am targeting desktop browsers, though I would like to keep tablets in mind.

One of my goals is to present the canvas as an infinite plane. (This is a key feature that differentiates this design from existing alternatives. The Minecraft world is infinite, and so declaring a finite size ahead of time doesn’t make sense and is a pointless hurdle. In addition, expanding a pre-sized canvas is annoying.)

The canvas is zoomable, and it must be “scrollable” in both dimensions. The user should be able to view and edit any part of the canvas they like — even a million tiles away from the origin.

Scrollbars do not work perfectly here. The canvas has neither beginning nor end, and the origin point isn’t important to users, so there are no objective reference points. The populated areas of the canvas might serve as useful subjective reference points, and a scrollbar might be useful for navigation within those areas.

I read a great question about infinite scrolling patterns, and although it didn’t address this particular case it was very enlightening. After some consideration, I think that the application needs to support the following:

  • Moving the view to an arbitrary specified point.
  • Moving/zooming the view to include the entire populated area.
  • Precisely moving the view within the populated area and immediately outside it (say, one screenful, a measure that depends on the zoom).

A traditional scrollbar also indicates the size of the view in relation to the entire document, but that doesn’t make sense for us. It could be useful to indicate the size of the view in relation to the populated area, but I’m not sold on that.

Moving to a point or zoom/scrolling to see all content can be implemented using buttons, menu commands, or whatever. The trick is finding an interface for scrolling-like behavior that’s intuitive to use but meets the needs of the infinite plane.

What I’m thinking of at the moment is a sort of “scrub bar”. Visually, it’s a scrollbar (and could be implemented using native widgets). The knob is locked to the center when the user isn’t scrolling. When the user manually moves the knob, it scrolls the view accordingly, and when they release it, the knob snaps back to the center. This allows for precise linear scrolling despite a lack of objective reference points.

As specified, this does not allow the user to scroll an unlimited distance in a single operation. To support this, if the user drags the knob to either extreme end, the canvas could continue scrolling until the user released the knob or moved it away from the end.

Are there any good examples of infinite plane scrolling out there? And does the widget I suggest seem like a reasonable compromise?

All curves over an infinite field embed into the projective space

Let $ k$ be an infinite field. Let $ X$ be a separated scheme of finite type over $ k$ . Assume $ X$ have relative dimension $ \leq 1$ . Does there exist a locally closed immersion $ X\rightarrow \mathbb{P}^3_k$ ? Is there a published reference containing a complete proof?

I think over finite fields you can have too many points so this can fail.

EDIT: actually, I think if you have a very singular curve the dimension of the tangent space can be problematic. What are the minimal smoothness assumptions on $ X$ under which this is true?

Why does running GHCi in Windows make it not possible to detect infinite loops? [migrated]

I’m currently reading “Haskell Programming from first principles” and there is a paragraph in the section about bottom that reads:

Let us examine a few ways by which we can have bottom in our programs:

Prelude> let x = x in x 

*** Exception: << loop >>

Here GHCi detected that let x = x in x was never going to return and short-circuited the never-ending computation. This is an exam- ple of bottom because it was never going to return a result. Note that if you’re using a Windows computer, this example may freeze your GHCi and not throw an exception.

My question is: is there anything inherent to Windows that makes it impossible or difficult to detect this loop or is it just specific to the GHC(i) implementation?

Regularity of infinite concatenation

It is well-known that an infinite union of regular languages is not necessarily regular, since every language can be written as a union of singletons. What about infinite concatenations?

Let $ \{ L_z : z \in \mathbb{Z} \}$ be a family of languages, cofinitely many of which contain $ \epsilon$ . We can define the infinite union of the family as the collection of all words of the form $ w_{i_1} \ldots w_{i_n}$ , where $ i_1 < \cdots < i_n$ and $ w_{i_j} \in L_{i_j}$ . (The definition makes sense if we replace $ \mathbb{Z}$ with any linear order.)

Is the infinite concatenation of a family of regular languages necessarily regular?

How to improve the user experience on a infinite record historical flow?

I’m building a SaaS product and having doubts on how to organize the user navigation regarding historical and new user records.

One of our document objects is supposed to be stored forever – it is a stock transaction record.

So, in my application menu, I have two options:

  • Remove From Stock
  • Add To Stock
  • Show Stock Transactions

Both Remove From Stock and Add To Stock will open an input page where the user will select the stock item article, description and quantity and a new record is added to database. Date/Time and type (added/removed) fields are added automatically. The latest added field is shown in screen after commit.

The Show Stock Transactions option that will show all of my transactions over time. I’ve opted to use a date filter instead of pagination, as the following example:

enter image description here

The user can select a specific date rage (Today, Yesteday, etc.) or choose to type specific dates on the FROM and TO inputs.

In practice, this approach is getting “complaints” from the following points:

a) When adding new transactions, I should be switching screens on the menu. b) Every time I add a new transaction, I have to switch to “Show Stock Transactions” to see the added record. The added record is not easily visible on screen. c) There is no clone buttons. I need to be able to clone a previous transaction, no matter how old it is.

I knindly ask for ideas on how to improve this simple use case.

Examples of infinite sets of regular and non-regular languages that their union is regular and non-regular

Been looking around for a good source to answer the following question. Have read a few different sources but have not found the answer I was looking for. The question is:

“Give an example of an infinite set of:

a. Regular languages that their union is a regular language

b. Regular languages that their union is a non-regular language

c. Non-regular languages that their union is a regular language

d. Non-regular languages that their union is a non-regular language”

I’ve used the following post to answer question b, and I understand the method behind it (at least I think I do) – Union of regular languages that is not regular

What is the right way to approach this question? Wouldn’t an infinite set of anything would constitute a non-regular language by definition?

Any help would be appreciated.