## symbolic – Closed form of the product of the gamma function

Mathematica
recognizes this closed form
begin {align} prod_ {k = 1} ^ {n-1} sin ( pi k / n) & = 2 ^ {1-n} , n end
All good:

but fails
on this

Nevertheless, this expression also has a known closed form
begin {align} prod_ {k = 1} ^ {n-1} gamma (k / n) & = sqrt { frac {(2 , pi) ^ {n-1}} {n}} , end

Is there a way to do Mathematica
to recognize it?

## Number fields – To what extent is the association of basic functions closed?

What if there is a possible extension of real numbers that turns out that some functions that are currently considered non-elemental can be expressed through elementary functions in closed form?

For example, when I recently examined the algebra of divergent integrals, I came to the following conclusions. If $$lim_ {x to infty} f & # 39; (x) = 0$$ then the infinite (irregular) part of $$f ( omega _- + x)$$ is not dependent on $$x$$ for every regular $$x$$ (This happens because we can shift the function by any finite value and the difference between the integrals to infinity is finite.) $$int_0 ^ infty (f # (x + a) -f # (x)) dx = b$$). In this way we can eliminate an infinite part: $$f ( omega _ ++ a) -f ( omega _ +)$$ is regular.

This yields the following expressions:

$$psi (x) = log left ( frac {x + omega _-} { omega_ + e ^ { gamma}} right)$$

$$gamma (x) = e ^ {(1+ gamma) (1-x)} left ( frac {x + omega _-} { omega _ +} right) ^ {x + omega _ -}$$

$$x! = e ^ {- (1+ gamma) x} left ( frac {x + omega _ +} { omega _ +} right) ^ {x + omega _ +}$$

(Here $$omega _ +$$ and $$omega _-$$ are special infinite numbers that correspond to infinite series $$sum_0 ^ infty 1$$ and $$sum_1 ^ infty 1$$ respectively)

In other words, the gamma function, the digamma function and all their derivatives provide elementary functions!

I wonder what consequences this could have.

## Flash Network – Is a channel automatically closed when an HTLC expires that does not have its own output in the commit transaction?

If routed Lightning payments are smaller than a certain amount, they will not receive their own HTLC output in the commit transaction. Instead, the reserved funds are used for transaction fees.

If there is an actual HTLC, it makes sense for the sender to close the channel and call it back when it has expired. However, it does not make sense to do the same if there is no real HTLC. The same applies to the recipient.

Is a channel still closed under these circumstances?

## object-oriented – How to comply with the Open Closed principle in a procedural language such as C.

To do the work in C, you would probably want to create a structure that contains a pointer to a function. In other words, you explicitly define a vtable / manually and paste it as the first item in a union containing all forms:

``````void drawCircle(union Shape *);
void drawSquare(union Shape *);

struct Square {
void (*draw)();

Position center;
Size size;
};

struct Circle {
void (*draw)();

Position center;
Size size;
};

union Shape {
Circle circle;
Square square;
};

