algorithm analysis – Space complexity of using a pairwise independent hash family

I’m trying to analyze the space complexity of using the coloring function $f$ which appears in “Colorful Triangle Counting and a MapReduce Implementation”, Pagh and Tsourakakis, 2011, https://arxiv.org/abs/1103.6073.

As far as I understand, $f:(n) rightarrow (N)$ is a hash function, that should be picked uniformly at random out of a pairwise independent hash functions family $H$. I have a few general questions:

  1. Does the space complexity required by $f$ is affected by the fact that $H$ is $k$-wise independent? Why? (if it does, then also- how?)
  2. What do we know about $|H|$? What if $H$ is $k$-wise independent?
  3. Is there a more space-efficient way to store $f$ than storing an $N times m$ matrix that maps each vertex to its color, using O($N m$) storage words?
  4. Does the total space complexity which is required in order to use $f$ as described in the paper is $|H| cdot O(text{space complexity of } f)$?

Best regards

Forex analysis – General Forex Questions & Help

Forex traders typically use two analytical techniques to analyze the market. Technical analysis and fundamentals analysis. Fundamental analysts, primarily as a tactical tool for making trading decisions based on basic data and finding the right entry and exit points. Technical analysts use price charts to make a trading decision. Whatever analysis you choose to step into the Forex market, always use Stop Loss orders for all trades and only risk a small percentage of your trading account in a single trade.  

The Belgian regulator FSMA issued a warning about boiler room scams – Forex News & Analysis

The Belgian financial regulator – the Financial Services and Markets Authority (FSMA) – updated its list of unregulated entities and issued a warning about the new entries as the watchdog believes they are boiler room scams.

The warning lists ABConseils-patrimoine dot com; Takahashi and Partners and Tan Allen Piguet Asset Management.

The FSMA warned that the above-mentioned companies are not allowed to offer investment to traders neither in nor out of the country. The watchdog also urges traders not to have any dealings with said companies.  The FSMA then goes on to warn against responding to so-called cold-calling and not to transfer money to companies registered outside of the country.

Source

It makes sense, really, it’s poor idea to give your money to a company that exists entirely out of the reach of your local law enforcement.

computational mathematics – Accounting for nanoparticle effect for heat enhancement and analysis of nanofluid/oil flow in porous media using ShanChen LBM

Thanks for contributing an answer to Mathematics Stack Exchange!

  • Please be sure to answer the question. Provide details and share your research!

But avoid

  • Asking for help, clarification, or responding to other answers.
  • Making statements based on opinion; back them up with references or personal experience.

Use MathJax to format equations. MathJax reference.

To learn more, see our tips on writing great answers.

calculus and analysis – Performing iterated integrals

I would like to define a function $f_n(x)$ and plot it with Manipulate. The function is defined by
$$
f_{n+1}(x)=frac{1}{int_0^1(f_n(x’))^2dx’}left(int_0^xf_n(x’)dx’-int_0^1f_n(x’)dx’right)
$$

The key part is $int_0^xf_n(x’)dx’$, the iterated integral of the original function $f_1(x)$ and the rest is details – the other term in parentheses subtracts the average in each iteration, and the fraction normalizes in each iteration.

Before doing this more complex mapping, the first step is to be able to do iterated integrals, which I test with sine:

n = 2;
f(1)(x_) := Sin(x);
For(j = 1, j < n, j++, f(j + 1)(x_) := Integrate(f(j)(x), x))
Plot(f(1)(x), {x, 0, 10})

Disappointingly, I get

SetDelayed::write: Tag Sin in Sin(1)(x_) is Protected.
SetDelayed::write: Tag Sin in Sin(2)(x_) is Protected.

and an empty plot.

If I delete the index j

n = 2;
f(x_) := Sin(x);
For(j = 1, j < n, j++, f(x_) := Integrate(f(x), x))
Plot(f(x), {x, 0, 10})

gives recursion errors as the plot is attempted:

RecursionLimit::reclim2: Recursion depth of 1024 exceeded during evaluation of f(0.000204286).

What is the proper way to do an iterated integral like this?

Ideally, I’d be able to a sequence of already-defined functions $f_n(x)$ so they could be displayed by Manipulate later without needing to be recalculated.

azure – Sentiment analysis for speech in MS Teams meetings (classrooms to be more specific)

I’m looking for a solution that could be used with MS Teams for Education that could be used for sentiment analysis in real time during classroom discussions in synchronous on-line learning. I assume Azure’s Speech to Text could capture what is said but not sure what tools are available for the analysis.
Comments by individual students are not as important as gauging the overall sentiment in the classroom and ideally it would go past simply positive/negative to detecting mood, words or phrases that are being used frequently, lapses between questions and answers, etc.
Ideally the data could then be fed into Power BI for providing real-time indicators of what is happening in the class.

Any suggestions?

fa.functional analysis – Minimax theorems in nonconvex setting

Let $X$ be a topological space, $Z$ be a compact convex subset of $mathbb R^m$, and let $f:X times Z to mathbb R$ be a continuous function (w.r.t the product topology on $X times Z$).

Question. Under what minimal additional assumptions do we have the duality $sup_{x in X}inf_{z in Z}f(x,z) = sup_{z in Z}inf_{x in X}f(x,z)$ ?

