## 3 manifolds – Thurston Universe gates in Knots: which invariant is it?

Today I discovered this nice video of a lecture by Thurston:

https://youtu.be/daplYX6Oshc

in which he explains how a knot can be turned into a “fabric for universes”. For example, the unknot can be thought as a portal to Narnia, and when you pass again you switch back to Narnia. This forms in a sense a $$mathbb{Z}/2mathbb{Z}$$. Then he proceeds to explore what fabric one gets with the treefoil and you get an $$S_3$$. I am sure there is some real geometry behind but I can’t grasp how to translate a portal into something homotopic.

A way to formalize this would be the following. Take a knot $$K$$ in $$mathbb{R}^3$$. Fix a tubular neighborhood $$N$$ of $$K$$. For each point $$x$$ in the knot take the loop $$L_x$$ obtained as the sphere bundle of $$N$$ at $$x$$ (a small circle around $$x$$ that jumps into the portal). Then there exist a connected 3-manifold $$M$$ with a (finite?) cover $$M to mathbb{R}^3 setminus K$$ such that the “monodromy in small circles” around $$L_x$$ has order two for all $$x$$. Then we set the “group of universes” as the group of cover automorphisms.

I think this captures the previous idea in the following sense: to each locus of $$mathbb{R}^3 setminus K$$ we have $$n$$ counterimages that represent the different worlds. Some branch should be chosen to make distinguishing between worlds possible. The constraint on monodromy ensures that if you jump twice through the same portal (at least for the portals very close to the boundary) you get back.

Does such a manifold exist for all knots? Is this construction just some simplification of the fundamental group of the complement?

## complexity theory – Is there CIRCUIT-SAT algorithms that slightly depends on gates count?

Yes, such an algorithm exists, but it is the same algorithm used for SAT solving in general.

While the Tseytin extension variables associated with gates do appear in the CNF transformation of the original circuit, a minimally competent SAT solver will rarely branch on them. This is because one of the earliest heuristics discovered for speeding up searches was choosing decision variables based on how often they appear in clauses. The one-per-subformula Tseytin extension variables appear in only a few clauses, while the original input variables will be involved in many clauses as the leaves of the tree of Tseytin extensions. So the Tseytin variables will all have low scores and won’t be used often as decision variables. The solver will therefore iterate through assignments of the input variables much like a brute-force search would, except that it will also take advantage of unit propagation, clause learning and all the other features of a modern SAT solver to get through the search space faster.

I say “minimally competent SAT solver” above because a really competent solver would take advantage of well-known CNF preprocessing techniques that can remove most of these gate variables before the actual solver search even starts. So CIRCUIT-SAT solvers are generally just SAT solvers. You can gain speed in some circumstances by having access to the original circuit in addition to the CNF result, but the gate variables don’t much factor into that.

## ❕NEWS – Bill Gates Changes Her Mind About Bitcoin (BTC) | Proxies-free

Gates says she still doesn’t own Bitcoin. Bill Gates revealed his thoughts on Bitcoin (BTC) in an interview with CNBC’s Andrew Ross Sorkin. Gates changed his thinking about Bitcoin to neutral.
It is recalled that Gates said in May 2018:
—- “As an asset class you are not producing anything and therefore you should not expect it to rise. This is a “big fool theory” type of investment. “—-
Why do you think she might have changed her mind?

## quantum computing – How do two H gates act on two entangled qubits?

In this circuit, if the two qubits are initial in state 0, then after the oracle they are entangled and in the state:

$$0.5 * (|00>+|01>+|10>-|11>)$$

My question is how do the two H gates act on them? Do they act like:

$$0.25 * ((|0>+|1>)otimes(|0>+|1>) + (|0>+|1>)otimes(|0>-|1>) + (|0>-|1>)otimes(|0>+|1>) – (|0>-|1>)otimes(|0>-|1>))$$

which in the end nothing has changed. My intuition tells me that it’s wrong.

## air travel – Why does one sometimes have to go through two subsequent security gates at El Alto International Airport (LPB, La Paz, Bolivia)?

I took a flight from El Alto International Airport (LPB, La Paz, Bolivia) to Alejandro Velasco Astete Airport (CUZ, Cusco, Peru), and passengers for this flight (boarding gate R20) were required to go through two security gates that directly followed each other, while for some other flights passengers didn’t have to go through the second security gate.

Why does one sometimes have to go through two subsequent security gates at El Alto International Airport (LPB, Lima, Peru)?

That seemed redundant as the second security gate was only scanning the passengers’ luggage while the first security gate was scanning passengers’ luggage and bodies, but I’m assuming there is a good reason for it. The second security gate didn’t require passengers to remove anything from the luggage before the scan.

