## Sporadic groups generated by two simple permutations

Fixing $$nge 1$$, consider the permutation $$p$$ on $$n$$ elements whose word representation consists of the even integers ascending up to $$n$$, followed by the odd integers descending from $$n$$. Let $$q$$ be the reverse of $$p$$. The permutations are perhaps more easily defined via example: when $$n=8$$, we have $$p=24687531$$ and $$q=13578642$$.

Here’s a natural question: What is the group $$G$$ generated by the permutations $$p,q$$?

Using GAP, I have computed these groups for $$1le nle 128$$. The answer is almost a straightforward one: $$A_n$$ when $$n=0,1pmod{4}$$, and $$S_n$$ when $$n=2,3pmod{4}$$. That is, it will be as large as possible, given the parity of $$p$$ and $$q$$.

However, this classification has the following exceptions:

• When $$n=2^k$$ for $$kge2$$, $$G$$ is a combination of direct and semidirect products of certain cyclic groups, with an order of $$2^kcdot (k+1)$$; I think it is always given by the semidirect product $$(C_2)^krtimes C_{k+1}$$, though this doesn’t always match how GAP’s `StructureDescription()` function interprets the group. (When $$k=2$$, this coincides with the expected $$A_4$$.)

• When $$n=6$$, $$G$$ is not $$S_6$$, but $$S_5$$.

• When $$n=12$$, $$G$$ is not $$A_{12}$$, but the sporadic simple group $$M_{12}$$.

I have two questions about these groups and their apparent classification.

• Can we understand how the $$n=6$$ and $$n=12$$ sporadic cases work? I suspect at least the $$n=6$$ case is related somehow to the sporadic outer automorphisms of $$S_6$$, but I am not quite sure how this connection manifests.

• Can the classification outlined above be proven for all other $$n$$, if indeed it is true? (If not, can a counterexample be found?)

For convenience, the Sage code used to reach the above conclusions is linked here, and can be run here.

## Underwater Wreckage Simple Photoshop Blending And Composition Tutorial

Underwater Wreckage Simple Photoshop Blending And Composition Tutorial

## javascript – Simple to-do list application in React

I’m getting started with React, so I took a React tutorial for creating a simple to-do list app.

After finishing it, I read “Thinking in React”, and tried to improve what I did during tutorial based on that article.

This is my original code from tutorial: https://codesandbox.io/s/todo-initial-bklyz

And this is the code refactored by me: https://codesandbox.io/s/todo-refactored-lszfh

I would like to get feedback on how I improved the code, and whether I can improve it further (i.e. to make it more React-way, etc.).

Also, I have a question, how should I correctly manage the `tasks` passed to `App` as `props`, which then becomes `state` in `App`?

## testing – Should simple helper functions be used to consolidate function calls in test code?

We have test code like:

``````clickElement(a);
clickElement(b);
clickElement(c);
``````

that’s repeated in many places, where clickElement is called 1 to 5 times in a row.
Should we make a helper function to consolidate these, e.g.:

``````clickElements((a, b, c));
``````

I’ve heard arguments against creating the helper function, that it makes it harder to read and that test code should be simpler.
I’ve heard arguments for the helper function that it simplifies things and reduces code duplication.
It seems like both camps are firmly convinced that their way is clearly better.
Are there other important reasons for either that I’m missing or popular/standard resources on this?

## pr.probability – Simple math question regarding a very important medical diagnosis

I am faced with an unfortunate, however VERY slim chance, of a particularly unsatisfactory medical condition. I know the chances of said condition coming to fruition, but given that there is also a dynamic timeline, I’m a bit confused on the math. So, if someone can give me the answer to this I’m sure it will ease my VERY anxious mind a bit. I’m not sure I’m going to word this properly, but I’ll try..

Think of this as a science experiment in terms of the setup for this. The test subjects are entered into a YES or NO situation, the chance of YES being 1 out of 665, and the chance of NO of course being 664 out of 665. This YES or NO over the timeline of this study can, however, change, but only from NO to YES. At the timeline Benchmark A, 95% of the test subjects in this study that will get a YES will get the YES definitively at this point, and if that occurs the study is over and the rest of this does not matter for that test subject.

But, if the subject gets a NO at Benchmark A, the definitive nature of this can only be measured retroactively at Benchmark B, so it is possible to get a NO at Benchmark A and then a YES at Benchmark B, but getting a NO at Benchmark A obviously presents a much less chance of a YES at Benchmark B.

At timeline Benchmark B, the remaining 5% of the test subjects in this study will know if their NO is changed to a YES. That said, if a test subject gets a NO (chances 664 out of 665) at Benchmark A, what are the chances that the subject will end up with a YES by Benchmark B?

Hopefully I didn’t over-complicate this too much. I just wanted to be sure I gave all the information. Thank you in advance! Please help me ease my worried mind with some data so I can maybe sleep and eat normally again! 🙂

## kanban – How to deal with story-cards on a simple issue-board in Jira