The case $m=1$ (in which case $Z$ must be a compact interval in $mathbb R$) was proved in Theorem 1 of Minimax theorems in a fully non-convex setting.

real analysis – $lim_{trightarrow 0}U(t)f=f$ implies the convergence at each point?

I am new here and I would like to see if you can help me.
My question is if the limit $limlimits_{trightarrow 0}U(t)f=f$ imply the convergence at each point?

It seems to me that the statement is true, but I don’t know how to write it. Can you please give me some help?

real analysis – Unboundedness of anti-derivative

Note that I got this question from just messing around with a couple of functions and don’t know if it is actually true.

Let $f$ be a function such that $limlimits_{x to a}|x-a|f(x)=L$, and $0<L<infty$. Additionally let $f$ be integrable in a region, $B$, where $a$ is an accumulation point of $B$.
Then we know that,
$$forall epsilon >0 exists delta >0 : 0<|x-a|<delta implies ||x-a|f(x)-L|<epsilon.$$
Fix $epsilon$ such that $L>epsilon$, then this means that,
begin{equation}
frac{L-epsilon}{|x-a|}<f(x)<frac{L+epsilon}{|x-a|}.
end{equation}

Then let $F$, the anti-derivative of $f$ be defined as,
$$F(x)=int_{d}^{x}f(t) mathrm{d}t + k,$$
for some $d in B$ and $k in mathbb{R}$. Then I aim to show that $limlimits_{x to a}F(x)=infty$.

Now we know that $dfrac{1}{|x-a|}$ is integrable everywhere except $x=a$. Additionally $$int_{y}^{a}dfrac{1}{|x-a|} mathrm{d}x,$$
is unbounded and goes to $infty$ for $y neq a$.
Then taking the left hand side of the inequality above and integrating from $d<a$ to $x$ where, where $x$ is in $B$, we get that,
$$(L-epsilon)int_{d}^{x}frac{1}{|t-a|} mathrm{d}t+k<int_{d}^{x}f(t) mathrm{d}t+k=F(x).$$
Now taking the limit as $x$ approaches $a$ on both sides we achieve the desired result. That is $limlimits_{x to a}F(x)=infty$.

$textbf{My first question is:}$

Is this proof valid? Initially I thought that $L>1$ but it seems this ‘proof’ doesn’t use this assumption anywhere so I omitted it. It seems intuitively correct to assume this as the area under $dfrac{1}{|x-a|}$ is unbounded if we take one of the bounds as $a$, so the area under $f(x)$ must be unbounded as well.

$textbf{Second question (and the one I’m more concerned with):}$

Supposing the fact that this is true. Then couldn’t I supposedly assume the following proposition.

Let $g(x)$ and $f(x)$ have the following properties described in the proof, that is as $x$ approaches $a$, $G(x)$ and $F(x)$ (their respective anti-derivatives) are unbounded and approach $infty$.

Then if we take the limit of the ratio of $g(x)$ and $f(x)$, ($G(x), g(x) neq 0$),
$$lim_{x to a} frac{f(x)}{g(x)}.$$
Then integrate the numerator and denominator to obtain a supposedly different limit, that is,
$$lim_{x to a} frac{F(x)}{G(x)}.$$
However since we know that $F(x)$ and $G(x)$ both go to $infty$ as $x$ approaches $a$ we can apply L’Hospital’s rule and supposedly achieve the following,
$$lim_{x to a} frac{F(x)}{G(x)}=lim_{x to a} frac{f(x)}{g(x)}.$$
That is to say we achieve a sort of “inverse” L’Hopital’s rule if you will, assuming that the functions that are being concerned obey the properties laid out earlier.

$textbf{Third and final question:}$

The function $dfrac{1}{|x-a|}$ was chosen somewhat arbitrarily since it has that nature of having an unbounded area. Is there any function perhaps smaller than this but also has an unbounded area? Then perhaps this condition would capture a wider array of functions.

The reason for not being able to assume that solely $f(x)$ goes to infinity as $x$ goes to $a$ is because counter-examples exist for this, that is $ln|x|$, and a more strict unboundedness needed to be placed.

algorithm analysis – Analyzing space complexity of passing data to function by reference

I have some difficulties with understanding the space complexity of the following algorithm.
I’ve solved this problem subsets on leetcode. I understand why solutions’ space complexity would be O(N * 2^N), where N – the length of the initial vector. In all those cases all the subsets (vectors) are passed by value, so we contain every subset in the recursion stack. But i passed everything by reference. This is my code:

class Solution {
public:
vector<vector<int>> result;
void rec(vector<int>& nums, int &position, vector<int> &currentSubset) {
    if (position == nums.size()) {
        result.push_back(currentSubset);
        return;
    }
    
    currentSubset.push_back(nums(position));
    position++;
    rec(nums, position, currentSubset);
    currentSubset.pop_back();
    rec(nums, position, currentSubset);
    position--;
}

vector<vector<int>> subsets(vector<int>& nums) {
    vector <int> currentSubset;
    int position = 0;
    rec(nums, position, currentSubset);
    return result;
}
};

Would the space complexity be O(N)? As far as i know, passing by reference doesn’t allocate new memory, so every possible subset would be contained in the same vector, which was created before the recursion calls.

I would also appreciate, if you told me how to estimate the space complexity, when working with references in general. Those are the only cases, where i hesitate about the correctness of my reasonings.

Thank you.