Extend algorithm to even faces, add simple-level-resolution conjecture

- Generalize Phase 1 to include even interior faces as optional flip
  candidates and allow the source-triangle break in $L_0$ to be skipped;
  generalize Phase 2 so even outer-incident cycles may have at most one
  outer-face edge flipped (odd cycles still must have one).
- Define "simple level resolution" as a triangulation $G'$ obtained from
  some $(G, S)$ via the algorithm with bipartite parity subgraphs
  (Definition 5.4).
- Add Conjecture 5.7 (simple-resolution md4 surjectivity) and
  Observation 5.6: every minimum-degree-4 plane triangulation iso-class
  on $n \in \{6, ..., 11\}$ vertices is reached as a simple level
  resolution. Counts: 1, 1, 2, 5, 12, 34. The md4 restriction is
  necessary -- specific non-md4 iso-classes (iso 5 at n=8; iso 25, 183
  at n=10) are not reachable.
- Add experiments/simple_level_resolution_coverage.py implementing the
  branched algorithm and coverage check, plus supporting scripts for
  Phase 1 cycling debugging, Phase 2 gap diagnosis, inductive-lift
  scaffolding (inductive_lift_check.py for the route-1 proof strategy),
  and visualizations of the unreached n=10 iso-classes and the original
  Phase 2 gap example.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

papers/level_resolutions_of_maximal_planar_graphs/paper.tex

@@ -399,25 +399,7 @@ $L_{k+1}$ iff $\ell_G(w) = \ell_G(x) = k + 1$; otherwise $wx$ is cross-parity
 and lies in no level subgraph. In all cases $uv$ is removed from $L_k$.
 \end{proposition}
 
-\subsection{Cross-level flip pass}
-
-For each odd simple cycle $C$ of each $L_k$ containing a cross-level edge,
-flip one such edge. By Proposition~\ref{prop:flip-target} the new edge
-either enters $L_{k+1}$ (in the apex case $(k+1, k+1)$) or is cross-parity
-(otherwise). Choosing apex pairs distinctly across cycles makes the set of
-new edges entering any single level $L_j$ a matching, hence a forest, and
-similarly for new same-parity-distance-$2$ edges entering the relevant
-parity subgraph; these therefore introduce no odd cycle.
-
-\subsection{Tricky-everywhere cycles}
-
-After the cross-level pass, the only odd simple cycles remaining in any
-$L_k$ are those whose every edge is intra-level; we call such a cycle
-\emph{tricky-everywhere}. By Proposition~\ref{prop:flip-target}, flipping
-any edge of a tricky-everywhere cycle replaces it with another edge of $L_k$,
-so the local triangle pair $(uvw, uvx)$ becomes $(uwx, vwx)$: still a pair
-of odd triangles inside $L_k$. To make global progress on these cycles we
-use a facial-depth potential to choose the flip.
+\subsection{Facial depth and isolated faces}
 
 \begin{definition}[Facial depth]
 \label{def:facial-depth}
@@ -430,41 +412,138 @@ $L_k$ is
   \mathrm{depth}(F) \;=\; \min_{F' \in \mathcal{B}} \mathrm{dist}_D(F, F'),
 \]
 with the convention $\mathrm{depth}(F) = \infty$ if no such $F'$ exists.
+An inner face is \emph{isolated} if $\mathrm{depth}(F) \geq 1$.
 \end{definition}
 
-\subsection{The algorithm}
+The seed set $\mathcal{B}$ consists of the inner faces that already have
+two outer-face edges available as flip targets; Phase~2 below handles
+these directly. Phase~1 uses facial depth as a potential to push isolated
+odd faces toward $\mathcal{B}$.
 
-\begin{enumerate}
-\item \emph{Cross-level flip pass.} For each $L_k$ and each odd simple cycle
-$C \subseteq L_k$ containing a cross-level edge, flip one such edge,
-selecting apex pairs to keep the newly added edges a matching in each
-target level subgraph and in the relevant parity subgraph.
-\item \emph{Intra-level flip loop.} While some $L_k$ contains a
-tricky-everywhere odd simple cycle:
-\begin{enumerate}
+A cycle that is \emph{tricky-everywhere}, meaning every edge is
+intra-level, is necessarily isolated: an outer-face edge of $L_k$ has a
+level-$(k-1)$ apex on its outer side and is therefore cross-level, so a
+tricky-everywhere cycle shares no edge with the outer face. Hence the
+tricky-everywhere cycles are a subset of the isolated odd cycles.
+
+\subsection{Phase 1: interior faces}
+
+\noindent\textbf{Procedure.} While some $L_k$ contains an odd simple cycle
+whose corresponding inner face has facial depth $\geq 1$ and shares no
+edge with the outer face, repeat:
+\begin{enumerate}[label=(\arabic*)]
 \item compute facial depths for all simple level cycles of $L_k$;
