text:
Skip to main content

# 1.3: Early attempts to understand the Nature of Heat: The Caloric Fluid Theory

## Contributors and Attributions

This page titled 1.3: Early attempts to understand the Nature of Heat: The Caloric Fluid Theory is shared under a CC BY-SA license and was authored, remixed, and/or curated by Michael Fowler.

• Was this article helpful?


text:
Expression

abstract class Expression<Value> < DelayExpression

Lazy expression.

• Value: Value type.

• x: Fixed value, or nil to evaluate.

The simplest use case of lazy expressions is to simply construct them and then call value() to evaluate them. Evaluations are memoized, so that subsequent calls to value() do not require re-evaluation of the expression, they simply return the memoized value. Objects may be reused in multiple expressions, e.g. two expressions with a common subexpression can share that subexpression.

More elaborate use cases include computing gradients and applying Markov kernels. For this purpose operations are separated into closed world and open world operations. The world is that of lazy expressions.

1. The quintessential open world operation is value(). The evaluated value may be used in any context, including eager-mode expressions and I/O operations. Consequently, the evaluated value of the expression must be made constant to avoid the inconsistency (and possibly incorrectness) of different evaluated values being used in different contexts.

2. Closed world operations include get(), pilot(), grad(), and move(). The caller of such member functions guarantees that the value is only used in the world of lazy expressions. The evaluated value of the expression can remain variable and still produce consistent results---it may, for example, be moved with a Markov kernel.

To keep track of whether an evaluated value is open world (constant) or closed world (variable), expressions are stateful:

• An Expression is initially considered variable.
• Once an open world operation is performed on the Expression, it and any subexpressions are considered constant.

This particularly affects the grad() and move() operations:

• grad() will compute gradients with respect to any variable Random objects but not constant objects, and similarly,
• move() will apply a Markov kernel to any variable Random objects but not constant objects.

Attention

Unless you are working on something like a Markov kernel, or other closed-world feature, you want to use value(), not get() or pilot(). Doing otherwise may risk correctness. Consider:

if x.value() >= 0.0 {
doThis();
} else {
doThat();
}

This is correct usage. Using get() or pilot() instead of value() here may result in a subsequent move on the value of x (by e.g. MoveParticleFilter) that switches the sign of the evaluated value, but does not change the branch taken, resulting in an invalid trace and incorrect results. This is because the evaluated value of the expression is not being used in the world of lazy expressions here: the if statement is not lazily evaluated.

Assignments

Name Description
Value Value assignment.

Member Variables

Name Description
x:Value? Memoized value.

Member Functions

Name Description
hasValue Does this have a value?
setValue Set the value.
setPilot Set the pilot value.
distribution If this is a Random, get the distribution associated with it, if any, otherwise nil.
value Evaluate, open world.
pilot Evaluate, closed world, before a call to grad().
get Evaluate, closed world.
move Move and re-evaluate.
compare Evaluate log-ratio of proposal probability densities after move.
count Make constant, as though calling value(), but without re-evaluating the expression.
constant Update counts, as though calling pilot(), but without re-evaluating the expression.

Member Function Details

compare

final function compare(gen:Integer, x:DelayExpression, κ:Kernel) -> Real

Evaluate log-ratio of proposal probability densities after move.

• gen: Generation limit.
• x: Starting state, $x$.
• κ: Markov kernel, $\kappa(\mathrm{d}x^\prime \mid x)$.

Returns: The log-ratio of proposal probability densities after move, $\log q(x \mid x^\prime) - \log q(x^\prime \mid x)$. This object is considered to represent the proposed state $x^\prime$.

The generation limit gen works to truncate the recursion, as for grad().

constant

function constant()

Update counts, as though calling pilot(), but without re-evaluating the expression.

count

function count(gen:Integer)

Make constant, as though calling value(), but without re-evaluating the expression.

distribution

function distribution() -> Distribution<Value>?

If this is a Random, get the distribution associated with it, if any, otherwise nil.

get

final function get() -> Value

Evaluate, closed world.

Returns: The evaluated value of the expression.