## Is there a pattern for unit/integration testing where tests that are higher level are intended to act as “gates” for other more specific tests?

The motivating concept here is that the fewer tests you have, the faster your test suite runs. This kinda feels like I’m basically describing smoke tests, but I think smoke tests and other tests are commonly treated as entirely separate test suites: separate steps in a pipeline. Broadly speaking, we may have smoke, integration, and unit test suites, but they’re all separate from one another.

Imagine a build pipeline set up such that an integration test on components A B and C runs, and since it’s designed to be somewhat comprehensive in its checking, it’s deemed safe to skip individual unit test suites under components A and B so long as this test does not fail.

In my experience this level of granularity over dispatch is not generally provided in test frameworks.

What we can expect to see is that during relatively stable periods of development, only this integration needs to be run (sort of as a smoke test), which provides potentially big gains for pipeline throughput and latency because the unit test suites are usually skipped if nothing goes wrong. The system could still opt-in to execute all unit tests in times of low load, on a schedule, and/or on demand.

This provides benefits for situations in which a heavily tested component of a project approaches maturity and the overhead of executing tests begins to impact CI resources available for other jobs. This system would be a way to provide a level of granularity of control. Being able to skip tests for systems that have not changed is kind of a base case that this generalizes.

It could be represented as a skip-dependency graph. Tests could optionally be marked as being superceded by zero or more tests and thus be skippable if all of those pass.

I like this concept because in my experience, when working on complex systems, testing (and instrumentation that goes along with it) can potentially be prohibitively resource-intensive. What this forces upon us is to at least in some significant way dismantle that instrumentation from the deployment of the system once we finish working on a particular component. Practically speaking, pressures materialize which are proportional to the comprehensiveness of testing of a particular component, and although this does balance (in an organization that is well-adjusted!) with the relative importance of that component (and is perhaps a good natural force to regulate over-engineering tests), I sometimes end up feeling that these pressures don’t actually need to exist. It seems that a prohibitively expensive full test suite could and should exist for the entire system, and to wire it up internally in such a way that it shortcuts the bulk of low level testing under almost all typical circumstances means that it could retain all of its potential exhaustiveness while still being fast enough to actually use all the time.

Are there test frameworks that provide an implementation of this concept? If so, does it have a name?

In either case, what might be some good approaches we could use to avoid overmarking and overculling the testing?

## java – Creating logic gates objects – Code style

I would like to create a small virtual PLC application, where the user may choose from a variety of logic gates and put them together to form a boolean program. I just have written the logic gates, which all work as intended. May you give me some tips in regarding programming style? My class Gate uses a static int variable named gateValuesForced. This variable shall be an indicator for the user that any of the Gates has used method Gate.force() and not has used Gate.unforce() in sucession. Did I’ve implemented this in the right way? Also in regard to my method Gate.finalize().

Package operatoren – Class Gate

``````package operatoren;

public final class Gate{
private boolean value = false, force = false, forceValue = true;
private static int gateValuesForced = 0;

public final void setValue(boolean value) {
this.value = value;
}

public final void flipValue() {
if(value) value = false;
else value = true;
}

public final void setForceValue(boolean forceValue) {
this.forceValue = forceValue;
}

public final void flipForceValue() {
if(forceValue) forceValue = false;
else forceValue = true;
}

public final boolean force() {
if(!force) {
force = true;
gateValuesForced++;
return true;
}
else {
return false;
}
}

public final boolean unforce() {
if(force) {
force = false;
gateValuesForced--;
return true;
}
else {
return false;
}
}

public final boolean getValue() {
if(force) return forceValue;
else return value;
}

public final boolean getForceValue() {
return forceValue;
}

public final boolean isForced() {
return force;
}

public final static int gateValuesForced() {
return gateValuesForced;
}

protected void finalize() {
unforce();
}

public Gate() {

}
}
``````

Package operatoren – Class LogicGate

``````package operatoren;

import java.util.ArrayList;
import java.util.List;

public abstract class LogicGate {
public List<Gate> input = new ArrayList<Gate>();
public Gate output = new Gate();

public abstract boolean calc();

public LogicGate(int inputs) {
for(int i = 0; i < inputs; i++) {
}
}
}
``````

Package operatoren – Class AND

``````package operatoren;

import java.util.NoSuchElementException;

public class AND extends LogicGate{
public boolean calc() {
if(this.input.size() > 1) {
for(int i = 1; i < this.input.size(); i++) {
if(this.input.get(i-1).getValue() && this.input.get(i).getValue()) {
this.output.setValue(true);
}
else {
this.output.setValue(false);
break;
}
}
return this.output.getValue();
}
else {
throw new NoSuchElementException("AND-Gate has less than 2 inputs.");
}
}

public AND() {
super(2);
}
}
``````

