set theory – Large chromatic number in hypergraphs with large edges

Let $H=(V,E)$ be a hypergraph. If $kappa neq emptyset$ is a cardinal, we call a map $c:Vto kappa$ a coloring if for each $ein E$ with $|e|>1$ the restriction $crestriction_e$ is non-constant. The smallest cardinal $kappa > 0$ such that there is a coloring map $c:Vto kappa$ is said to be the chromatic number $chi(H)$ of $H$.

Given an infinite cardinal $kappa$, let $(kappa)^kappa$ denote the collection of subsets of $kappa$ having cardinality $kappa$.

A standard combinatorial argument shows that whenever $Esubseteq (kappa)^kappa$ has cardinality $kappa$, then $chi(kappa,E) = 2$.

Question. Is it consistent with ${sf ZFC}$ that there is $E subseteq (kappa)^kappa$ with $|E|<2^kappa$ and $chi(kappa,E) = kappa$?

Given a simple undirected graph, how to direct its edges to make it transitive

I am currently looking for an algorithm to determine whether we can direct every edge (no adding or deleting edges allowed) so that the graph is transitive (meaning that if (x,y) and (y,z) are edges then so is (x,z)).

One way to do it is to use PQ trees as I had an interaction with a professor and this is what he had to say but we are looking for a faster algorithm. When I try to do it myself, my mind keeps looping back to the PQ-tree technique. Each edge is allowed only one direction (if in the underlying undirected graph {a,b} is an edge then exactly one of (a,b) and (b,a) is an edge).

Perhaps there is one algorithm better in the sense of lower complexity than the PQ-tree approach, but we can’t seem to find it in literature. Do we take it that doing a PQ-tree approach is the best way?

The title of this post is the best I could do in the google search bar. Any help is appreciated.

matching theory – Number of edges in bipartite graphs

Let $G$ be a bipartite graph on $n$ vertices of either color.

Suppose $G$ contains no perfect matching the number of edges can be $Omega(n^2)$ (just do not place an edge between a particular pair of vertices).

  1. Suppose $G$ contains exactly one perfect matching what is the maximum number of edges it can have?

  2. Suppose $G$ contains exactly two perfect matchings what is the maximum number of edges it can have?

I think $2n-1$ is the upper bound for 1. Essentially fix a perfect matching. As long as we do not have a $2times2$ subgraph we can add edges and there is exactly $n-1$ additional edges we can add. For 2. the upper limit is $2n$ I think by the same calculation.

graphics3d – How do you calculate the area of a surface with edges in mathematica

Like the title indicates, how could I achieve this. Normally what I did for a closed surface is as follows:
where a is an output from ListContourPlot3D. However, this fails when applied on a surface that is not closed. For example, if I want to calculate the total area of all the yellow (or the blue) surfaces in the following plot (again given by ListContourPlot3D), I wonder what the easiest possible way to do it.

enter image description here

plotting – LayeredGraphPlot: How to control the style of the edges?

I am trying to plot a graph using LayeredGraphPlot;

I would like to change the style of the edges commented out inside the following command to dashed lines with different colors:

