geometry – How can you change the counts on vertices of a tetrahedron if you increase/decrease the counts on all vertices of a face the same amount?

Hard question to ask, but here’s the idea:

I’m creating a game to teach invariants. I want to make a game where each vertex of a platonic solid (we’ll start with a tetrahedron) has a counter – all initially set to 0.

If you click a face, the counter on each vertex of that face increases by 1. If you right-click a face, the counters on each vertex of that face all decrease by 1.

I want to describe all possible counter values attainable in this game. Clearly a necessary condition is that the sum of the counters on the tetrahedron be a multiple of 3, but I don’t think that’s sufficient. For example, I don’t think (0,0,1,2) is possible.

What possibilities exist? And what if we start with a different platonic solid?

physics – Unity – how to weld nearby mesh collider vertices together to erase seams?

2020.3.2f1. I have a very commonly seen problem. I have a Spherecollider which I am using for a physics game, and geometry that uses BoxColliders or MeshColliders. Everything is nice until I get to the seams of one of these objects, and then my ball loves to do inane things like come to a complete stop across a seam or bounce high into the air when striking one. These seams are very tiny as you can see in the image below.

So, I’ve tried basically every workaround in the physics engine and rigidbody options for my ball (continuous, changing timestep, etc), and none of them completely erase the issue. I suspect that unless I marry all the colliders together, decimating points within some tolerance of each other into one, I will always have this problem at least in some cases, which isn’t acceptable for my project.

So I’m wondering how I would work with this data, or if there is a tool out there that does this. How do I access the meshcollider data of each object in the scene? If I join them into a “master mesh” how does it expect to be constructed (quads from vertices or something)? Is there a performance aspect to worry about, having one giant collider versus many tiny ones? I imagine it screws with pruning colliders in the collision detection portion.

Given graph G and vertices v and w can you non-deterministically walk the “least Hamiltonian path” from v to w, if it exists?

My understanding of non-deterministic algorithms is that they’re “as lucky as you want”.

…you can think of the algorithm as being able to make a guess at any point it wants, and a space alien magically guarantees it will always make the right/lucky guess.

For example, if you choose two vertices `v` and `w`, if there’s a `vw` path, then you can non-deterministically walk a `vw` path, luckily correctly guessing the vertices to walk in a `vw` path. Given this is true of paths in general, I wonder if the same can be done for Hamiltonian paths. I would think so, but I’m not sure.

Therefore, my first question is: if you can non-deterministically walk a `vw` path, can you non-deterministically walk a Hamiltonian path from `v` to `w`, if a Hamiltonian path exists? If you can non-deterministically walk a Hamiltonian path, I wonder if the same can be done for an additional constraint, what I’m calling a “least Hamiltonian path.” I would think so, but I’m not sure.

Define the least Hamiltonian path from `v` to `w` to be the Hamiltonian path such that the second vertex is the smallest it can be, then the third vertex is the smallest it can be, the fourth is the smallest, etc. Assume vertices are integers. For example, if we consider `K5` the graph with vertices `{1,2,3,4,5}` and all possible edges, then the least Hamiltonian path for `(v,w)` = `(2,3)` is `21453`. If you were at vertex 2, the next least vertex would be 1. Then, the next least vertex would 4. etc.

Therefore, my actual question is: Given graph `G` and vertices `v` and `w` can you non-deterministically walk the least Hamiltonian path from `v` to `w`, if it exists?

Motivation: If so, then perhaps there’s a space-efficient algorithm for non-deterministically walking a Hamiltonian path: You can keep a counter for vertices `v` and `w`, and go through each pair of vertices such that `v<w`, checking for the existence of a least Hamiltonian path. To ensure all vertices in `G` are reached, keep a counter for the number of vertices walked (this should equal `N` if there are `N` vertices). Also, ensure that each vertex in the path is unique. The least Hamiltonian path from `v` to `w` will be unique, therefore it can be walked multiple times (each time you walk through it, starting at `v`, you’ll non-deterministically guess the next least vertex in the least Hamiltonian path). You could use two counters to ensure no vertices are repeated – one for the vertex you’re checking to see if it’s unique (loop through the vertices in the least Hamiltonian path), and another counter for a second pass through the least Hamiltonian path. Ensure the second counter encounters the value of the first counter exactly once (use a boolean flag to keep track of this).

complex analysis – maximum product of distances of a point and vertices of equilateral triangle

If $$ABC$$ is an equilateral triangle. $$P$$ is a variable point inside the triangle or on its sides. We need to find the maximum product of $$AP cdot BP cdot CP$$.

This question is in a Complex Analysis homework.
I don’t know how can I use the complex analysis (maybe, maximum modulus theorem ) to find the maximum product.

convex polytopes – Number of vertices in a polyhedron

Consider polytopes

$$A_1[x_{1,1},dots,x_{1,m_1},z_{1}]’leq b_1$$
$$A_2[x_{2,1},dots,x_{2,m_2},z_{2}]’leq b_2$$
$$B[z_{1},z_{2},z]’leq c$$
having vertex count $$v_1,v_2$$ and $$v$$ respectively.

We eliminate $$z_{1}$$ to $$z_{2}$$ by Fourier Motzkin and get a new polyhedron
$$C[x_{1,1},dots,x_{2,m_2},z]’leqtilde c.$$

Is the number of vertices in the new polyhedron $$leq v_1v_2$$ if $$m_1=m_2$$?

