at.algebraic topology – Proofs that the classifying space of Connes’ cycle category \$Lambda\$ is \$mathbb C mathbb P^infty\$

Connes showed in Cohomologie cyclique et foncteurs $$Ext^n$$ (1983) that the classifying space of his cycle category $$Lambda$$ is $$mathbb C mathbb P^infty = B(S^1) = K(mathbb Z,2)$$.

Connes’ proof is not quite as conceptual as one might like. He shows that $$|Lambda|$$ is simply-connected, and then computes its cohomology via an explicit resolution of the constant functor $$Lambda to Ab$$, $$(n) mapsto mathbb Z$$ via a double complex which is cooked-up by gluing together the usual way of resolving cyclic groups and the usual way of resolving simplicial objects, with a few modifications. He’s able to get the ring structure on the cohomology using an endomorphism of this double complex. The result follows because $$mathbb Cmathbb P^infty$$ is characterized among simply-connected spaces by its cohomology ring.

Surely in the last nearly 40 years new proofs that $$|Lambda| simeq mathbb C mathbb P^infty$$ have been found.

Question 1: What are some alternate proofs that $$|Lambda| simeq mathbb C mathbb P^infty$$?

Question 2: (somewhat vague) In particular, is there a proof which somehow uses an explicit $$S^1$$ action on some category or simplicial set related to $$Lambda$$?

dungeons and dragons – How does the Day/Night cycle work on the Elemental Plane of Fire?

So I found out, that there is a curfew every night in the City of Brass on the Elemental Plane of Fire. This makes me wonder: How does a day/night cycle work on the Elemental Plane of Fire?
Is there a sun and if so, does it rise and set like a normal sun?

I’m looking for informations in any sourcebook of whatever edition of Dungeons & Dragons.

The source for the curfew is the book “Secrets of the Lamp” for 2nd edition published 1993. From page 27:

[…] a strict curfew is enforced each night

big o notation – Is reduction from Rudrata/Hamiltonian path to Rudrata/Hamiltonian cycle O(1)?

I am reading about P and NP and looking at the reduction of a Rudrata/Hamiltonian path to a Rudrata cycle. I think adding an extra node and 2 edges connecting the start, `s` and the target, `t` is `O(1)` time as this doesn’t depend on the size of the graph. Algorithms by Dasgupta et al. says that the pre and post processing steps take polynomial time.

One last detail, crucial but typically easy to check, is that the pre- and postprocessing functions take time polynomial in the size of the instance
(G, s, t).

Since `O(1)` is polynomial time of order 0, is this reduction `O(1)`?

Do a pair of parallel edges form a cycle in a graph

Whenever there is a back edge, a cycle is detected.
Then, do a pair of parallel edges form a cycle in a graph? If no, why it is not a back edge?

unity – Night cycle object not going smootly when object instantiated

Hello so I’m adding night cycle to my game it’s going smoothly for object except the instantiated one

as you can see that is a different color on it.

so here the script for night cycle:

`````` public GameObject ca1, ca2, ca3, ca4, ca5, ca6;

void Update()
{
if (_GameManager.instance.isStarted)
{
timer += Time.deltaTime;

if (timer >= maxTime)
{
GenerateObstacle();

if (_GameManager.instance.score >= 450)
{
if (_GameManager.instance.score % 2 == 0)
{
GenerateBuwungObstacle();
}

if (_GameManager.instance.score >= 3000)
{
if (_GameManager.instance.score % 5 == 0)
{
GeneratedMeteorObs();
}
}
}

timer = 0;
}

if (_GameManager.instance.score % 200 == 0 && activeFade == null && activeFadeObjectClouds == null)
{

Color colorCactusObs = fadeToBlack ? Color.white : Color.gray;

}
}
}

// for generating the cactus
public void GenerateObstacle()
{
choosedObstacle = Random.Range(0, Obstacles.Length);
GameObject obstacle = Instantiate(Obstacles(choosedObstacle));
}