-\item among tricky-everywhere odd simple cycles of maximum facial depth,
-      pick any $C$;
-\item among the edges of $C$, pick one whose other incident inner face has
-      minimum facial depth, and flip it.
-\end{enumerate}
+\item among interior odd faces (depth $\geq 1$, no outer-face edges) of
+      maximum facial depth, pick one $C$; even-parity interior faces of
+      depth $\geq 1$ may also be selected as $C$;
+\item find the inner face $F'$ incident to $C$ of minimum facial depth,
+      and flip the edge shared between $C$ and $F'$.
 \end{enumerate}
 
+The restriction to faces with no outer-face edge in step~(2) means that
+every edge of $C$ borders another inner face, so a unique shared-edge
+flip target exists for each neighbor $F'$. The depth-guided choice of
+$F'$ in step~(3) progressively pushes the residual odd-face structure
+toward the seed set $\mathcal{B}$ (depth~$0$). Even-face flips are
+optional restructuring moves that expand the reachable configuration
+space; the loop's termination is gated only by interior odd faces.
+
+\subsection{Phase 2: outer-incident faces}
+
+After Phase~1, every remaining odd simple cycle of $L_k$ shares at least
+one edge with the outer face, whose apex pair includes a level-$(k-1)$
+vertex and is therefore cross-level.
+
+\noindent\textbf{Procedure.}
+For each $L_k$:
+\begin{itemize}
+\item every odd simple cycle $C \subseteq L_k$ incident to the outer
+face \emph{must} have exactly one of its outer-face edges flipped;
+\item every even simple cycle of $L_k$ incident to the outer face
+\emph{may} have at most one of its outer-face edges flipped (an optional
+restructuring move).
+\end{itemize}
+For the source-face level ($k = 0$ with face source $S$), the $L_0$
+source triangle is itself an odd cycle whose three edges all bound the
+outer face; we treat $L_0$ uniformly with higher levels, with the option
+of leaving the triangle intact when the resulting parity-subgraph
+configuration on $G'$ permits.
+
+Each flip is permitted even if the apex edge $wx$ already exists in $G$,
+in which case $G'$ is a multigraph; this does not affect bipartiteness
+of the parity subgraphs of $G'$, since a duplicated edge is bipartite-
+equivalent to a single edge.
+
+\subsection{Simple level resolutions}
+
+\begin{definition}[Simple level resolution]
+\label{def:simple-level-resolution}
+A plane triangulation $G'$ is a \emph{simple level resolution} of a plane
+triangulation $G$ if there exists a level source $S$ of $G$ such that
+the algorithm of Sections~\ref{sec:flip-algorithm}--Phase~1 and~Phase~2
+applied to $(G, S)$, under some sequence of optional-move choices,
+produces $G'$ as a simple-graph triangulation whose parity subgraphs are
+bipartite.
+\end{definition}
+
+\subsection{Empirical status}
+
 \begin{observation}
-\label{obs:terminate}
+\label{obs:empirical-lk-bipartite}
 For every plane triangulation $G$ on $n \in \{9, 10, 11\}$ vertices, every
-level source $S$, and every $k$ such that $L_k$ contains a tricky-everywhere
-odd simple cycle, Step~2 terminates with no tricky-everywhere odd simple
-cycle remaining in any $L_k$. Moreover, the total number of
-tricky-everywhere odd simple cycles strictly decreases on every flip chosen
-by Step~2(c).
+level source $S$, and every $k$ such that $L_k$ contains an odd simple
+cycle, the algorithm produces a $G'$ whose corresponding $L_k$ is
+bipartite (in the underlying simple-graph view). Across the $29640$ such
+$(G, S, k)$ triples — $4645$ at $n \leq 10$ and $24995$ at $n = 11$ —
+Phase~1 always terminates and Phase~2 always succeeds.
 \end{observation}
 