Having a separate issue type makes sense. This allows you to set up different Jira workflows with states for different issue types easily. Having issue types for Epic, Story, Task, and Bug makes sense. However, when you put them onto a board, there doesn’t necessarily need to be a 1:1 mapping between workflow states and board columns. Perhaps, for now, a backlog (or a backlog column), a “to do” or “ready to work on” column, an “in progress” column, and a “done” column may be sufficient. Depending on the workflow associated with each issue type, there could be multiple states inside of each column.

A Story issue may be a good example. The “in progress” column on the board could represent multiple states – coding, testing, waiting to be merged. If you are working alone, this could be fine. However, if you are working with a team, it may be more important to visualize when something is waiting for a code review, so a workflow state associated with work ready for or undergoing a code review may be split out into a different column than working being developed or tested by a developer.

As far as tasks go, I would consider a parent to be started once any subtask is started. I would also consider a parent to be done when all subtasks are done. You can use Jira automation to help this along, as well, and avoid the game of moving tickets around. If you aren’t using subtasks, I’d recommend either using subtasks or just encapsulating all of the work in a single ticket to avoid ticket management hell. Most teams that I work with tend to use subtasks sparingly, unless multiple people will be working on a parent ticket because of the overhead of creating and managing parent and child tickets.

## How do I get simple product not associate with any configurable product?

How do I get all simple product not associate with any configurable , bundle , group product in Magento API 2 ?

## Simple Physics and Calculus in Mathematica V4

I think the only real problem keeping you from using the more modern `Quantities` framework is the fact that `Integrate(a0, t, t)` and `a0 Integrate(1, t, t)` are not equivalent if one or more accelerations in `a0` are zero. In the first case we get `{0 m/s^2, -4.9 t^2 m/s^2}` and in the second case we get `{t^2 (0 m/s^2), t^2 (-4.9 m/s^2)}`. Since we’re integrating constants, we can pull the constants out of the integral and put them in front. I’ve done it for both `v0` and `a0`, though it was only absolutely necessary for `a0`. Unfortunately, because of the way the replacement works, Mathematica will print a warning that m/s and m are incompatible units, then the substitution happens and it realizes the units are fine.

``````vectorDirection(vec_) := ArcTan(vec((2))/vec((1)))*180/(Pi)

r0 = Quantity({0, 0}, "Meters");
s0 = Quantity(37, "Meters"/"Seconds");
v0 = AngleVector(s0, 53.1 Degree)
a0 = Quantity({0, -9.8}, "Meters"/"Seconds"^2);

r0 + v0 Integrate(1, t) + a0 Integrate(1, t, t) /.
t -> Quantity(2, "Seconds")

{Norm(
v0 + a0 Integrate(1, t) /. t -> Quantity(2, "Seconds")),
vectorDirection(
v0 + a0 Integrate(1, t) /. t -> Quantity(2, "Seconds"))}

r1 = {x, y};
v1 = {v1x, Quantity(0, ("Meters")/("Seconds"))};
Solve({r1 == r0 + v0 Integrate(1, t) + a0 Integrate(1, t, t),
v1 == v0 + a0 Integrate(1, t)}, {x, y, t, v1x})

r1 = {x, Quantity(0, "Meters")};
v1 = {v1x, v1y};
Last@Solve({r1 == r0 + v0 Integrate(1, t) + a0 Integrate(1, t, t),
v1 == v0 + a0 Integrate(1, t)}, {x, t, v1x, v1y})
``````

Of course all the quantities and integrals can be entered in the more traditional format when using Mathematica, but it doesn’t translate well to StackExchange. I do think it’s a bit strange to carry around all these integrals and repeatedly solve the same equations over and over. My usual process would be to solve the integral once, if possible, and then be done with it. Perhaps you have a reason you want to keep the integrals, but I think it’s cleaner without. With the initial values defined as above:

``````pos = Integrate(a, t, t, GeneratedParameters -> C) /. {C(1) -> r0, C(2) -> v0,  a -> a0}
pos /. t -> Quantity(2, "Seconds")
{Norm(#), vectorDirection(#)} &@(D(pos, t) /.
t -> Quantity(2, "Seconds"))
Solve({{x, y} == pos, {v1x, Quantity(0, ("Meters")/("Seconds"))} ==
D(pos, t)}, {x, y, t, v1x})
Last@Solve({{x, Quantity(0, "Meters")} == pos, {v1x, v1y} ==
D(pos, t)}, {x, t, v1x, v1y})
``````

If we were using the derivative of the position a lot, we could also just define a new equation like `vel = D(pos, t)`. I also switched the definition of position here. From a physics perspective, I don’t think the original definition is quite right. It gets the same answer, but a double indefinite integral should have two unknowns (initial velocity and initial position, here). When using the double integral, we’re really solving the differential equation `r''(t) == a` and integrating both sides twice to get `r(t) = 1/2 a t^2 + v0 t + r0`, so we don’t need the definition to contain 3 separate parts.

## How to make simple Screen Recorder in Ubuntu

To Screen Record in Ubuntu for less then 30sec.

To Start
ctrl + alt + R.

To End the screen recorder in < 30 then use the key.
ctrl + alt + R.

After aprouching the 30sec the screen recorder automatically will off.