## Regular expression for the Bitcoin Gold network

#### Battery exchange network

The Stack Exchange network includes 175 question and answer communities, including Stack Overflow, the largest and most reliable online community for developers who want to learn, share knowledge and develop their careers.

Visit Stack Exchange

## dg.differential geometry – When is a regular surface in \$ mathbb {R ^ 4} \$ contained in a vector subspace 3 \$ \$ from \$ mathbb {R ^ 4} \$?

Introduction: Either $$S$$ be a regular connected surface integrated into $$mathbb {R ^ 3}$$. We know that $$S$$ is contained in an airplane (a $$2$$-vector subspace of $$mathbb {R ^ 3}$$) if each point of $$S$$ is umbilical and the Gaussian curvature is constantly zero.

Question: Either $$S$$ be a regular connected surface integrated into $$mathbb {R ^ 4}$$. Are there any conditions on the first fundamental form or other "intrinsic" properties of the surface equivalent to the statement "$$S$$ is contained in a $$3$$-vector subspace of $$mathbb {R ^ 4}$$"?

Observation 1: $$S$$ is contained in a $$3$$-vector subspace of $$mathbb {R ^ 4}$$ if each tangent plane of $$S$$ is orthogonal to a nonzero fixed vector $$a$$.

Observation2:
Let $$phi: U rightarrow S$$ be a local map. $$phi (U)$$ is contained in a $$3$$-vector subspace of $$mathbb {R ^ 4}$$ so $$langle phi, a rangle = 0$$, for a non-zero fixed vector $$a$$.

Additional question: suppose $$S$$ as in the first question. Is the following implication true ?: "If $$S$$ is not contained in any $$3$$-vector subspace of $$mathbb {R ^ 4}$$ then there is a point $$p in S$$ so that for each neighborhood $$W$$ of $$p$$, $$S cap W$$ is not contained in any $$3$$-dimensional vector subspat ". I ask if the property is local or global.

## algorithms – McNaughton-Yamada Algotihm (1960) Regular expression to DFA without going through NFA

I have a homework problem here. It asks me to use the McNaughton-Yamada algorithm to convert a regular expression to DFA first, and then minimize this using a partition argument. I can do the latter. My problem is that I cannot access any real references on the algorithm. Their original document is behind a payment wall at the IEEE which my university does not have access to.

The algorithm went something like this:
1. For each symbol in the expression, give them a left-to-right index increasing by one for each occurrence of that symbol. For example, the expression, aa * would receive a_1 a_2 ^ *.

1. We are building a diagram based on the possible word lengths.

If done correctly, it produces a DFA. I think labeling in (1) is to help label states.

Feel free to give your own example if you decide to give an answer. I will not provide any problem here as there is no guarantee that this is not really my homework exercise.

## ac.commutative algebra – Intersection of prime numbers in a regular local ring

Assume $$R$$ is a regular local ring of dimension at least 3, and suppose $$P_1, P_2$$ are prime numbers of dimension 1. Is there necessarily a dimension 2 prime $$Q$$ contained in both?

In other words, is each pair of "small curves" contained in a "small area"?

If it is wrong, will it hold if the ring is full?

## mini chariot – Add a regular price with a special price on Minicart and on the order summary (payment page) – Magento 2.2.9

I am trying to get a regular price next to the special price on the minicart & checkout page. I added it on the cart page thanks to this topic:

Magento 2: How to display the special price and the regular price on the cart page?

But my tests for adding it on the minicart and on the payment page are still not good at the moment. Could you help me?

For the minicart, I tried to modify sidebar.html in Magento_Wee with this code but it didn't work:

``````getProduct()->getFinalPrice();
\$normalPrice = \$item->getProduct()->getPrice();
if (\$block->displayPriceWithWeeeDetails()): ?>

formatPrice(\$block->getUnitDisplayPriceExclTax()); ?>

formatPrice(\$normalPrice); ?>

``````

## automata – Prove that the following language is regular?

Suppose that L1 is a regular language and define:

$$L = {wcv ∈ {a, b, c} * | (| w | a + 2 | v | b) ≡ 3 mod 5, w, v ∈ L1}.$$

I first tried to prove by showing that the pumping lemma is true, then I learned that it was not a double implication and can only be used to prove that languages ​​are not regular.

Next, I tried to draw an NFA, but I made no progress.

What is the right way to prove that a language like this is regular?

## regular expressions – regular expression of three repeating numbers

First, "there is no occurrence of 123".

So the chain can start with any number of 2 and 3.
Then it has 0, 1 or more components that start with 1, and followed by any number of 2 and 3 other than 23. So the 1 is followed by nothing, a single 2, 22 and a number any of 2 and 3, or 3 and any number of 2 and 3.

Each of these components can contain three or four consecutive 2s. Four consecutive 2's are not allowed, three consecutive 2's can only occur once. So, for each of these components, add elements to not allow three 2s in a row or to allow three but not four 2s in a row. And then the language is any number of components without three 2s, possibly followed by one component with three 2s and any number of components without three 2s.

It's a little complicated, but not too bad.

So make regular expressions for "lead_2" = "any number of 2 and 3, but not three 2 in a row", "lead_3" = "any number of 2 and 3 , with 222 once but not twice, and not 2222 "," follow_2 "=" 1, followed by lead_2 not starting with 23 "," follow_3 "=" 1, followed by lead_3 not starting with 23 ", and the whole language is

``````lead_2 (follow_2)* or
``````

## javascript – What is the right algorithm to match the regular expression on a stream?

This is a difficult problem. Regular expression engines are fundamentally about ability reverse, that is to say, to try something else with an entry that they have already consumed. And the problem is not limited to possessive quantifiers, but to most constructions: even `(A|B)` requires going back.

If there is a way to limit the possible duration of your matches, it is almost certainly your best option for applying a normal match on overlapping chunks of size. `2 * L` than changing the way your regex engine works.

If you need to change it, however, that would involve parsing the regular expression or monitoring the engine progress to prove when previous entries can no longer be part of all corresponds, that is to say when the higher level backtrack has exhausted its alternatives. At this point you can delete the characters and thus limit the amount of memory required for the whole operation. But know that it would be a fascinating project, that is almost certainly outside the budget if you are just trying to do a random job.

## Generating regular expressions not containing abc

Design a DFA that recognizes "abc" (be sure to include all transitions). Complete it (make the accepting states non-accepting and make the non-accepting states accept) in order to obtain a DFA for $$L = Sigma ^ * setminus {abc }$$. Finally, note the regular expression of the completed DFA.

As a brute force solution that does not use DFA: write a regular expression for all words of length 0, 1, 2 and more than 3. This should be easy.
Then write a regular expression for all words of length 3 except abc.
For example:
$$(b + c) (a + b + c) ^ 2 + ab (a + b) + a (a + c) (a + b + c)$$

Take the union of all the above REs.

## regular expressions – What are the properties of a pattern?

I wonder if a pattern can contain variable parts.

Assuming the image above is a model, then, in this case, it can match multiple images having a common part (the constant part). Can a pattern have variable parts? If not, which properties are incompatible? If yes, is the model still conceptually valid?

I ask the question because in practice an expression can be compared to a pattern that has a variable part (unknown elements). However, in my opinion, this can lead to obfuscation if the constituents of the model have unspecified types.

Concretely, the variable part can be a pointer to an object of any type and the constant part can be made up of objects of fixed types.