chart = LayeredGraphPlot({{"S" -> "E", ""}, {"E" -> "I", 
    " !(*SubscriptBox((e), (i))) "}, {"I" -> "H", 
    " !(*SubscriptBox((i), (h))) "}, {"E" -> "R", 
    " !(*SubscriptBox((e), (r)))"}, {"I" -> "R", 
    " !(*SubscriptBox((i), (r)))"}, {"H" -> "R", 
    " !(*SubscriptBox((h), (r)))  "}, {"H" -> "D", 
    " !(*SubscriptBox((h), ((d)(\ \ \ ))))"(*{"E"
(Rule)"S", "  Subscript((Beta), e)  "},{"I"(Rule)"S", 
   "  Subscript((Beta), i)  "}*)}}, Left, 
  VertexShapeFunction -> ({EdgeForm(Black), Yellow, Disk(#1, 0.2), 
      Black, Text(#2, #1)} &), PlotStyle -> {Blue}, 
  VertexSize -> Large, 
  EdgeLabelStyle -> Directive(10, Background -> White))

Thank you!

shortest path – The Cut Lemma for graphs with non-distinct edges

In my introductory algorithms class I recently learned about the Cut Lemma and how it can be used to prove correctness for many Minimum Spanning Tree algorithms like Kruskal’s and Prim’s.

In class, to simplify these proofs-of-correctness, we assumed that all edge weights in the graphs we were considering were distinct. This was also a helpful assumption when working with the Cut Lemma, since it guaranteed there will only be one minimum-weight crossing edge between the two disjoint sets of vertices created by the cut. In fact, we used proof-by-contradiction to prove the Cut Lemma, which required a unique minimum-weight edge.

My question is, what happens if edge weights aren’t distinct? How can we still use the Cut Lemma to prove correctness for MST algorithms if we can no longer guarantee there is one minimum-weight crossing edge between the two sets of a cut? Is anything materially different?

heuristics – CVRP and removing edges from a graph

I am solving a CVRP (Constrained Vehicle Routing Problem) on a connected graph, that is not necessarily complete. Edge weights represent Euclidean distances.
I know that, in general, the complexity of the problem in terms of the number of variables (and computational time) increases with the number of edges in the graph.
I also know that for particular graphs where node degree is fixed (for example 3 or 4), polynomial-time algorithms exist that return the optimal solution.
Therefore, I am playing around with removing the edges with the highest weight from the graph, while ensuring each node retains at least a minimum degree, and seeing how this impacts solution time. As expected, reducing the number of edges in the graph does impact the solution time significantly.

Are there any theoretical results that tie this idea of removing edges from the graph before solving the problem to the optimality of the solution? Is it in some cases possible to conclude, a-priori, that some specific edge will necessarily NOT be part of the optimal solution?

graphs – stCon algorithm to find 2 distinct edges between vertices

The traditional approach of stCon shows that there is a edge between two vertices in a graph and this problem can be solved on a TM by a non deterministic algorithm like this:
$<G,u,v>, G = (V,E)$ is a graph with the nodes $V={1,2,…,m}$

x := u
repeat m-times:
    if x == v:
    pick non-deterministic y from V
    if (x,y) element of E:
        x := y
        otherwise reject

If I want to check if there are two distinct edges to connect two vertices, I need to basically do the same but check if the paths that were found contain different vertices right? So how can one change this algorithm to accomplish that?

algorithms – Minimum Vertex Cover of 2 vertex disjoint odd cycles that have edges between them

Consider the graph $G$, which is comprised of 2 vertex disjoint odd cycles ($C_1$, $C_2$) where $|C_1|$ and $|C_2| geq 5$. $G$ is sub-cubic and connected, with edges in between the cycles. Because $G$ is sub-cubic, each node’s degree $leq 3$ but $geq 2$.

I am interested to know whether the minimum vertex cover of $G$ can be found in polynomial time? Furthermore, I am also interested to know whether we can:

  1. Establish a tight upper bound on the MinVC for such a graph.
  2. Say anything else about this graph that’s insightful.

We know that for either cycle $C$, $MinVC = leftlfloorfrac{|C|+1}{2}rightrfloor$. Thus, $MinVC(G) geq leftlfloorfrac{|C_1|+1}{2}rightrfloor+leftlfloorfrac{|C_2|+1}{2}rightrfloor$

A loose upper bound would be to take all vertices of one cycle and solve optimally for the other. Thus, $MinVC(G) leq min(|C_1|,|C_2|) + leftlfloorfrac{max(|C_1|, |C_2|)+1}{2}rightrfloor$.

php – Is there a canonical definition of SPA – or is SPA a broadly agreed-on architecture with fuzzy edges?


Is there a canonical definition of SPA which would exclude the software architecture model described below?

I’m working on an app with a new web-architecture model (new to me, at any rate) which has features which differentiate it from a Single Page Application (SPA) as the term is conventionally understood.

Since the model uses server-side and client-side variables which always automatically mirror each other, I would like, at least provisionally, to give the model a label something like Reflective SPA (or veSPA for short) but I’m concerned that due to its reliance on server-side processes, it may not qualify as an SPA at all and, as such, this name would be misleading and / or nonsensical.

Towards the end of the Wikipedia entry on Single Page Applications there is a statement:

A SPA is fully loaded in the initial page load and then page regions
are replaced or updated with new page fragments loaded from the server
on demand. To avoid excessive downloading of unused features, a SPA
will often progressively download more features as they become
required, either small fragments of the page, or complete screen

I’d strongly subscribe to this as a conventional definition of an SPA. This is absolutely what I think of when I read the acronym SPA.

What differentiates veSPA is that instead of:

page regions are replaced or updated with new page fragments loaded from the server on demand

veSPA repeatedly responds to user interactions by updating the queryString, either via:

1. Updating the URL (including the queryString), using:

  • window.history.pushState({}, document.title, '' + queryString); (Javascript)

2. Reloading the URL (using a new queryString), using:

  • window.location.href = '' + queryString; (Javascript)

3. Redirecting the URL Request (using a new queryString) at server level, using:

  • header('Location:'.$Query_String); (PHP)

When the page is actually reloaded, various custom-data attributes in the root HTML element are populated from the queryString, using the super global variable $_GET in PHP.

When the URL queryString is updated, the same custom-data attributes in the root HTML element are populated from the queryString, using new URLSearchParams( in Javascript.

Either way – and this is the most important culmination of everything described above – the app-view is then rendered via CSS from the values in the custom-data attributes in the root HTML element.


Does this use of page-reloads and PHP (described above) mean this model is too differentiated from SPA (as conventionally understood) to have the term SPA meaningfully applied to it (or to use SPA in its name)?

Is there a canonical definition of SPA which would exclude the model described above?