## stochastic processes – Functional theorems of the central limit under weak dependence on C (S)

I am wondering if anyone can hint the results in fCLT in Banach's continuous function space in a compact set $$S$$ endowed with the maximum norm.

My problem is as follows: given $$X_1, …, X_N sim X$$ iid processes I want to prove that the process
$$frac {1} { sqrt {N}} sum_ {n = 1} ^ N r_n (X_n – bar X)$$
weakly converges to the gaussian process with the covariance function given by $${ rm cov} (X (s) X (t))$$. here $$bar X$$ is the sample average and $$r_1, …, r_N sim r$$ iid processes with zero mean and unit variance.

Using the Jain-Marcus theorem of (1) this is simple under these types of Hölder conditions. However, all results require independence of the addends.
Is there a way to avoid that? Asymptotically my addends are independent.

I'd be happy with suggestions or articles that address similar questions.
Thank you!

(1) Chang, C. and Ogden, R. T. (2009). Bootstrapping sums of independent but not identically distributed continuous processes with applications to functional data. Multivariate Analysis Journal, 100 (6), 1291-1303.

## Cryptocurrencies and internet dependence

I have a problem with the concept of cryptography in one aspect. What about "cybersecurity"? Since there will be more malicious activity online in the future, isn't crypto dependence on the Internet a weakness?

## Graphs – Algorithm for the analysis of non-directed projective dependence

I am looking for an algorithm that obtains an optimal non-targeted projected dependency analysis.

That is, given the sentence & # 39; Mary loves John & # 39 ;, and an edge weight function $$f$$ (that is, a function of word pairs in the sentence to real numbers), such as

$$f$$(Maria does) = 1

$$f$$(Mary, love) = 5

$$f$$(Maria, Juan) = 2

$$f$$(yes, love) = 2

$$f$$(does, John) = 3

$$f$$(love, John) = 5

I want an algorithm that gives the edges of the maximum projective expansion tree like:
{(Mary, love), (does, love), (love, John)} with a total weight of 12. That is, I should give this:

Crucially, the algorithm should not give {(Mary, love), (does, John), (love, John)}, although it has a greater weight of 13, because in that case the dependencies are not projective (the arcs (Mary, love), (does, John) intersect). I mean, I should do not give this:

Equivalently, I ask: what algorithms exist to find a minimum / maximum expansion tree in an ordered graph, so that the resulting structure is projective? A little more formally: given a completely ordered set of nodes $$(S, <)$$and an edge weight function $$W: S × S → ℝ$$Is there a good algorithm for finding the optimal weight expansion tree on this set of nodes, so that the resulting structure has the property that each subtree is contiguous in the order (for any subtree $$T$$, for all $$t, s$$ in $$T$$ There is not $$r$$ not in $$T$$ such that $$t )?

• Without the projectivity requirement, any classic MST algorithm will work (like Prim or Kruskal).
• With the projectivity requirement, but for managed graphs / dependencies The Eisner algorithm (a faster version of arc-factorized projective analysis) is standard for obtaining the optimal targeted projective analysis.

I'm looking for an algorithm (probably CYK) like Eisner's, but that will work in the non-directed dependency analysis. That is, an algorithm to find the maximum projective expansion tree for non-directed ordered graphics. Or, perhaps, proof that Eisner's algorithm with some modification to work on non-directed graphics will guarantee the optimal projective expansion tree.

## Complements: a product can have multiple values ​​for 1 and multiple values ​​for 2. Because there is no dependence between these attributes, it is not possible

A product can have multiple values ​​for Carmodel and multiple values ​​for Carbrand. Because there is no dependency between these attributes, it is not possible to filter correctly in the interface.

The dependency between attributes must be established from the backend (so that the user can decide which attributes depend on each other)
And when the dependency between attributes has been created, the user should be able to match the values ​​of one attribute with the values ​​of the other attribute.

Take for example the product Defender® T + H
This has 2 values ​​for carbrand: Audi and BMW
This has 4 values ​​for carmodel: A3, A4, i3, i8

As no relationship has been defined, it is possible to show products that are valid for a non-existent Audi i3.

## Dependence on custom options

How to create a custom product option that depends on another custom option. Let's say I have a custom drop-down option that has Yes or No options and another option Field in which it is activated / displayed only if Yes is selected in the first custom option

## Database design: decomposition without loss and dependence that preserves decomposition in normal ways

I read (from a text something not so standard) that

the decomposition of a relationship (i.e. the database table) in the first normal form, the second normal form and the third normal form are always lossless and preserve dependence, while the decomposition in BCNF is always without losses, but not always preserves dependence

I doubt if that is correct. I feel it could be like this:

We can always get

• 1 NF, 2 NF and 3 NF without loss and dependence preserving decomposition
• lossless BCNF decomposition