Package test – Class Test

``````package test;

import operatoren.*;

public class Test {
public static void testLogicGate(LogicGate logicGate) {
System.out.println(" ------- " + logicGate.toString() + " ------- ");
boolean intToBoolean = false;
for(int i = 0; i < (1 << logicGate.input.size()); i++) {
for(int j = 0; j < logicGate.input.size(); j++) {
if((i & (1 << j)) > 0) {
intToBoolean = true;
}
else {
intToBoolean = false;
}
logicGate.input.get(j).setValue(intToBoolean);
System.out.println("logicGate.input.get(" + j + ").getValue() = " + logicGate.input.get(j).getValue());
}
logicGate.calc();
System.out.println("logicGate.output.getValue() = " + logicGate.output.getValue() + "n");
}
if(Gate.gateValuesForced() != 0) {
System.out.println("Gate.gateValuesForced() = " + Gate.gateValuesForced());
}
}

public static void main(String() args) {
AND testAND = new AND();

/* uncomment one or more of following lines for testing */
//testAND.input.get(0).setForceValue(false);
//testAND.input.get(0).force();

testLogicGate(testAND);
}
}
``````

You may uncomment one or more of those comments to view another test situation.

## complexity theory – Why mod \$p\$ gates cannot be computed by \$ACC^0[q]\$ circuits, \$p\$ and \$q\$ prime

I am going through Computational Complexity by Arora and Barak, and there I came across the proof of why mod $$p$$ gates cannot be computed by $$ACC^0[q]$$ circuits, where $$p$$ and $$q$$ are distinct primes. The book proves it for $$p=2$$ and $$q=3$$, and I am facing difficulties generalizing this result for arbitrary $$p$$ and $$q$$.

The proof uses two lemmas. The first one states that any $$ACC^0[3]$$ circuit can be approximated via a low degree polynomial $$in F_3[x]$$. The change in the first lemma to generalize it to arbitrary primes, $$p$$ and $$q$$, is straightforward.

But in the second lemma, where they changed $$fcolon{0,1}^nto{0,1}$$ to $$fcolon{-1,1}^nto{-1,1}$$ and defined a function $$prod_{i=1}^n y_i$$ which represents parity, I do not quite get how to generalize to arbitrary $$p$$ and $$q$$.

## WOW Classic Players Will Relive the Gates of Ahn'Qiraj

World of Warcraft Classics is slowly bringing the full version of the original MMO experience to reality, and one of the biggest attacks and events in the game will go live on July 28. Version 1.13.5 will unlock the content of "Ahn’Qiraj" and take the player to the sand of Silithus.

On July 28th, World of Warcraft Classic players will relive the Gates of Ahn’Qiraj world event, when thousands of races will take the lead in opening the nominal gate and release groups of angry monsters on Azeroth.

On the day of July, World of Warcraft Classic will enter the fifth stage of its release schedule. This update will add the Scepter of the Shifting Sands mission line and begin the Ahn’Qiraj War – these are two key components of a global event that require the hard work of the guild and the entire server community.

Ahn’Qiraj’s war effort requires players to donate production materials in preparation for combating the evil exterminator Qiraji in the Silithus region. Basically, stacking this kind of inventory is a competition between server communities to understand who can finish the World Series first.

The second part of the event is strictly aimed at Classic’s core players. The Assault Guild will carry out a long and tortuous task to build the Scepter of the Shifting Sand, which is an extremely rare item that only a few players can use on each server. Interestingly, Luke Smith, the director of Destiny 2, was one of the luckiest players when he first participated in the game of Ahn’Qiraj in 2006.

After completing these two tasks, the keeper of the scepter can sound a gong, which will open the Gates of Ahn’Qiraj, triggering a 10-hour war, the entire server can participate in while hardcore raiders will slip through the battle to test their mettle in the two new raids.

This is one of the most ambitious events in the history of World of Warcraft, and I am very happy to see Classic reappear at this moment. The first time the door of Ahn’Qiraj was opened, the chaos caused almost made the server unbearable, leading to various nasty connection problems and lags. But this is an unprecedented conflict in the scale of online games, and it will be fascinating to revisit this moment

If you need to buy WoW boost and wow classic gold or any other special items, don’t forget to visit WOWclassicgp.com first! Top WoW items and service are waiting for you!

.

## If Bill Gates makes a law that mandates coronavirus vaccination, will you obey it?

If they need to MANDATE a vaccine like that, that would have me afraid to take it.

Show me evidence of the safety and let me make up my own mind. If it is safe, I will take it. If it is not safe because of the quick turn-around with little testing, I am not taking it.