Why Did Arizona Challenge the 2020 Presidential Election?

[DISCLAIMER: I am not affiliated with any political party or organization. I am an American.]

[DISCLAIMER: This blog post is not alleging that any fraud occurred in the 2020 U.S. election.]

2020 was my 13th Presidential election. As a devout student of humanity, I found it to be a fascinating event. I also found out, once again, how little people know about how elections are conducted in this country. For example, many people don't understand that every state has different laws regarding the election. They assume that the way they have always voted is the same for everyone else. They also don't seem to understand that only their state legislature can make changes to the election laws when voting for President or Vice-President. Not their Secretary of State. Not their Governor. Not the Congress. Not even the Supreme Court of the United States. Only their state legislature.

How do I know this? Because the U.S. Constitution specifically says so:

Article II Section 1 Paragraph 2: Each State shall appoint, in such Manner as the Legislature thereof may direct, a Number of Electors, equal to the whole Number of Senators and Representatives to which the State may be entitled in the Congress[....]

Why is each state different? Why isn't there just one system for everyone? Many people don't seem to understand that we are not a single country under Washington, D.C., rule, but a Union of individual states that are allowed to do their own thing as long as it doesn't violate the U.S. Constitution. A Constitution which, by the way, was designed to limit the powers of a central government so that the citizens had control over their own states.

There were a number of anomalies in the 2020 election. While I have researched more than a dozen states, I will use Arizona as an example of where anomalies occurred, since it's the only state serious enough to try and learn exactly what happened. It's also the easiest to show where the problems occurred. Bear in mind that I'm not interested in the outcome, I'm only interested in the process itself.

In Arizona, you can start by reading Title 16 of the Arizona Revised Statutes.

16-120. Eligibility to vote

A. An elector shall not vote in an election called pursuant to the laws of this state unless the elector has been registered to vote as a resident within the boundaries or the proposed boundaries of the election district for which the election is being conducted and the registration has been received by the county recorder or the recorder's designee pursuant to section 16-134 before midnight of the twenty-ninth day preceding the date of the election.

B. If the twenty-ninth day preceding the date of the election falls on a Saturday, Sunday or other legal holiday, voter registrations that are received on the next business day immediately following the Saturday, Sunday or other legal holiday are deemed to have been timely received for purposes of voting in that election.

By law, enacted by the state legislature, you cannot register to vote within 29 days of the election. In 2020, that date was October 5th. However, two outreach groups, Mi Familia Vota and Arizona Coalition for Change, sued Arizona in court to have the date extended. On October 5th, U.S. District Judge Steven Logan heard their plea and, as a result, unconstitutionally extended the registration period to October 23rd. Instead of refusing the court order, the Secretary of State immediately announced the extended registration period. Registrations continued while the judgment was being appealed. However, on Oct. 13, the 9th Circuit Court put Logan’s order on hold, effective Oct. 15. The end result was that the registration period was unconstitutionally extended 10 days without the approval of the legislature. Legally, the votes of anyone who registered late should be set aside and not counted. We have deadlines for everything and the 29 day rule has been on the books since at least 2013. If you're late for the bus, they don't wait for you.

This was presented to the Congress by the Arizona Representatives and Senators at numerous points during the run-up of counting the electoral votes. On January 6, 2021, the electoral count of the votes from Arizona was legally contested. The counting was stopped by Vice-President Mike Pence and the Congress recessed to their separate chambers for discussion of the Arizona votes.

This explanation was given in the House discussion [see page H80 of the Congressional Record for 1/6/2021]:

Andy Biggs: "During that window, more than 32,000 voters registered in Maricopa County alone. Here are copies of those voter registration records. In going around the deadline set by the legislature, the court ignored the Arizona legislature’s obligation and right to direct the manner of choosing Presidential electors as set forth in Article II, Section 1. As a consequence of that judicial usurpation, more than 32,000 people were allowed to unlawfully cast ballots in Arizona’s Presidential election in 2020. The Arizona legislature seeks an independent audit of the election. The Governor refuses now to call them into a special session. The Maricopa County Board of Supervisors has refused to comply with legislative subpoenas. In Arizona, the people who control the evidence related to the election have done everything possible to prevent an independent audit directed by the legislature."

With a margin of only 10,457 votes, it is reasonable to question the legal outcome of this election and ask that an alternate slate of electors be entered into the record until an audit can be held. However, before the issue could be discussed and properly resolved, it was interrupted by the storming of the Capitol Building at 2:29 p.m. (page H85 of the CR). When the Congress reconvened at 9:02 p.m., the invasion was the primary topic at hand and began with these words from Nancy Pelosi:

Today, a shameful assault was made on our democracy. It cannot, however, deter us from our responsibility to validate the election of Joe Biden and KAMALA HARRIS. For that reason, Congress has returned to the Capitol.

The electoral votes from Arizona were then counted for Biden and Harris without having finished the two-hour discussion that was allotted by law. The legal halt to counting the ballots was never completed, but had been interrupted by the intrusion of the protesters. The action of then Secretary of State, Katie Hobbs, by caving in to the unconstitutional demands of a circuit court judge, technically became the singular event that eventually precipitated what happened on January 6th, 2021. If only she had kept her oath to uphold the Constitution, and had never illegally extended the registration deadline, the outcome might well have been totally different.

More reading for those who are interested:

https://www.scotusblog.com/election-litigation/mi-familia-vota-v-hobbs/

https://www.azcentral.com/story/news/politics/elections/2020/10/05/arizona-voter-registration-deadline-extended-oct-23-judge-rules/3633974001/