But it is not always possible to obtain dependence while preserving the decomposition of BCNF

Because the definitions of normal form do not speak of anything about the nature without loss or the preservation of the dependence of the decompositions. Just talk about the normal form of unique relationship.

Am I correct with this?

## java – Dependence of the UI adapter on a secondary (controlled) port – Hexagonal architecture

I am applying the Hexagonal Architecture (Ports and Adapters) to my system and I have noticed a dependency of my adapter from the primary side (controller) to the secondary (controlled) side port. This does not seem right; There should be a way to handle this.

Let's say I have two very basic ports in my domain; one is on the driver's side and the other on the driver's side.

``````// Primary Port
interface ForecastGenerating {
Forecast() generateForecastsForAllLocations();
Forecast() generateForecastsForLocation(Location location);
}

// Secondary Port
interface LocationFetching {
Location() fetchAllLocations();
Location fetchLocationbyId(String locationId);
}
``````

Then I have my domain logic as below. A concrete implementation of the `LocationFetching` Port.

``````// Domain Implementation
class ApplicationForecastGenerator implements ForecastGenerating {

private LocationFetching locationFetching;
public ApplicationStatusChecker(LocationFetching locationFetching) {
this.locationFetching = locationFetching
}

Forecast() generateForecastsForAllLocations() {
Location() locations = this.locationFetching.fetchAllLocations();
// Do my domain thing and generate forecasts
}
Forecast() generateForecastsForLocation(Location location) {
// Do my domain thing and generate forecasts
}
}
``````

And finally, we have the main adapter that links all this:

``````// Primary Adapter Implementation
class UIBasedForecastGenerator {

private ForecastGenerating forecastGenerating;
public UIBasedForecastGenerator(ForecastGenerating forecastGenerating) {
this.forecastGenerating = forecastGenerating;
}

public void userTappedOnGenerateButton() {
Location location; // How does the primary adapter get its hands on the Location object?
Forecast() forecasts = this.forecastGenerating.generateForecastsForLocation(location);
System.out.println(forecasts);
}
}
``````

The question in the implementation of the primary adapter is that, how do I get a reference to the `Location` object? I can definitely use the `LocationFetching` port and I have a dependency on him, but that sounds a bit strange to me; a driver side adapter that depends on the driver side port. I feel that the domain should be responsible for providing this object, but the `ForecastGenerating` the port should not expose such functionality; It seems to be beyond the reach of forecast generation.

How do we handle such dependencies in this architecture?

## Functional dependence and standardization

For a relational scheme without functional dependencies, what is the highest normal form?

For example, R = (A, B, C, D)

## design patterns – Dependence on event-driven architecture

I have the following case. I have X services (wrapper) that communicate with different external APIs, these channels normally listen to events on a rabbit (queue) server. In addition, each channel has different configurations where the user has to enter, this logic is in a separate application (authentication administrator). A user can add authentication details X times per container, those credentials are stored in the authentication manager.
The problem I have is if a user configures a new application if they want to activate a function in the container to verify if the credentials are ok. The answer to this should be directly return to the user.
For this I would have 3 possibilities:

a) The authentication administrator communicates by REST with the container

b) If the user entered the details that he sends directly to the container that runs the test, in case of success, he places an event and the authentication administrator listens to it

c) The user publishes his configuration in the authentication manager, this puts a message in the queue and waits until he gets the response from the wrapper (the frontend polls until this is done)

d) store the credentials directly in the container, which would give me the problem that I need an endpoint to show the user all authenticated channels, which means that I would need to ask all the containers to load this information.

In addition to the endpoint of the test credentials for each execution (from a container in certain events) those containers need configuration, which means that I can give that as part of the message or resolve this with case d), which leads me to the problem that I don't have & # 39; I don't know what credentials are already configured and what containers are configured

## magento2 – Magento 2. How does Magento avoid the circular dependence of Magento Backend Model Url?

Magento Uses

``````MagentoBackendModelUrl
``````

as a preference for

``````MagentoFrameworkUrlInterface
``````

now `MagentoBackendModelUrl`
has a dependency on

``````MagentoFrameworkDataFormFormKey
``````

that depends of

``````MagentoFrameworkSessionSessionManagerInterface
``````

which in the administration area is implemented by

``````MagentoBackendModelSession
``````

that depends of
`Magento Framework Session SidResolverInterface`

which is implemented by

``````MagentoFrameworkSessionSidResolver
``````

which in turn depends on

``````MagentoFrameworkUrlInterface
``````

in the end what we have is a circular dependency

``````BackendModelUrl <- depends -> FormKey
``````

I checked three times to see if a different implementation is provided for SidResolverInterface in the administration area, one that does not depend on Magento Framework UrlInterface. This is not the case.

So how does Magento avoid this circular dependence? Why doesn't it fail? What am i missing?