Edge

This program generates a random four-node binary graph and analyzes the symmetry properties of its edges. It represents each node as either “I” or “O” (binary state), performs up to 50 single-bit-flip transitions to build a sequence of 16 unique states, then pairs consecutive states into 16 directed edges stored in the string array M$(16,8). The core analysis at lines 760–834 checks all pairs of edges against six conditions — each testing whether two positions are conserved while the remaining two differ — to count “symmetrical” edges, printing both the symmetrical count and its complement (48 minus the count) as the asymmetrical total.

---

Program Analysis

Program Structure

The program divides into four logical phases:

1. Initialization (lines 2–35): Seeds the random number generator with user input, then declares all arrays.
2. State generation (lines 40–120): Creates a random 4-bit binary string of “I”/”O” characters, prints it, and stores it as N$(1).
3. Transition walk (lines 200–710): Randomly flips one of the four bits at a time. Each new state is checked against all previously seen states; if unseen it is added to the list N$. The loop repeats until 50 flips have been attempted (H(1)>50), aiming to collect up to 16 distinct states.
4. Edge analysis (lines 750–880): Pairs consecutive states (wrapping around) into 8-character strings in M$(16,8), then exhaustively checks all 16×16 edge pairs for six symmetry conditions.

Data Representation

Each node state is a 4-character string over the alphabet {“I”,”O”}, representing a 4-bit binary value. Transitions are single-character (Hamming distance 1) flips. The 16 possible 4-bit states form a hypercube graph; the program attempts to walk this hypercube and collect its nodes. Consecutive state pairs are concatenated into 8-character strings in M$(16,8), so M$(I,1..4) is the source node and M$(I,5..8) is the target node of each edge.

Array Usage

Array	Dimensions	Purpose
A$(6,1)	6 strings of length 1	Current node’s individual bit characters
N$(16,4)	16 strings of length 4	Sequence of distinct 4-bit states visited
M$(16,8)	16 strings of length 8	Edge pairs (source+target concatenated)
H(1)	scalar-as-array	Flip attempt counter (limit 50)
Q(1)	scalar-as-array	Count of distinct states found
R(1)	scalar-as-array	Used as upper bound for duplicate-check loop
E(1)	scalar-as-array	Symmetrical edge count accumulator
D$(1,1), C$(1,1)	1-char string	Temporary storage for bit flip logic

Scalars Stored as Single-Element Arrays

Several counters (H(1), Q(1), R(1), E(1)) are implemented as one-element numeric arrays rather than plain variables. This is not strictly necessary but is a common idiom when a programmer wants to ensure a value initializes to zero reliably via DIM, or simply out of habit.

Symmetry Detection Logic

Lines 764–814 implement six symmetry conditions, each checking a pair of edges M$(C) and M$(H). Each condition selects two of the four bit positions that are conserved (same value in source and target, and matching between the two edges), while requiring that at least one of the other two positions differs between the edges. The six conditions correspond to choosing 2 conserved positions from 4, i.e., C(4,2)=6 combinations:

• Line 764: positions 1 and 2 conserved
• Line 774: positions 1 and 3 conserved
• Line 784: positions 2 and 3 conserved
• Line 794: positions 2 and 4 conserved
• Line 804: positions 3 and 4 conserved
• Line 814: positions 1 and 4 conserved

For each matching condition, E(1) is incremented by 1. The maximum theoretical count is therefore 6×16×16 = 1536, but the program reports 48 - E(1) as asymmetrical edges, implying an expected meaningful range near 48 total edges (6 conditions × 8 edges) — suggesting a specific graph-theoretic context where this bound is meaningful.

Duplicate-State Detection (Lines 600–710)

After generating a candidate new state B$, the program loops from T=1 TO R(1), comparing B$ against all previously stored states in N$. If a match is found (GOTO 700), the flip is reversed (A$(W)=D$(1)) and a new flip is attempted. If no match is found (GOTO 370), the new state is accepted, printed, and appended to N$. The variable R(1) tracks how many states have been stored for the search bound, while Q(1) tracks the insertion index — these are incremented separately, which is slightly redundant but not a bug since they effectively track the same count.

Notable Anomalies and Limitations

• The transition loop is capped at 50 flip attempts (H(1)>50), which may terminate before all 16 states are found. If fewer than 16 states are collected, N$ rows beyond Q(1) remain as empty strings, potentially corrupting the edge analysis.
• DIM C$(1,1) is declared inside the loop at line 205, re-dimensioning on every iteration. This is legal but wasteful, resetting the array each pass.
• Lines 890–910 (CLEAR, SAVE, RUN) are unreachable due to the STOP at line 880.
• Only positions 1–4 of A$() are used, though A$(6,1) is dimensioned for 6 elements — two slots go unused.
• The FOR Y=1 TO 4 loop (lines 40–75) only initializes the first four elements, consistent with the 4-bit design.