## parametrization – Intermediate Calculus Question

Q: Let P be the standard paraboloid in R3, and let S be the surface which results from positioning it as follows:
(a) The vertex is at the origin;
(b) the axis of the paraboloid is the line spanned by the vector a=(1,1,1);
(c) the paraboloid is open in the direction of a.

Find a parametrization for S which is regular at every point of its domain – Remember: Don’t forget to check that the parametrization you suggest is regular at every point of its domain

## Why do I need a websocket intermediate for a telnet server in a web client?

I’m very new to the concepts of protocols and networks and a project just fell on my desk regarding these topics.
The project is a MUD (Multi-User-Dangeon, one of those old text-based rpg’s that you can run from the terminal).
The problem in it is that it’s using a third-party client to give users a web interface, the client is served by this third-party entity and they give the possibility for us to use their client by passing our telnet server as query parameters in their URL.
Sometimes their server falls down so that’s the job: bring a copy of their client to our own servers (free software, and we’re preserving all credits of course).
When studying their code I realized that in order to communicate to our telnet server, first they setup a websocket server of their own (the address is something like “ws://etcetc.com”).
I got confused by that because, in my understanding, the need of a websocket in this kind of communication is for bidirectional communication between client-server and, maybe, provide a security layer on top of it, since telnet is not able to do so. However, their websocket doesn’t seem to use this security layer (I supposed that from the single ‘s’ in ‘ws://’).

So, if I don’t care about security and telnet is also a bidirectional protocol, why do I care about a websocket intermediate?

## timestamp – RFC3161: should tokens for which intermediate certificates were revoked without ReasonCode be deemed invalid?

RFC3161 specification (https://www.ietf.org/rfc/rfc3161.txt) section 4. “Security Considerations” states:

``````   1. When a TSA shall not be used anymore, but the TSA private key has
not been compromised, the authority's certificate SHALL be
revoked.  When the reasonCode extension relative to the revoked
certificate from the TSA is present in the CRL entry extensions,
it SHALL be set either to unspecified (0), affiliationChanged (3),
superseded (4) or cessationOfOperation (5).  In that case, at any
future time, the tokens signed with the corresponding key will be
considered as invalid, but tokens generated before the revocation
time will remain valid.  When the reasonCode extension relative to
the revoked certificate from the TSA is not present in the CRL
entry extensions, then all the tokens that have been signed with
the corresponding key SHALL be considered as invalid.  For that
reason, it is recommended to use the reasonCode extension.
``````

Does the same also apply for intermediate certificates in the issuer chain of the TSA certificate? From one side it would make sense (if the key of the TSA’s issuer would leak, neither the TSA’s certificate nor its RCLs could be trusted). On the other hand the specification only talks about the CRL of the TSA.

So, if an intermediate certificate above the TSA is revoked with a CRL and the reasonCode extension relative to that revoked intermediate certificate is NOT present in the CRL entry extension, will that invalidate all timestamp tokens issued by this TSA?

On a similar note – What happens after the expiration date of the root certificate? Since self-signed root certificates don’t have CRL lists, should timestamps issued by TSAs that use this root still be deemed valid?

## python – Make numpy calculation super fast by reducing size of intermediate arrays

I am trying to perform a certain numerical computation in Python with Numpy:

``````import numpy as np

# Given:

I = 100
O = 1000
F = 10

o = np.random.random((O,F))
ev = np.random.choice(a=(False, True), size=(O,F))
x = np.random.random((I,F))

const1 = 1.3456
const2 = 2.3456
const3 = 3.3456
const4 = 4.3456

# My calculations:

diff = o(np.newaxis, :, :) - x.reshape((-1, 1, x.shape(x.ndim - 1)))

# Might be accessible from cache:
nsh = np.einsum('iof,iof,of,->io', diff, diff, ev, 1 / const1)
kv = const2 * np.exp(nsh + const3)
# :Might be accessible from cache

result = np.einsum('io,iof,of->if', kv, diff, ev)
``````

I was trying to optimize for speed using broadcasting in the first line `diff =` and einsum in the last line. However, as one can easily see, the first line produces a very large array `diff`. Is it possible to avoid the creation of this large array while improving the speed or at least keeping the current speed?

One idea would be to replace

``````nsh = np.einsum('iof,iof,of,->io', diff, diff, ev, 1 / const1)
``````

with

``````X = x
Y = o
X_sqr = np.sum(X ** 2, axis=1)
Y_sqr = np.sum(Y ** 2, axis=1)
nsh = (X_sqr(:, np.newaxis) - 2.0 * X.dot(Y.T) + Y_sqr) / const1
``````

which is much faster. However, it does not include `ev` yet, because I don’t know how I have to include it, to get it right. And also it does not remove the need to create `diff`, because I still need it in the final line.

## certificates – Intermediate CA authenticity in an embedded device

My company are using an offline embedded device, that must encrypt connections to its client (a PC connected with USB).
We have chosen to use TLS with both PC and device authentification to encrypt message, and use certificates to secure the system.
So the device needs to send CSR and receives its certificates to authentificate and secure connection.
Also, It needs to store the root certificate of my company.
These certificates will not be downloaded directly from internet, the client PC will act as proxy and relay them to the device.
My question is how I can validate that the intermediate CA is authentic (that was created only by my company).

My guess was to use the Organisation or Common Name of the CA that can be identified with the company name.
And use the CA certificates chain to validate that the CA is not self-signed.

But could it be possible to create a CA cert with a valid chain certs and with the same name as my company in Organisation or CN field?
For exemple an intermediate CA cert that have the same common name but different parent authorities (Verisign, Let’s Encrypt…)
Are there other ways to authentificate intermediate CA?

## calculus – Does csc(x) violate the Intermediate Value Theorem?

I have been asked a question to explain as to why $$f(x) = csc(x)$$ does not “break” the IVP between
$$left(frac{-pi}2,frac{pi}2right)$$.

Considering that the function is discontinuous, it already breaks the IVP. In addition, there is no $$f(x)$$ value that can be found between $$fleft(frac{pi}2right)$$ and $$fleft(-frac{pi}2right)$$ which makes the question even more confusing for me.

## differential equations – How to discard NDSolve`StateData intermediate data

I’d like to prepare the equations with `NDSolve'ProcessEquations` and then doing repetitive `NDSolve'Iterate` for the steps.

I need only variable values at each step, not the final InterpolatingFunction and the computation may run indefinitely.

Is it possible to discard state data for processed steps?

## rendering – Intermediate level training for WPF

I am looking for a good WPF tutorial that helps understand the GUI implementation specifically. I have used C# for quite some time, understand basic XAML and have completed the basics such as https://wpf-tutorial.com.

What I am more interested in is rendering correctly, the use of adorner layers and similar. I don’t just want some code to paste in, I want something to take me through the logic. I prefer videos, as well as examples but let’s see any good recommendations.

It is a well-known theorem that if $$kappa$$ is measurable, then there is a generic extension in which $$kappa$$ is no longer weakly compact, but we can force its weak compactness back and recover the full measurability.
Question. Suppose that $$kappa$$ is measurable, is there a forcing $$Bbb{P*Q}$$ which preserves the measurability of $$kappa$$, but $$Bbb P$$ only preserves its weak compactness/Ramsey/other large cardinal properties while violating measurability?