get() is similar to pilot() except that it does not update counts in anticipation of a following call too grad(). It can be used at any time to retrieve the evaluated value of the expression, evaluating it if necessary, without disrupting the state.

Evaluate gradients. Gradients are computed with respect to all variables (Random objects in the pilot or gradient state).

• Gradient: Gradient type. Must be one of Real, Real[_] or Real[_,_].

• gen: Generation limit.

• d: Upstream gradient. For an initial call, this should be the unit for the given type, e.g. 1.0, a vector of ones, or the identity matrix.

The generation limit gen is used to truncate the recursion. Any expressions that have been assigned a generation number less of than gen (usually at the time they are evaluated with pilot()), are considered constant for the purposes of gradient evaluation. As the default generation is zero, a value of less than or equal to zero here will not truncate the recursion.

grad() must be called as many times as pilot() was previously called. This is because subexpressions may be shared. The calls to pilot() are used to determine how many times the object occurs as a subexpression. The subsequent calls to grad() accumulate upstream gradients this number of times before recursing. This is an important optimization for many use cases, such as computing gradients through Bayesian updates.

Reverse-mode automatic differentiation is used. The previous calls to pilot() constitute the forward pass, the subsequent calls to grad() constitute the backward pass. If the expression tree encodes

x_n = f(x_0) = (f_n \circ \cdots \circ f_1)(x_0),

and this particular node encodes one of those functions $x_i = f_i(x_{i-1})$, the argument to the function is

\frac{\partial (f_n \circ \cdots \circ f_{i+1})} {\partial x_i}\left(x_i\right),

it computes

\frac{\partial (f_n \circ \cdots \circ f_{i})} {\partial x_{i-1}}\left(x_{i-1}\right),

and passes the result to its child, which encodes $f_{i-1}$, to continue the computation. The variable (Random object) that encodes $x_0$ keeps the final result.

Evaluate gradient for an element of a vector.

• gen: Generation limit.
• i: Element index.

final function grad(gen:Integer, d:Real, i:Integer, j:Integer)

Evaluate gradient for an element of a matrix.

• gen: Generation limit.
• i: Row index.
• j: Column index.

hasValue

function hasValue() -> Boolean

Does this have a value?

Returns: true if a value has been evaluated with value(), pilot() or get(), false otherwise.

Note that this differs from isConstant(), which will only return true for a value that has been evaluated with value().

move

final function move(gen:Integer, κ:Kernel) -> Value

Move and re-evaluate. Variables are updated with a Markov kernel, possibly using gradient information, and the expression re-evaluated with these new values.

• gen: Generation limit.
• κ: Markov kernel, $\kappa(\mathrm{d}x^\prime \mid x)$.

Returns: The evaluated value of the expression.

The generation limit gen works to truncate the recursion, as for grad().

pilot

final function pilot(gen:Integer) -> Value

Evaluate, closed world, before a call to grad().

• gen: Generation number.

Returns: The evaluated value of the expression.

If the expression has not yet been evaluated (excepting a previous call to get()), the generation number gen is assigned to it for future use.

pilot() may be called multiple times, which accumulates a count. If the intent is to compute gradients, grad() must subsequently be called the same number of times. This is because subexpressions may be shared. The calls to pilot() are used to determine how many times the object occurs as a subexpression. The subsequent calls to grad() accumulate upstream gradients this number of times before recursing. This is an important optimization for many use cases, such as computing gradients through Bayesian updates.

setPilot

function setPilot(x:Value)

Set the pilot value.

• x: Pilot value.

setValue

function setValue(x:Value)

Set the value.

• x: Value.

value

final function value() -> Value

Evaluate, open world.

Returns: The evaluated value of the expression.

An expression is considered constant once value() has been called on it. All subexpressions are necessarily also then constant, including any Random objects that occur, which are no longer considered variables for the purpose of grad() and move().

If this is not the intended behavior, consider get() or pilot().

format: plain


text:
Lemma 33.38.14. Let $f : X \to Y$ be a morphism of schemes. Assume $Y$ is Noetherian of dimension $\leq 1$, $f$ is finite, and there exists a dense open $V \subset Y$ such that $f^{-1}(V) \to V$ is a closed immersion. Then every invertible $\mathcal{O}_ X$-module is the pullback of an invertible $\mathcal{O}_ Y$-module.

