## Getting values of 2 variables and a constant based on a single equation using a 3D graph

This is my function.

```````g(p_, q_, c_) :=
2^(-p*Log2(p) -
q*Log2(q) - (1 - p)*Log2(1 - p) - (1 - q)*
Log2(1 - q))*(c^(p*q + (1 - p)*(1 - q)))*(1 - c)^(1 -
p*q - (1 - p)*(1 - q))`
``````

I have graphed this function taking g as a function of p and q, I am varying c as a constant.

```````flo=Manipulate(Plot3D({g(p, q, c)}, {p, 0, 1}, {q, 0, 1}), {c, 0.001, 1})`
``````

How can I get values of p, q and c so that g(p,q,c)<1?

## Integral weight modular forms which reduce a given prime number to a constant non-zero modulo

Let $$B_k = frac {N_k} {D_k}$$ to be the reduced numerator and denominator of the $$k$$-th number Bernoulli. For a given prime number $$p> 2$$, the Eisenstein series (standardized in an unconventional way) $$E_ {p-1} (z) = N_ {p-1} – 2 (p-1) D_ {p-1} sum_ {n = 1} ^ { infty} sigma_ {p-2} ( n) q ^ n$$ has the property that its Fourier coefficients are all integers, and the constant coefficient is the only coefficient not divisible by $$p$$.

Given a premium $$p$$, I am interested in the existence of a modular form $$f_p$$ with similar properties but whose weight is half integral. In other words, $$f_p$$ must have integral Fourier coefficients, the constant coefficient must be prime to $$p$$and all other coefficients must be divisible by $$p$$.

The exact weight and level are not limited, but should preferably be kept small enough to be calculated with moderately small values ​​of $$p$$.

The only example I know of is the theta function $$thêta (z) = 1 + 2q + 2q ^ 4 + …$$ for $$p = 2$$.

## hash – Is there a constant space accumulator for a set of numbers to facilitate the test of belonging to a set?

My question: which data structure or which algorithm could I use to effectively solve the problem of belonging to the following set?

Imagine that I generate a 32-bit random integer every second and add it to a list of N integers. Imagine that every time I generate an integer, I send it (and any other information to which I would have easy access) to a client. Later, the client will submit an integer (with any other information I have given them), and I want to be able to quickly determine if a given integer has already appeared in my set, but I want to do this in constant time, using a small constant amount of memory. In other words, I don't want to just keep all of my generated numbers in a list or hash and check the whole submitted against this list. Ideally, adding a number to this set is a constant-time operation. I never need to delete numbers from the set.

Option 1: I could use a flowering filter and add each number to the flowering filter. Unfortunately, the defined membership test would be probabilistic, but I could make the filter large enough to reduce my likelihood of a false positive being low enough. I am open to this approach, but I want to know what other options I might have.

Option 2: I read about cryptographic accumulators. If each of the numbers I generated was prime, I think I could use an RSA accumulator to store a single accumulator value of constant size. Whenever I add a new bonus to my set, I add it to the accumulator, then I also generate its cookie and send both the number and the cookie to my customer. Later, the client would submit the whole that he is testing and the witness, and I would be able to quickly determine if the number submitted is actually a member of my set or not. Possible problems: I need to be able to hash a prime number deterministically. (Not the end of the world, but adds complexity) I think I need to update my witness values ​​when I add new values ​​to the accumulator. Finally: My understanding of accumulators is rudimentary.

Possible modifications:
1: Would it be easier if the following values ​​in my number string depended in one way or another on the previous values? You could imagine some sort of non-cryptographic hash string, whose current hash value includes enough information about its previous values ​​that it could quickly determine, "Yes, if my current hash value is X, and you submit Y, Y was definitely a previous member of my channel. "
2: If I understand them correctly, accumulators seem to be a very space-efficient way to store sets of prime numbers (and perhaps other values), but in the literature, they all assume potential adversaries. In my case, I don't need my witness to be tamper-proof, so I think that would make the problem much easier to solve. Maybe it just means that I can use smaller constants (so I don't need to use RSA-2048?). Or maybe it simplifies my problem even more?
3: What if the "random" values ​​that I generated increased or were simply timestamps? (I still need to know if this particular timestamp has already been used)

Related issues:
It is very similar to having a lot of hash values ​​in a Merkle tree or a hash chain (blockchain), and wanting to be able to determine if a particular hash value has already been seen in the chain, without have to store every value that had been seen in the string. I hope that with the additional concept of generating any "cookie" value to store with the number, the server can make a membership determination with much less overhead than # 39; have to store all the numbers.
It also seems similar to a verifiable journal or an authenticated dictionary.

## constant factor of strassen algorithms

Numerous references say that the large constant term is hidden in the calculation of the time complexity of the Strassen algorithm.

I want to know how the huge constant term is constructed or how it is calculated mathematically. (assuming that n matrices are given)