https://web.archive.org/web/20201007023316/https://azsos.gov/elections/voting-election/register-vote-or-update-your-current-voter-information

The Knight's Tour

Nearly forty years ago, a friend of mine challenged me to write a program to solve The Knight's Tour problem. Simply put: can a knight move around the chess board landing on every space only once?

At the time, I was working with a WYSE-386 computer with 2MB of memory and 40MB of hard drive space. After coming up with a suitable algorithm, I implemented it in 16-bit assembler. Running on a single CPU at 16MHz, It took 29 days for it to find a solution.

Since then, I have periodically revisited this using a number of different approaches. The most recent iteration of my algorithm took another turn. Instead of using a two-dimensional array for the board, I linearized it into a single vector which provides substantial computational advantages over my previous efforts.

I start by defining the board to virtually look like this:

By traversing the bottom row (left to right) and then the next row, etc., I implement this with a one-dimensional array of 144 values ("board[144]"). Moving up or down or left or right is simply a matter of adding the indexed offset to the current location.

The eight possible moves with 0 through 7 (and their offsets):

These moves are stored in an eight-element array of offsets ("dirloc[8]") from the current location. Given the direction (0-7), adding the value of the ith element gives the new location. If the new location is not zero, then it is an invalid move.

For each location visited on the board, the number of moves up until then is stored. At each location, the moves array is indexed by the current direction. When a new move cannot be found (i.e., moves[cur] = 8), the move is retracted by subtracting the appropriate offset in the dirloc array. The direction is incremented to the next trial and repeated again until it equals eight.

When 63 moves have been made, the program stops and prints out the board. Here is the basic C code to make it happen:

// knight1.c (Knight's Tour)

#include <stdio.h>

int cur,loc,curloc,i,j;
int dirloc[] = { -25,-14,10,23,25,14,-10,-23 };
int moves[64];
int board[144];

void init(void)
{
  cur = 0;
  curloc = 32;
  for (i = 0; i < 64; i++)
  {
    moves[i] = 0;
  }
  for (i = 0; i < 144; i++)
  {
    board[i] = 1;
  }
  for (i = 2; i < 10; i++)
  {
    for (j = 2; j < 10; j++)
    {
      board[i + j * 12] = 0;
    }
  }
  board[curloc] = 1;
}

void print_board(void)
{
  for(i=110;i>25;i-=12)
  {
    for(j=0;j<8;j++)
    {
      printf("\t%d",board[i+j]);
    }
    printf("\n\n");
  }
}

int main()
{
  init();
  while (cur < 63)
  {
    if (moves[cur] == 8)
    {
      if (cur == 0)
      {
        break; // exit if no solution is found
      }
      moves[cur] = 0;
      board[curloc] = 0;
      cur--;
      curloc -= dirloc[moves[cur]];
      moves[cur]++;
    }
    else
    {
      loc = curloc + dirloc[moves[cur]];
      if (board[loc] == 0)
      {
        board[loc] = cur + 2;
        curloc = loc;
        cur++;
      }
      else
      {
        moves[cur]++;
      }
    }
  }
  if(cur == 63)
  {
    print_board();
    return 0;
  }
  return 1;
}

First solution found by the example code:

There are many ways to optimize code to find a solution using a more efficient algorithm than the Brute Force one outlined here. However, my goal was to find a way to make the exhaustive approach as efficient as possible.

This same embedded algorithm, running for twenty-nine days on a Raspberry Pi , produced over 785,000 unique directional solutions. That's an amazing improvement over my 386. 😄

* * * [ ADDED 4/17/2023 ] * * *

I asked ChatGPT for a solution: "Write a C program that provides a solution to the Knight's Tour chess problem." This is the result:

#include <stdio.h>
#include <stdbool.h>

#define N 8 // Size of the chessboard

int moveX[8] = {2, 1, -1, -2, -2, -1, 1, 2};
int moveY[8] = {1, 2, 2, 1, -1, -2, -2, -1};

bool isSafe(int x, int y, int sol[N][N]) {
    return (x >= 0 && x < N && y >= 0 && y < N && sol[x][y] == -1);
}

void printSolution(int sol[N][N]) {
    for (int x = 0; x < N; x++) {
        for (int y = 0; y < N; y++) {
            printf("%2d ", sol[x][y]);
        }
        printf("\n");
    }
}

bool solveKnightTour(int x, int y, int moveCount, int sol[N][N]) {
    if (moveCount == N * N) {
        return true; // All squares visited
    }

    for (int i = 0; i < 8; i++) {
        int nextX = x + moveX[i];
        int nextY = y + moveY[i];

        if (isSafe(nextX, nextY, sol)) {
            sol[nextX][nextY] = moveCount;
            if (solveKnightTour(nextX, nextY, moveCount + 1, sol)) {
                return true; // Move leads to a solution
            } else {
                sol[nextX][nextY] = -1; // Backtrack
            }
        }
    }

    return false; // No solution found
}

int main() {
    int sol[N][N]; // Solution matrix

    // Initialize solution matrix
    for (int x = 0; x < N; x++) {
        for (int y = 0; y < N; y++) {
            sol[x][y] = -1; // Mark all squares as unvisited
        }
    }

    // Starting position
    int startX = 0;
    int startY = 0;
    sol[startX][startY] = 0; // Mark starting position as visited

    if (solveKnightTour(startX, startY, 1, sol)) {
        printf("Knight's Tour solution:\n");
        printSolution(sol);
    } else {
        printf("No solution found.\n");
    }

    return 0;
}