+\paragraph{Coverage test for Conjecture~\ref{conj:simple-md4}.} For each
+$n \in \{6, \ldots, 11\}$ we enumerate all plane-triangulation iso-classes
+on $n$ vertices. For each iso-class $G$, each level source $S$ of $G$,
+and each branching choice within the algorithm — Phase~1 ties on which
+deepest interior face and which lowest-depth neighbor to flip, Phase~2
+choices of which outer-face edge to flip for each odd or even
+outer-incident cycle (including the option to leave even cycles
+untouched), and the option to skip the source-triangle break when $S$ is
+a face — we run Phase~1 to termination and then Phase~2, recording the
+algorithm's output $G'$ as a labelled simple graph. We check three
+properties: (a) $G'$ is a triangulation (no multi-edge survived the
+Phase~2 flips), (b) the parity subgraphs $E_{G, S}(G')$ and
+$O_{G, S}(G')$ are both bipartite, and (c) the iso-class of $G'$.
+Aggregating over all $(G, S, \text{branch-choices})$ triples yields the
+set of iso-classes attainable as algorithm outputs satisfying (a)+(b);
+we compare this set against the minimum-degree-$4$ iso-classes at each
+$n$.
+
+\begin{observation}
+\label{obs:md4-simple-resolution}
+For every $n \in \{6, 7, 8, 9, 10, 11\}$, every plane triangulation
+iso-class on $n$ vertices with minimum degree at least $4$ is a simple
+level resolution of some plane triangulation on $n$ vertices. Concretely,
+the counts of minimum-degree-$4$ iso-classes — $1, 1, 2, 5, 12, 34$ at
+$n = 6, \ldots, 11$ — are all reached by the algorithm with bipartite
+parity subgraphs (Definition~\ref{def:simple-level-resolution}).
+\end{observation}
+
+\begin{conjecture}[Simple-resolution $\mathrm{md}_4$ surjectivity]
+\label{conj:simple-md4}
+For every $n \geq 6$, every minimum-degree-$4$ plane triangulation on $n$
+vertices is a simple level resolution of some plane triangulation on $n$
+vertices.
+\end{conjecture}
+
+The minimum-degree-$4$ restriction in Conjecture~\ref{conj:simple-md4} is
+necessary: at $n = 8$, the unique iso-class with three degree-$3$
+vertices is not reachable by the algorithm; at $n = 10$, two further
+iso-classes with four degree-$3$ vertices and high-degree hubs fail to
+appear among algorithm outputs.
+
 \begin{question}
 \label{q:terminate-all-n}
-Does Observation~\ref{obs:terminate} hold for all $n$? Equivalently, does
-the count of tricky-everywhere odd simple cycles strictly decrease on every
-Step~2(c) flip, in every plane triangulation?
+Does Phase~1 terminate for all $(G, S)$? Equivalently, is there an
+explicit monovariant on $L_k$'s face structure that strictly decreases
+on every Phase~1 flip?
 \end{question}
 
 \section{Discussion and open questions}
@@ -493,11 +572,22 @@ The computational results suggest the following:
 \end{enumerate}
 
 The algorithm of Section~\ref{sec:flip-algorithm} is the candidate
-constructive answer: cross-level flips dispose of every odd cycle of $L_k$
-that admits one, and the facial-depth-guided intra-level flip loop attacks
-the residual tricky-everywhere cycles. Observation~\ref{obs:terminate}
-records that the loop terminates on all tested $(G, S, k)$ at $n \leq 11$;
-Question~\ref{q:terminate-all-n} asks whether termination holds for all $n$.
+constructive answer. Phase~1 iteratively flips the shared edge between
+the deepest interior odd face and its lowest-depth neighbor, pushing the
+residual odd-face structure toward the seed set $\mathcal{B}$ at
+depth~$0$, with optional even-face restructuring moves along the way;
+Phase~2 disposes of the remaining outer-incident odd cycles by flipping
+an outer-face edge each (and optionally an even outer-incident face),
+accepting a multigraph if the apex edge already exists.
+Observation~\ref{obs:empirical-lk-bipartite} records that the algorithm
+terminates and succeeds at the level-bipartiteness layer on all $29640$
+tested $(G, S, k)$ triples at $n \in \{9, 10, 11\}$.
+Observation~\ref{obs:md4-simple-resolution} records that every
+minimum-degree-$4$ iso-class on $n \leq 11$ vertices is reached as a
+simple level resolution; Conjecture~\ref{conj:simple-md4} extends this
+to all $n$.
+Question~\ref{q:terminate-all-n} asks whether Phase~1 terminates in
+general.
 
 \section{Implementation}
 \label{sec:impl}