You can add more matrix constraints to help with the solution.

Thank you

## Established niche site with constant organic traffic

you don't

Advertise just about anything here, with CPM banner ads, CPM email ads, and CPC context links. You can target relevant areas of the site and show ads based on the user's location if you wish.

Starts at just \$ 1 per CPM or \$ 0.10 per CPC.

## algorithms – How to interpolate between change in value and constant?

I have a cursor that goes from 0 to 100 and as the cursor increases it should change a floating value from its current value to a target value, so when the cursor is at 100 it will be at the target value .

Additional difficulty, there is no way to store the original starting value, the equation is used as an expression which is rerun each time the cursor is moved so that you cannot retrieve only the current value of the float.

Thanks for any help!

## directx – If I use vertex shader to perform all operations on the object, can the constant buffer be empty?

The program cycle is

``````Update();
UpdatePipeline();
``````

In `Update()` constant buffer for each object, which after transformations, has this object world matrix is ​​copied to the GPU upload heap. And in `UpdatePipeline()`, among others, the installed shaders are called. Because we do all the matrix transformations using the CPU, the vertex shader just returns the position, right? If yes – is it true that performance will increase?

Now I want to do all the transformations using the GPU, i.e. via the vertex shader. This means that in `Update()` I should just call `memcpy()` with a constant empty buffer as the source?

## time series analysis – an algorithm for detecting whether noisy univariate data is constant or is the sum of step functions

In an explicit algorithm that I write, there is a certain step where I need to determine whether or not certain noisy univariate data are constant or are the sum of the step functions.

For example, define foo as the algorithm I'm after (write in python):
affirm foo ((0) * 20) == False
affirm foo ((0) * 20 + (1) * 20) == True
affirm foo ((0) * 20 + (5) * 30 + (1) * 70) == True

• The data in the examples is not noisy, but let's assume that the real one is (just a little, one can determine where a step could take place by observing the plotting of the data.

I would be happy to hear ideas, thanks.

## Abstract algebra – Dieudonne module of the constant group diagram \$ mathbb Z / p ^ n mathbb Z \$

Let $$k$$ to be a perfect characteristic field $$p> 0$$, denote by $$W = W (k)$$ the associated ring of ($$p-$$) Witt vectors and consider the constant group scheme $$G = ( mathbb Z / p ^ n mathbb Z) _k$$ more than $$k$$. I would like to show that its contravariant Dieudonne module $$M (G)$$ is isomorphic to $$W (k) / (p ^ n)$$ with the action Frobenius $$F = operatorname {id}$$ (and necessarily, Verschiebung action $$V = p$$).

The underlying $$W (k)$$-the structure of the module $$M (G)$$ is easily visible $$W (k) / (p ^ n)$$, like the basic ring $$W (k)$$ is a PID and by functoriality using this multiplication by $$p ^ l$$ in $$G$$ East $$0$$ only when $$l geq n$$.

By étaleness of $$G$$ or by directly checking the definitions, the relative Frobenius $$F_ {G / k}: G rightarrow G ^ {(p)}$$ is an isomorphism, hence the action of Frobenius on $$M (G)$$ must be an automorphism. Attach a basic element $$e$$ for $$M (G)$$, we must have $$F (e) = alpha e$$ for some people $$alpha in W (k) ^ { times}$$.

Is it possible to resize the base element $$e$$ so we can assume $$alpha = 1$$ ?

If I resize $$e$$ through $$e & # 39 ;: = lambda e$$ for some people $$lambda in W (k) ^ { times}$$, I see it $$alpha$$ turns into $$alpha & # 39 ;: = frac { sigma ( lambda)} { lambda} alpha$$ or $$sigma$$ is the Frobenius automorphism of $$W (k)$$. The question is whether I can choose $$lambda$$ so that $$alpha & # 39; = 1$$.

This problem made me think of Hilbert's theorem 90 as shown here Corollary $$1$$ page $$2$$, but I don't know if this can apply to this context. Course it would work if $$k$$ was finished cardinal $$q = p ^ f$$, as $$L: = operatorname {Frac} (W (k))$$ would then be the unbranched extension of $$mathbb Q_p$$ of degree $$f$$, which is cyclical with the Galois group generated by $$sigma$$. How about a general $$k$$ ?

## debugging – Rider / Unity attaches and plays the debugger: constant decompilation popups when entering the UnityEngine code

I'm trying to learn how to use Rider's debugging tools for Unity. I have only used a debugger a few times before.

I put a breakpoint in my code and hit Attach and Play Debug. It stops correctly at my stop point. But now, when I press step in several times, this comes to the end of my script and then I constantly get decompilation prompts, which, I suppose, means that the debugger has entered the UnityEngine code. Is there a way to prevent this from happening so that it only looks at my code? Or a way to continue until the next breakpoint? How do people avoid this problem?

Also, I can't stop debugging because of the prompts, I have to go to the task manager and exit the driver.