{
Color start1 = ca1.GetComponent<SpriteRenderer>().color;
Color start2 = ca1.GetComponent<SpriteRenderer>().color;
Color start3 = ca3.GetComponent<SpriteRenderer>().color;
Color start4 = ca4.GetComponent<SpriteRenderer>().color;
Color start5 = ca5.GetComponent<SpriteRenderer>().color;
Color start6 = ca6.GetComponent<SpriteRenderer>().color;

for (float t = 0; t < 1f; t += (Time.deltaTime / fadeSpeed) * 2)
{
ca1.GetComponent<SpriteRenderer>().color = Color.Lerp(start1, destination, t);
ca2.GetComponent<SpriteRenderer>().color = Color.Lerp(start2, destination, t);
ca3.GetComponent<SpriteRenderer>().color = Color.Lerp(start3, destination, t);
ca4.GetComponent<SpriteRenderer>().color = Color.Lerp(start4, destination, t);
ca5.GetComponent<SpriteRenderer>().color = Color.Lerp(start5, destination, t);
ca6.GetComponent<SpriteRenderer>().color = Color.Lerp(start6, destination, t);

yield return null;
}

ca1.GetComponent<SpriteRenderer>().color = destination;
ca2.GetComponent<SpriteRenderer>().color = destination;
ca3.GetComponent<SpriteRenderer>().color = destination;
ca4.GetComponent<SpriteRenderer>().color = destination;
ca5.GetComponent<SpriteRenderer>().color = destination;
ca6.GetComponent<SpriteRenderer>().color = destination;

}
``````

I already try with for loop in the `object cactus fade` but still not smooth

Prove that connected graph \$G\$ with \$delta (G)geq 3\$ contains a cycle \$C\$ such that G-V(C) is still connected.

In a connected simple graph every vertex has a degree at least $$3$$. Prove that the graph contains a cycle such that the graph remains connected when the edges of this cycle are deleted.

Source: https://www.komal.hu/verseny/2000-02/mat.e.shtml

I’ve tried this: Pull out of $$G$$ a cycle $$C$$ with smallest perimeter $$p$$.

Claim: No two nonconsecutive vertices in circle $$C$$ are adjacent (else we could make smaller cycle then we have).

Let $$C_1,C_2,…,C_k$$ be all components in $$G-C$$. If $$n_i = |V(C_i)|$$ and $$e_i= |E(C_i)|$$, then we have
$$e_i = {3n_i-b_iover 2}$$ where $$b_i$$ is a number of edges between $$C_i$$ and $$C$$. Because $$G$$ is connected we have $$b_igeq 1$$ for each $$i$$. Because of the claim we have: $$b_1+b_2+cdots +b_k = p$$

I have no idea what to do now.

np complete – Reducing the Hamiltonian cycle to the travelling salesman problem and self loops

If this is my adjacency matrix for the hamiltonian cycle:
$$begin{pmatrix}0&1&0&1\ 1&0&1&0\ 0&1&0&1\ 1&0&1&0end{pmatrix}$$
Then a reduction algorithm to reduce this to a TSP problem is to introduce 1 anywhere an edge is missing and let pre-existing edges have a cost of zero (according to this), applying this yields:
$$begin{pmatrix}1&0&1&0\ 0&1&0&1\ 1&0&1&0\ 0&1&0&1end{pmatrix}$$
Now I see that I have also introduced weighted-loops to my undirected graph, would asking whether this has a zero-cost salesman tour be equivalent to asking whether the unreduced version has a hamiltonian cycle, or should I maybe have something else on the diagonal of the reduced matrix?

graph theory – Complexity of heaviest 2-optimal vertex-disjoint cycle covers

Calculating lightest vertex-disjoint cycle covers of finite complete symmetric graphs with weighted edges can be done efficiently and also renders the edge set of the calculated cycles free of pairs of crossing edges.

Calculating the unconstrained heaviest cycle cover will however generate edge sets with many pairs of crossing edges, leading to the

Question:
what is the complexity of calculating heaviest 2-optimal vertex-disjoint cycle covers, i.e. if constraints are added that make crossing edges mutually exclusive?

The motivation for the question is the observation that the minimal cycle cover may contain cycles that are far apart, thus making it hard to merge these cycle in an optimally to get an approximation of the shortest Hamilton cycle.
For heaviest 2-optimal cycle covers we may expect many pairs of long edges for which the minimum-weight matching of the $$K_4$$ that is induced by their adjacent vertices is small, thus easing the task of optimally merging the cycles to a short tour.

pseudo random generators – Simple way to extend period of LCG (expected cycle length)?

Let’s consider 128-bit pseudorandom generator. From Harris 1960, if we model uniform random permutation, we know that every period length $$l$$ has equal probability $$1/n$$ (Eq. 5.2) for any particular starting point, where $$n = 2^{128}$$ is the size of the domain, so the expected cycle length is $$sum_{i=1}^n i/n = (n + 1)/2 approx 2^{127}$$.