co.combinatorics – Number of linear inequalities describing a polyhedron with prescribed number of vertices

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

Command for finding maximum weight Hamiltonian path between two vertices

A Hamiltonian path is a graph path between two vertices of a graph that visits each vertex exactly once.
Finding a single Hamiltonian path of a graph $$g$$ is implemented in the Wolfram Language as FindHamiltonianPath[$$g$$]Hamiltonian path.

What command could be used to find the Hamiltonian path with maximum path weight between the starting vertex $$s$$ and the terminating vertex $$t$$ in the following edge labeled graph?

Graphs: colouring vertex weights differently from vertices

I use simultaneous display of vertices and weights (this topic is related to another question posted here)

I display vertices via the following code (only included for completeness)

``````vf({xc_, yc_}, name_, {w_, h_}) :=
Block({xmin = xc - w, xmax = xc + w, ymin = yc - h, ymax = yc + h},
Polygon({{xmin, ymin}, {xmax, ymax}, {xmin, ymax}, {xmax, ymin}}));
``````

The graph edges are specified as:

``````relations = {x2 -> x6, x2 -> x7, x5 -> x6, x5 -> x7, x3 -> x2}
``````

The following code has a part that colors the vertex labels red

``````labeling(relations_, weights_) :=
Graph(relations,
VertexCoordinates ->
ReflectionTransform({0, -1})@GraphEmbedding(Graph(relations)),
VertexLabelStyle -> Directive(Red, 15),
VertexWeight -> weights, VertexShapeFunction -> vf)

g = labeling(relations, {1, 2, 3, 4, 5});
``````

The vertices xi and their weights are simultaneously displayed by:

``````g = SetProperty(
g, {VertexLabels ->
Table(i ->
Placed({i, PropertyValue({g, i}, VertexWeight)}, {Before,
After}), {i, VertexList(g)})})
``````

How can I display the weights in blue, but keep the vertices xi in red?

VertexLabelStyle allows me to set the colour red for vertex labels (displaying both vertices xi and their weigths red in the graph).

There is no VertexLabelStyle to set colours of weights (I believe).

I need to manipulate the weights and vertices separately in the graph, i.e. sometimes move the vertices (xi) which are to remain red and sometimes move the weights (integers) which need to remain blue.

reference request – Which graphs on \$n\$ vertices have the largest determinant?

This is a question that seems like it should have been studied before, but for some reason I cannot find much at all about it, and so I am asking for any pointers / references etc.

The determinant of a simple graph is the determinant of its adjacency matrix which is, of course, a symmetric binary matrix with zero-diagonal.

Question: Which graph has the largest value of $$|det(A)|$$ over all simple undirected graphs on $$n$$ vertices?

(We could ask separately for the graphs with minimum determinant, which will be some negative number, and those of maximum determinant, but by taking the absolute value, this just becomes a question of which graphs have the most extreme determinant.)

For small numbers of vertices, we can just find the answer almost by hand:

• On $$2$$ vertices, the winner is the complete graph $$K_2$$ with spectrum $${-1,1}$$, so determinant $$-1$$, of absolute value $$1$$.
• On $$3$$ vertices, the winner is $$K_3$$ which has absolute value of determinant equal to $$2$$
• On $$4$$ vertices, the winner is $$K_4$$ with value $$3$$.
• On $$5$$ vertices, there are two winners (both with value $$4$$), namely $$K_5$$ and the “bowtie” graph (two triangles sharing a common vertex).

Sequence so far is $$1$$, $$2$$, $$3$$, $$4$$ (don’t bother looking this up in OEIS).

For larger numbers of vertices, we turn to the computer and discover that on $$6$$ vertices, the maximum value is $$7$$, and this is realised by two graphs, namely a triangle and a $$4$$-clique sharing a vertex, and two $$4$$-cliques sharing an edge.

From there, the sequence continues: 12, 28, 128, 256, 576 for 7, 8, 9, 10 and 11 vertices respectively, with between 2 and 7 graphs achieving the maximum for each of these values.

So now I do have enough to look up in the OEIS, but there are no matches.

The problem of finding the maximum determinant of a (0,1)-matrix, often called the Hadamard maximal determinant problem has been extensively studied, and there are lots of bounds, and constructions of extremal matrices etc. (There is a mapping between (0,1)-matrices and (-1,1)-matrices which changes the determinant predictably and when they exist, Hadamard matrices are the winners.)

So lots is known, and it is summarised in sequence A003432 on the OEIS which gives exact values up to $$n=20$$.

Just for comparison, for $$n = 6$$ to $$n=11$$, we have

• 7, 12, 28, 128, 256, 576 (for graphs)
• 9, 32, 56, 144, 320, 1458 (for
(0,1)-matrices)

From several sources, including the OEIS, I have been advised to check a website attributed to Will Orrick at http://www.indiana.edu/~maxdet/ but this appears to be offline or removed or something, and nor could I find his email address in the directory for that university.

So my question remains: what is known about maximal determinant (in absolute value) of the adjacency matrix of a simple graph on $$n$$ vertices?

algorithms – Maximum edges for bipartite graph where all vertices of one part have order 1

I am looking for a method/algorithm to find the maximum edges possible for a bipartite graph where one part only has nodes of order one.

I guess a good example would be an algorithm matching as many students as possible to a teacher for a given class. Teachers will teach many students, but each student only has one teacher.

I would also want to modify such an algorithm to include other constraints, like availabilities for example.

Additionally, is there a name for this specific type of bipartite graph?