Proof. We factor $f$ as $X \to Z \to Y$ where $Z$ is the scheme theoretic image of $f$. Then $X \to Z$ is an isomorphism over $V \cap Z$ and Lemma 33.38.7 applies. On the other hand, Lemma 33.38.11 applies to $Z \to Y$. Some details omitted. $\square$

In your comment you can use Markdown and LaTeX style mathematics (enclose it like $\pi$). A preview option is available if you wish to see how it works out (just click on the eye in the toolbar).


text:
Kerodon

$\Newextarrow{\xRightarrow}{5,5}{0x21D2}$ $\newcommand\empty{}$

Remark 5.4.7.6. The existence of morphisms between $(\infty ,2)$-categories which do not preserve thin $2$-simplices should be viewed as a feature of our formalism, rather than a bug. Recall that, if $\operatorname{\mathcal{C}}$ and $\operatorname{\mathcal{D}}$ are $2$-categories, then Theorem 2.3.4.1 supplies a bijection

$\xymatrix@R =50pt@C=50pt{ \{ \textnormal{Strictly unitary lax functors \operatorname{\mathcal{C}}\rightarrow \operatorname{\mathcal{D}}} \} \ar [d]^-{\sim } \\ \{ \textnormal{Morphisms of simplicial sets \operatorname{N}_{\bullet }^{\operatorname{D}}(\operatorname{\mathcal{C}}) \rightarrow \operatorname{N}_{\bullet }^{\operatorname{D}}(\operatorname{\mathcal{D}})} \} . }$

Consequently, we can think of general morphisms of simplicial sets as providing a generalization of the notion of (strictly) unitary lax functors to the setting of $(\infty ,2)$-categories.


text:
# Quiz Chapter 06.03: Linear Regression

 MULTIPLE CHOICE TEST LINEAR REGRESSION REGRESSION

1. Given $\left(x_{1},y_{1} \right), \, \left( x_{2}, y_{2} \right), \, ... \, , \, \left( x_{n}, y_{n} \right)$ best fitting data to $y = f (x)$ by least squares requires minimization of

2. The following data

 $x$ $1$ $20$ $30$ $40$ $y$ $1$ $400$ $800$ $1300$

is regressed with least square regression to $y = a_{0} + a_{1}x$. The value of $a_{1}$ is most nearly

3. The following data

 $x$ $1$ $20$ $30$ $40$ $y$ $1$ $400$ $800$ $1300$

is regressed with least square regression to $y = a_{1}x$. The value of $a_{1}$ is most nearly

4. An instructor gives the same $y$ vs $x$ data as given below to four students and asks them to regress the data with least squares regression to $y = a_{0} + a_{1}x$.

 $x$ $1$ $10$ $20$ $30$ $40$ $y$ $1$ $100$ $400$ $600$ $1200$

Each student comes up with four different answers for the straight-line regression model. Only one is correct. The correct model is

5. A torsion spring of a mousetrap is twisted through an angle of $180^{\circ}$. The torque vs. angle data is given below

 Torsion, $T$, N-m $0.110$ $0.189$ $0.230$ $0.250$ Angle, $\theta$, rad $0.10$ $0.50$ $1.1$ $1.5$

The amount of strain energy stored in the mousetrap spring in Joules is

6. A scientist finds that regressing the $y$ vs $x$ data given below to $y = a_{0} + a_{1}x$ results in the coefficient of determination for the straight-line model, $r^{2}$, being zero

 $x$ $1$ $3$ $11$ $17$ $y$ $2$ $6$ $22$ ?

The missing value for $y$ at $x = 17$ most nearly is


text:
# Positive Second derivative and convexity

Let $f:\mathbb R\to\mathbb R$, maps a point $x \in \mathbb R$. $f$ is twice differentiable. Show that if second derivative is positive for all $x$ then $f$ is convex

Is there anyway to prove this without using MVT/definitions of derivatives?