void drawShapes(Shape *shapes, int count) {
for (int i=0; idraw(&shapes(i));
}
``````

So we have a bunch of shape objects. The first element in each of these elements is a pointer to a function that can draw that particular type of shape. So when we add a new kind of shape, we have to define a function to draw that kind of shape, and when we create a shape "object" for that shape, we have to initialize it `draw` Actor referring to the drawing function for this form.

When we call this function, something happens in the order of:

``````void drawSquare(void *data) {
struct Square *real_data = (struct Square *)data;

// draw a square with the specified location/size
}

void drawCircle(void *data) {
struct Circle *real_data = (struct circle *)data;

// draw a circle with the specified location/size
}
``````

This brings us halfway to the open / closed principle. Of course, to add a new shape we need to add a new function to draw that kind of shape. We also need to add a structure to store the kind of data needed to define this shape. This structure must contain a pointer to a function to create the drawing that gets a pointer to a `Shape`, And of course we have to add that new kind of shape to the one `Shape` Association, so we can pass the correct data to the drawing function.

Our `drawShapes` and all the code to draw a circle or square can be left closed – adding a new shape does not affect it. Of course adding more pointers to functions (and not just the one `draw`) does not really change that much – we can still write functions generally on the order of `drawShapes` which work with forms of any type provided that each defines the same interface in terms of pointers to functions (with matching types and the like).

In the other direction, this still has a lot of manual work, leaving a lot of room for error. It's especially easy to initialize some of the pointers to point to the wrong functions. So when we use them, we do not get what we expect. We also have to manually initialize the pointer to work in each one `Shape` The object we create to point to the correct drawing function (and as we add more simulated virtual functions, this problem gets worse and worse).

## Geometry – When is a plane algebraic curve closed?

When is a flat algebraic curve closed?

Is there a metric? For square http://mathworld.wolfram.com/QuadraticCurveDiscriminant.html

We know that the discriminant must be below 0.

Is there something for higher degrees? I'm not looking for suggestions. I am looking for complete answers. No proofs of existence, because I know they exist.

Do we know it and what is it?

## Consistency – Which way blocks? / Which way is closed?

First of all, I would like to say that I set up castles to make a living. While I do a lot of locksmithing, I do not call myself a locksmith because I work exclusively on locks for buildings. That means I do not crack safes or open cars. I own a company that specializes in the sale and installation of door fittings for residential and commercial real estate.

I just came across this question, because I really wondered the same thing with all my expertise. I know the thread is quite old, but I feel like I can contribute to posterity. So, here is my attitude:

There are basically two types of locks on doors: cylinder and mortise lock. Mortise locks consist of a rectangular box that fits into a, well … mortise lock that cuts a joiner into a door. Due to its design, the key is inserted in one side and the latch is attached to the other side. They can not be undone and can only be installed in one direction. There are four types: left, right, left and right reverse.

To understand the types, it is easiest to first understand the cylinder locks. While mortise locks are still manufactured and used, they have fallen out of favor over the years. This is mainly due to the fact that an experienced joiner or a special machine (which no longer manufactures) is required for the installation. A cylinder lock that you probably have at home can easily be installed with a drill and the right bits. Essentially, they just fit in a hole.

Cylinder locks can be reversed as they fit in a round hole instead of a rectangular mortise lock. So unless you have a bent lever or latch, they are all the same. The only time they are "handed over" is when they have an exposed piece that should be shown in a certain way. Even then, they only come in left and right hands. The "bevel" refers to the angle cut on the striker so that the door closes without you first having to turn the knob. Even if a cylinder lock is handed over, you can turn the bevel to the door frame and the closing plate when it is closed. Thus there is no backward slope.

If you are still with me, there are four types of mortise locks, as the key can only be inserted on one side and the bevel of the firing pin can not be turned. There are four types of doors. The hinges can be on the left or right, and the door can open into or out of a room.

For mortise locks, the key has always been inserted vertically and turned away from the frame for locking in the direction of the frame and for unlocking. Likewise, the thumb lock works on the inside. Therefore, it makes sense to install a cylinder lock in the same way as locks have been working this way for at least a century.

However, there are some nuances in cylinder locks that prevent this from becoming a universal rule. The actual locking mechanism of a cylinder lock consists of a flat piece of metal that connects the inside and outside of the lock and passes through the latch that holds the door closed. This is called a "tailpiece".

When the right key is inserted into the lock, you can turn the tailpiece 90 degrees to the left or right from the outside. The tailpiece can be freely rotated by the bolt without a key. If you only hold the locking mechanism, you would see that the tailpiece is a total of 180 freely rotatable. That's why there is this question at all. You can install almost any cylinder lock in the unlocked position with the thumb latch in the vertical OR horizontal position.

So, here's what I know for sure. Some manufacturers design their locks to work in one way or another. As far as I know, this is due to the fact that the lock is stronger when turning to the stop. If you think about it and remember that the tailpiece rotates 180 degrees, the pins of the lock are cocked when it is turned to the left or right, but not when it is in the middle (vertical position).

I know this is confusing, but some locks are designed to be live in either the locked or unlocked position. This depends on the manufacturer and model. I will say that if the direction is important, it is always noted in the instructions. So check them first and follow them.

To make things even more obscure, some manufacturers make locks where the bolt sits at a 45-degree angle. All cylinder locks only need to rotate 90 degrees to operate. Therefore, these special locks tend to lock when locked to the frame and when unlocking. However, they never rest in a vertical or horizontal position. Schlage makes many models in this style.

Recently I also saw cylinder locks with labels on the front panels. Some have an arrow or mark for the locked position. Others have actually locked the words locked and unlocked in the record. To complicate matters, I have seen these labeled faceplates with the locked position vertically, horizontally, and in between.

TLDR: All locks are different. Follow the manufacturer's instructions. If the direction is not specified, install the lock so that it is unlocked when the thumb latch is vertical and locked when it is horizontal. The latch or key locks when it is turned to the frame (strike plate) and unlocks when it is turned away. Whether it is clockwise or counterclockwise depends on whether it is a left or a right door.

## Why are valid questions closed without help?

I often come across this problem. A typical example:

19.10 seems to be broken on my MB Pro suspend

This user has a reputation of 111, seems to be an active contributor, and in fact has the same problem I came here to look for, along with maybe 84 other people who have viewed his question. It is unbelievably unhelpful.

## Proofing – How to prove the function of a recursive big theta without using repeated substitution, mastering the sentence, or having the closed form?

I have defined a function: $$V (j, k)$$ Where $$j, k in mathbb {N}$$ and $$t> 0 in mathbb {N}$$ and $$1 leq q leq j – 1$$, Note $$mathbb {N}$$ includes $$0$$,

$$V (j, k) = begin {cases} tj & k leq 2 tk & j leq 2 tjk + V (q, k / 2) + T (j – q, k / 2) & j , k> 2 end {cases}$$

I am not allowed to use repeated substitution and I want to prove this by induction. I can not use the main clause because the recursive part is not in that form. Any ideas how I can solve it with given limitations?

When I start induction: I fix $$j, q$$ and introduce $$k$$, Then the base case $$k = 0$$, Then $$V (j, 0) = tj$$, The question indicated that the function may be $$Theta (jk)$$ or maybe $$Theta (j ^ 2k ^ 2)$$ (but it does not necessarily have to be either).

I choose $$Theta (j, k)$$, In the base case, this would mean that I had to prove that $$tj = theta (j, k)$$ when $$j = 0$$, But if I start with the big-oh, I have to show it $$km leq mn = m cdot0 = 0$$ which I currently do not think possible.

I am not sure if I did the basic case wrong or if there is another approach.

## Proving techniques – How to prove the function of a recursive Big-Oh without using repeated substitution, master phrase or closed form?

I have a function as defined $$V (j, k)$$ with two base cases with $$j, k$$ and the recursive part has an additional variable $$q$$ which it also uses. Also, $$1 leq q leq j – 1$$, The recursive part has the form: $$jk + V (q, k / 2) + V (j – q, k / 2)$$I am not allowed to use repeated substitution and I want to prove this by induction. I can not use the main clause because the recursive part is not in that form. Any ideas how I can solve it with given limitations?

## vmware – my exe file is automatically closed after startup

I wrote application in C # and when I try to open it on VM (VMware 15.1) in Task Manager, I can see that it is started, then the status changes to stopped and then automatically closed. I must add that when I try to open this .exe file on my main computer, this works. The same situation is when I try to open them through a shared folder (VMware). Other exe files work normally. Thanks in advance for your help.