# Some ideas on AI and ML.

I do strange and interesting things with python...

Generally with qiskit, numpy, scipy, etc.. I really like to use matplotlib for visualizations here and there.

I research the intersections of quantum computing and artifical intelligence. Riding the dimensional barriers with my code, and inferring probability.

I have been programming since mid 1980. BASIC, 6502 assembly, on and on. Until it all became a blurr and I find myself writing programs in C, adding processor specific assembly, maybe throwing in some other stuff here and there for added randomness. Made my first OS, this one for the Apple ][gs in the 80s. It was a horrible kludge of assembler, too many subroutines. I'm amazed it worked with all the cycles it used unnecessarily.

After a while, all the languages tend to blend together. Syntaxes become similar, you index man pages in your mind. "Oh, I know where to find my notes on that.." And so on.

A side effect of coding a lot is that you end up having dreams about it. Trying to find your keyboard in your sleep, strange and awkward conversations that you don't remember in the middle of the night, restlessness.. And then suddenly waking up and just having to write that bit of code because it's the solution to a problem you've been thinking about for the last day or so.

Or even weirder, you wake up and have to write this code because it came to you in a dream...

You run the code and it does some weird stuff. But, then it becomes relevant to the thing you've been working on for years, and managed to make some strides in recently.

Strange things are afoot at the Circle K...

Lately, I've been trying to work towards figuring out P=NP.

Some success there, but, if you're into python like I am, you want to do more.

qi[4] = -N1_x1 + N3_x1

qi[2] = -N1_t + N2_t

qi[1] = -N1_x1 + N2_x1

qi[10] = qi[2] * qi[7] - qi[1] * qi[8]

qi[11] = -(qi[2] * qi[4]) + qi[1] * qi[8]

qi[18] = qi[0] * qi[9] + qi[3] * qi[10] * qi[6]

qi[19] = 1 / qi[18]

qi[12] = qi[5] * qi[6] - qi[3] * qi[8]

qi[21] = qi[12] * qi[19]

qi[15] = -(qi[4] * qi[6]) + qi[3] * qi[7]

qi[22] = qi[15] * qi[19]

qi[23] = qi[10] * qi[19]

qi[13] = -(qi[2] * qi[6]) + qi[0] * qi[8]

qi[24] = qi[13] * qi[19]

qi[16] = qi[1] * qi[6] - qi[0] * qi[7]

qi[25] = qi[16] * qi[19]

qi[26] = qi[11] * qi[19]

qi[14] = qi[2] * qi[3] - qi[0] * qi[5]

qi[27] = qi[14] * qi[19]

qi[17] = -(qi[1] * qi[3]) + qi[0] * qi[4]

qi[28] = qi[17] * qi[19]

qi[29] = -qi[20] - qi[23] - qi[26]

qi[30] = -qi[21] - qi[24] - qi[27]

qi[31] = -qi[22] - qi[25] - qi[28]

I had some super-cynical stuff here before.

Life's too short to be negative, only your beer should be bitter.

Some random P=NP exploratory code:

import heapq

class Node:

"""A node class for A* Pathfinding"""

def __init__(self, parent=None, position=None):

self.parent = parent

self.position = position

self.g = 0

self.h = 0

self.f = 0

def __eq__(self, other):

return self.position == other.position

def __lt__(self, other):

return self.f < other.f

def heuristic(node, goal):

"""Calculate the heuristic (straight-line) distance to the goal"""

return ((node.position[0] - goal.position[0]) ** 2) + ((node.position[1] - goal.position[1]) ** 2)

def astar(maze, start, end):

"""Returns a list of tuples as a path from the given start to the given end in the given maze"""

# Create start and end node

start_node = Node(None, start)

end_node = Node(None, end)

# Initialize both open and closed list

open_list = []

closed_list = []

# Heapify the open_list and add the start node

heapq.heapify(open_list)

heapq.heappush(open_list, (start_node.f, start_node))

# Loop until you find the end

while len(open_list) > 0:

# Get the current node

current_node = heapq.heappop(open_list)[1]

closed_list.append(current_node)

# Found the goal

if current_node == end_node:

path = []

current = current_node

while current is not None:

path.append(current.position)

current = current.parent

return path[::-1] # Return reversed path

# Generate children

children = []

for new_position in [(0, -1), (0, 1), (-1, 0), (1, 0)]: # Adjacent squares

# Get node position

node_position = (current_node.position[0] + new_position[0], current_node.position[1] + new_position[1])

# Make sure within range

if node_position[0] > (len(maze) - 1) or node_position[0] < 0 or node_position[1] > (len(maze[len(maze)-1]) -1) or node_position[1] < 0:

continue

# Make sure walkable terrain

if maze[node_position[0]][node_position[1]] != 0:

continue

# Create new node

new_node = Node(current_node, node_position)

# Append

children.append(new_node)

# Loop through children

for child in children:

# Child is on the closed list

if child in closed_list:

continue

# Create the f, g, and h values

child.g = current_node.g + 1

child.h = heuristic(child, end_node)

child.f = child.g + child.h

# Child is already in the open list

for open_node in open_list:

if child == open_node[1] and child.g > open_node[1].g:

continue

# Add the child to the open list

heapq.heappush(open_list, (child.f, child))

maze = [[0, 0, 0, 0, 0],

[1, 1, 1, 1, 0],

[0, 0, 1, 0, 0],

[0, 1, 1, 1, 0],

[0, 0, 0, 0, 0]]

start = (0, 0)

end = (4, 4)

path = astar(maze, start, end)

print(path)