Basically can this be proven with just the definition of convexity/concavity and maybe quasi-convexity and lower contours. The definition we learned use for convexity is: $f$ is convex if $$f(\theta x_a + (1-\theta) x_b) \leq \theta f(x_a) + (1-\theta) f(x_b).$$

-

We know that if $f$ is differentiable in some interval, say $I$, then $f$ is concave upward in $I$ iff $$f(x)<\frac{x_2-x}{x_2-x_1}f(x_1)+\frac{x-x_1}{x_2-x_1}f(x_2)$$ for all $x_1,x,x_2\in I$ such that $x_1<x<x_2$. Use this fact.

-
Hey Babak, I see that if I let x be the weighted average of x2 and x1 I have my result. However, can you tell me where you got that iff for f concave upward? –  Alex Feb 11 '13 at 9:08
@Alex: You know this fact is a stared problem I think in R.A.Silver man's Calculus book. –  Babak S. Feb 11 '13 at 9:31
Okay thank you, but I have another question.. what exactly is the difference between concave upward and convex? Because on wikipedia it states the two interchangeably. If that is the case, then then are we not using concave up to prove convexity (which is circular logic)? Or is concave up defined as an increasing first derivative? –  Alex Feb 11 '13 at 9:47
@Alex: The main idea, I think, is the same as i.a.m noted below. In fact the similar deduction is true for concavity downward whit < replaced by >. –  Babak S. Feb 11 '13 at 10:11
Great help you are here at M.S.E.+1 ! –  amWhy Feb 12 '13 at 2:59

If $f''>0$ for all $x$, then $f$ is concave up, and if you look at the line passing throw any two points on the curve, the line will be above the curve, which implies $f$ is convex.

-
Doesn't this implicitly use Taylor's theorem (and an additional assumption that $f$ is analytic) to construct the local approximation of $f$? –  user7530 Feb 11 '13 at 6:59
@user7530, No I'm just using the fact that $f$ is twice differentiable and the second derivative is positive, which implies that $f$ is concave up, and if you write the equation of any line passing two points on the curve you will get the RHS of your inequality, and the LHS is f(....) and the inequality holds since the line is always above the curve by the concavity of f. –  i.a.m Feb 11 '13 at 7:04
I'm sorry I don't quite undertsand the last line. I understand your concave up argument, but what do you mean by "by the concavity of f".. f is not concave. –  Alex Feb 11 '13 at 7:08
@Alex, f is concave up since f''>0. –  i.a.m Feb 11 '13 at 7:18
@Alex imagine the curve of x^2 then any line joining two point on this curve will be above the curve since x^2 is concave up, this is the same argument is used for the general curve f, since it is concave up since the second derivative is positive. –  i.a.m Feb 11 '13 at 7:21


text:
[R-sig-finance] swap to forward rates

Thomas Steiner finbref.2006 at gmail.com
Wed Feb 22 16:49:06 CET 2006

Again, I want to calculate forward rates from swap rates.
Krishna Kumar was already very kind to help me here (24.1.06) and he
provided an algorithm, I did not understand. So I now figured out my
own one and unfortunately the two results do not coincide but both
appear very plausible.

How can you help me?
If you have a lot of time, check my algorithm or my formula.
If you have already implemented this yourself somewhere, please
compare my results with yours and with those of Kris. And let me know

Perhaps you can have a quick look at this and verify the results.

I have EUR-swap rates for 2Y, 3Y, 5Y, 7Y, 10Y, 20Y and 30Y, eg for 2005-12-13:

sc=list(
maturity=c(2,3,5,7,10,20),
tenors=c(2,1,2,2,3,10),    #the difference between two dates (=\tau_i)
rate=c(0.02982,0.03074,0.03230,0.03354,0.03533,0.03861),
date="2005-12-13"
);