We know that in typical LCG’s modulo $$2^{128}$$ it is not always the case:

https://en.wikipedia.org/wiki/Linear_congruential_generator

We can use Hull–Dobell Theorem to achevie period equal modulus. But what period we could expect in general in LCG, when we will choose multiplier and increment randomly? Let’s consider only LCG’s modulo $$2^{n}$$. And the main question. Let’s consider some simple modification of LCG – compute output in little endian, in other words our output is reversed block of ordinary LCG. What period or expected cycle length we can expect with such modification?

My preliminary experiments indicate that these cycles will be larger than in regular LCG’s. But I checked not much LCG’s that way. Also I’m looking for some mathematical aproach or proof.

c# – How do I let the player create a list, and make the game cycle through that list?

I’m creating a game where the player can put 4 objects in any combination, even 4 of itself. What would be the best method of going about this, and letting the game cycle through the list the player created based on a timer.

Example: The player has 4 weapons: Katana, Axe, Spear, Chakram. The player can set the order to Chakram, Chakram, Katana, Spear. The game will give the player the item based on the order of the list they set. The game will only give the player an item after a set amount of time.

``````using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Runner : MonoBehaviour
{
private Touch _touch;
private Rigidbody _rb;
private Animator _anim;
private UIManager _ui;

(SerializeField) private HealthBar _healthBar;
(SerializeField) private Bullet _bullet;

(SerializeField) private float _moveSpeed = 0.25f;
(SerializeField) private float _dashSpeed = 0.5f;
(SerializeField) private int _health = 20;
(SerializeField) private int _currentHealth;

(SerializeField) private bool _hasZwei;
(SerializeField) private bool _hasAxe;
(SerializeField) private bool _hasDagger;

void Start()
{

_rb = GetComponent<Rigidbody>(); //Accessing the Rigidbody Component
_anim = GetComponent<Animator>(); //Accessing the Animator Component
_ui = GameObject.Find("UI Manager").GetComponent<UIManager>(); //Accessing the UI Manager Component

_currentHealth = _health;
_healthBar.SetMaxHealth(_health);

_anim.SetBool("Running",true);
}

// Update is called once per frame
void FixedUpdate()
{
Movement();
}

void Update()
{
Invoke("GainPowerUp", 5f);
}

void Movement()
{
if (Input.touchCount > 0)
{
_touch = Input.GetTouch(0);

if (_touch.phase == TouchPhase.Moved)
{
_rb.MovePosition( new Vector3(
transform.position.x + _touch.deltaPosition.x * _moveSpeed,
transform.position.y,
transform.position.z + _touch.deltaPosition.y * _moveSpeed));
_rb.constraints = RigidbodyConstraints.FreezeRotation;
}
}

if (Input.touchCount == 2)
{
_touch = Input.GetTouch(1);

switch(_touch.phase)
{
case TouchPhase.Began:
if (_hasAxe == false && _hasZwei == false && _hasKatana == false && _hasDagger == false)
{
Debug.Log("Has no weapon.");
}
if(_hasZwei)
{
Debug.Log("Player has attacked with Zweihander");
_hasZwei = false;
_anim.SetTrigger("NoWeapon");
}
if(_hasAxe)
{
Debug.Log("Player has attacked with Axe");
_hasAxe = false;
_anim.SetTrigger("NoWeapon");
}
if(_hasDagger)
{
Debug.Log("Player has attacked with Dagger");
_hasDagger = false;
_anim.SetTrigger("NoWeapon");
}
{
Debug.Log("Player has attacked with Katana");
_anim.SetTrigger("NoWeapon");
}
break;
}
}
}

public void Damage(int damage)
{
_currentHealth -= damage;

_healthBar.SetHealth(_currentHealth);

if (_currentHealth == 0)
{
gameObject.SetActive(false);
}
}

public void GainPowerUp(int _powerUp)
{
_powerUp = Random.Range(0,4);

switch(_powerUp)
{
case 1:
//Sword Powerup
_hasZwei = true;
_hasAxe = false;
_hasDagger = false;
_anim.SetTrigger("SwordRun");
break;

case 2:
//Axe Powerup
_hasAxe = true;
_hasZwei = false;
_hasDagger = false;
_anim.SetTrigger("AxeRun");
break;

case 3:
//Katana Powerup
_hasAxe = false;
_hasDagger = false;
_hasZwei = false;
_anim.SetTrigger("KatanaRun");
break;

case 4:
//Dagger Powerup
_hasDagger = true;
_hasAxe = false;