#Kris' way from swap via discount to forward rates:
swap2discount<-function(swapcrv) {
n<-length(swapcrv$rate) dfcrv<-list() dfcrv$maturity    <- swapcrv$maturity dfcrv$discount    <- 1/(1+swapcrv$tenors*swapcrv$rate)
dfcrv$discount[-1]<- dfcrv$discount[-1]*(1-(cumsum(swapcrv$tenors[-n]*dfcrv$discount[-n]))*swapcrv$rate[-1]) dfcrv$date=swapcrv$date return(dfcrv) } discount2fwd<-function(dfcurve,times=dfcurve$maturity) {
times<-c(0,times)
n<-length(times)
fwd<-array(0,n)
df.tenor<-array(0,n)
df.tenor<-approx(x=dfcurve$maturity,y=dfcurve$discount,xout=times,rule=2)$y df.tenor[1]<-1 fwd<-(df.tenor[-n]/df.tenor[-1] -1)/diff(times) fwd<-c(fwd[1],fwd) return(list(maturity=times,rate=fwd,date=dfcurve$date))
}
dc=swap2discount(sc)
discount2fwd(dc)
#gives rates:  0.02982000 0.03264006 0.03592894 0.04081783 0.04582491 0.05007956

#my function:
# from Brigo/Mercurio, p.15; solve the last equation on this page for F_\beta:
# $$\1+\tau_\beta F_\beta = \frac{1+S_{\alpha,\beta}(t) \tau_\beta}{\Pi_{j=\alpha+1}^{\beta-1}(1+\tau_jF_j) - S_{\alpha,\beta}(t)\Sum_{i=\alpha+1}^{\beta-1}\tau_i\Pi_{j=i+1}^{\beta-1}(1+\tau_jF_j) }$$
swap2fwd<-function(sc) {
fwd=array(dim=length(sc$rate)) fwd[1]=sc$rate[1]
fwd[2]=( (1+sc$rate[2]*sc$tenors[2])/(1+sc$tenors[1]*fwd[1]-sc$rate[2]*sc$tenors[1])-1 ) / sc$tenors[2]
n<-length(sc$maturity) for (t in 3:n) { cumpr=rev(c(1, cumprod(1+sc$tenors[(t-1):2]*fwd[(t-1):2]) ))
su=sum( sc$tenors[1:(t-1)] * cumpr ) fwd[t]=(1+sc$rate[t]*sc$tenors[t]) / ( prod(1+sc$tenors[1:(t-1)]*fwd[1:(t-1)])-sc$rate[t]*su ) fwd[t]=(fwd[t]-1)/sc$tenors[t]
}
return(list(
maturity=sc$maturity,rate=fwd,date=sc$date
))
}
swap2fwd(sc)
#gives 0.02982000 0.03264006 0.03485760 0.03705553 0.04046209 0.04409305

My results are a bit lower then Kris'. What do you suggest me to use
now? A pro's solution I don't understand or my own answer?
If I add the 30Y swap rate (0.03922), results are strage again in both
cases (too high and to low respectively).

What I did not take into account are daycount conventions and the fact
the the very first point in the swap curve should be a cash rate. This
will come later...

Any help, hint and comparison is very welcome.
Thomas


text:
# How does mip-mapping work with non-power-of-2 textures?

I have heard that recent GPUs all support non-power-of-2 textures and all features just work. However, I don't understand how mip-mapping would work in such a scenario. Can someone explain?

The rule is that to compute the next mipmap size, you divide by two and round down to the nearest integer (unless it rounds down to 0, in which case, it's 1 instead). For example, a 57x43 image would have mipmaps like:

level 0: 57x43
level 1: 28x21
level 2: 14x10
level 3: 7x5
level 4: 3x2
level 5: 1x1

UV mapping, LOD selection, and filtering work just the same way as for power-of-two texture sizes.

Generating good quality mips for a non-power-of-two texture is a little trickier, as you can't simply average a 2x2 box of pixels to downsample in all cases. However, a 2x2 box filter wasn't that great to begin with, so using a better downsampling filter such as Mitchell-Netravali is recommended regardless of the texture size.

• Is there disagreement between this answer and John Calsbeek's answer? Does the implementation match both descriptions? If not then it would be useful to have a reference for one or other (or both if they are two different techniques both in use). – trichoplax Sep 8 '15 at 20:54

One way to think of it is that graphics cards often implement non-power-of-2 textures simply by padding them until they are a power of 2 in each direction. This makes most things "just work": tiling and hardware filtering, for example. The only thing that needs to change is the conversion from texture coordinates to image coordinates.

If implemented like that, it's obvious how to do mipmapping: nothing changes. Even if you have a GPU that supports non-power-of-2 textures without padding, the mipmap levels would end up with "padding". e.g. a 3x3 texture would have a 2x2 texture as lod 1.

• Is there disagreement between this answer and Nathan Reed's answer? Does the implementation match both descriptions? If not then it would be useful to have a reference for one or other (or both if they are two different techniques both in use). – trichoplax Sep 8 '15 at 20:55
• @trichoplax I think Nathan's assertion that "generating good quality mips for a non-power-of-two texture is a little trickier" makes our answers disagree at least slightly. That alone probably merits more elaboration. – John Calsbeek Sep 8 '15 at 21:09
• I think the problem here is that we're confusing the logical position of texels with their "physical" layout in memory. 1) Pixels are discrete items, i.e. you always need an integer dimension, and so down scaling an odd dimension means that we have to either round up or round down. Since we have to round up once we get to an Nx1 or 1xN texture, it makes sense to always round up. 2) When laid out in physical addresses, it is not uncommon to pad the texture out to some "convenient" "stride" size. This may be done for 2 reasons: a) It may make HW cheaper & b) if a P.of.2, Morton order is easy. – Simon F Sep 9 '15 at 16:23


text:
Corpus ID: 235446639

Learning-based Support Estimation in Sublinear Time

@article{Eden2021LearningbasedSE,
title={Learning-based Support Estimation in Sublinear Time},
author={T. Eden and P. Indyk and Shyam Narayanan and R. Rubinfeld and Sandeep Silwal and Tal Wagner},
journal={ArXiv},
year={2021},
volume={abs/2106.08396}
}
We consider the problem of estimating the number of distinct elements in a large data set (or, equivalently, the support size of the distribution induced by the data set) from a random sample of its elements. The problem occurs in many applications, including biology, genomics, computer systems and linguistics. A line of research spanning the last decade resulted in algorithms that estimate the support up to ±εn from a sample of size O(log(1/ε) · n/ log n), where n is the data set size… Expand
1 Citations

Figures and Tables from this paper

Putting the "Learning" into Learning-Augmented Algorithms for Frequency Estimation
• Computer Science
• ICML
• 2021
It is shown that machine learning models which are trained to optimize for coverage lead to large improvements in performance over prior approaches according to the average absolute frequency error. Expand

References

SHOWING 1-10 OF 31 REFERENCES
Estimating the unseen: an n/log(n)-sample estimator for entropy and support size, shown optimal via new CLTs
• Mathematics, Computer Science
• STOC '11
• 2011
We introduce a new approach to characterizing the unobserved portion of a distribution, which provides sublinear--sample estimators achieving arbitrarily small additive constant error for a class ofExpand
Estimating the Unseen: Improved Estimators for Entropy and other Properties
• Computer Science, Mathematics
• NIPS
• 2013
This work proposes a novel modification of the Good-Turing frequency estimation scheme, which seeks to estimate the shape of the unobserved portion of the distribution, and is robust, general, and theoretically principled; it is expected that it may be fruitfully used as a component within larger machine learning and data analysis systems. Expand
Learning-Augmented Data Stream Algorithms
• Computer Science
• ICLR
• 2020
The full power of an oracle trained to predict item frequencies in the streaming model is explored, showing that it can be applied to a wide array of problems in data streams, sometimes resulting in the first optimal bounds for such problems. Expand
Optimal prediction of the number of unseen species
• Mathematics, Medicine
• Proceedings of the National Academy of Sciences
• 2016
A class of simple algorithms are obtained that provably predict U all of the way up to t∝logn samples, and it is shown that this range is the best possible and that the estimator’s mean-square error is near optimal for any t. Expand
Probability-Revealing Samples
• Computer Science
• AISTATS
• 2018
This work introduces a model in which every sample comes with the information about the probability of selecting it, and gives algorithms for problems such as testing if two distributions are (approximately) identical, estimating the total variation distance between distributions, and estimating the support size. Expand
An optimal algorithm for the distinct elements problem
• Computer Science
• PODS '10
• 2010
The first optimal algorithm for estimating the number of distinct elements in a data stream is given, closing a long line of theoretical research on this problem, and has optimal O(1) update and reporting times. Expand
• Computer Science, Mathematics
• ICLR
• 2019
This work designs and trains a neural net which last layer forms a fixed parameter-free quantizer, such as pre-defined points of a hyper-sphere, and proposes a new regularizer derived from the Kozachenko--Leonenko differential entropy estimator to enforce uniformity and combine it with a locality-aware triplet loss. Expand
Learning-Based Frequency Estimation Algorithms
• Computer Science
• ICLR
• 2019
This work proposes a new class of algorithms that automatically learn relevant patterns in the input data and use them to improve its frequency estimates, and proves that these learning-based algorithms have lower estimation errors than their non-learning counterparts. Expand
Learning to Branch
• Computer Science
• ICML
• 2018
It is shown how to use machine learning to determine an optimal weighting of any set of partitioning procedures for the instance distribution at hand using samples from the distribution, and it is proved that this reduction can even be exponential. Expand
Chebyshev polynomials, moment matching, and optimal estimation of the unseen
• Mathematics
• 2015
We consider the problem of estimating the support size of a discrete distribution whose minimum non-zero mass is at least $\frac{1}{k}$. Under the independent sampling model, we show that the sampleExpand


text:
# Sh:127

• Shelah, S. (1981). On uncountable Boolean algebras with no uncountable pairwise comparable or incomparable sets of elements. Notre Dame J. Formal Logic, 22(4), 301–308.
• published version (8p)
Bib entry
@article{Sh:127,
author = {Shelah, Saharon},
title = {{On uncountable Boolean algebras with no uncountable pairwise comparable or incomparable sets of elements}},
journal = {Notre Dame J. Formal Logic},
fjournal = {Notre Dame Journal of Formal Logic},
volume = {22},
number = {4},
year = {1981},
pages = {301--308},
issn = {0029-4527},
mrnumber = {622361},
mrclass = {03E50 (06E05)},
url = {http://projecteuclid.org/euclid.ndjfl/1093883511}
}


text:
# Journal of Operator Theory

Volume 80, Issue 2,  Fall  2018  pp. 257-294.

Existence of common hypercyclic vectors for translation operators

Authors:  Nikos Tsirivas
Author institution: University College Dublin, School of Mathematical Sicences, Belfield, Dublin 4, Dublin, Ireland and Department of Mathematics, University of Ioannina, P.C. 45110, Panepistimiopolis Ioannina, Greece

Summary:  Let $\mathcal{H}(\mathbb{C})$ be the set of entire functions endowed with the topology $\mathcal{T}_\mathrm u$ of local uniform convergence. Fix a sequence of non-zero complex numbers $(\lambda_n)$ with $|\lambda_n|\!\!\to\!\! +\infty$ and $|\lambda_{n+1}|/|\lambda_n|\!\!\to\!\! 1$. We prove that there exists a residual set $G\!\!\subset\!\! \mathcal{H}(\mathbb{C})$ so that for every $f\!\!\in\!\! G$ and every non-zero complex number $a$ the set $\{ f(z\!\!+\!\!\lambda_na):n\!\!=\!\!1,2,\ldots \}$ is dense in $(\mathcal{H}(\mathbb{C}),\mathcal{T}_\mathrm u)$. This provides a very strong extension of a theorem by G.~Costakis and M.~Sambarino in \textit{Adv. Math.} \textbf{182}(2004), 278--306. Actually, in that article, the above result is proved only for the case $\lambda_n\!\!=\!\!n$. Our result is in a sense best possible, since there exist sequences $( \lambda_n )$, with $|\lambda_{n+1}|/|\lambda_n| \!\!\to\!\! l$ for certain $l\!\!>\!\!1$, for which the above result fails to hold, cf.\ F.~Bayart, \textit{Int. Math. Res. Notices} \textbf{21}(2016), 6512--6552.

DOI: http://dx.doi.org/10.7900/jot.2017aug03.2194
Keywords:  hypercyclic operator, common hypercyclic functions, translation\break operator