This code does not submit the full 3SAT formula as a single physical object. Instead, it uses a toy 3SAT formula to generate a small, repeatable set of assignment-labeled frequency trials. The purpose is not to demonstrate computational advantage, but to test whether the LC-CJM setup can produce reproducible alignment-like responses under controlled symbolic trial conditions.

 

/*

  CJM Manifesto 1/3

  LC Structural Alignment Pilot v0.05-beta

 

  Arduino Uno R3 Serial-Controlled Timer1 Output

 

  Output:

    D9 / OC1A

 

  Serial command format:

    F50000

    F50300

    F49700

 

  Meaning:

    Set output frequency in Hz.

 

  Important:

    This is for Arduino Uno / ATmega328P at 16 MHz.

*/

 

const int outputPin = 9;

 

void setupTimer1(float frequencyHz) {

  if (frequencyHz < 1000) frequencyHz = 1000;

  if (frequencyHz > 200000) frequencyHz = 200000;

 

  // Fast PWM mode 14, TOP = ICR1

  // Frequency = 16 MHz / (prescaler * (1 + ICR1))

  // Prescaler = 1

  unsigned long top = (unsigned long)(16000000.0 / frequencyHz) - 1;

 

  if (top < 1) top = 1;

  if (top > 65535) top = 65535;

 

  noInterrupts();

 

  TCCR1A = 0;

  TCCR1B = 0;

  TCNT1 = 0;

 

  ICR1 = top;

  OCR1A = top / 2; // 50% duty cycle

 

  // Non-inverting output on OC1A / D9

  TCCR1A |= (1 << COM1A1);

 

  // Fast PWM mode 14

  TCCR1A |= (1 << WGM11);

  TCCR1B |= (1 << WGM13) | (1 << WGM12);

 

  // Prescaler = 1

  TCCR1B |= (1 << CS10);

 

  interrupts();

}

 

void setup() {

  pinMode(outputPin, OUTPUT);

  Serial.begin(115200);

 

  setupTimer1(50000.0);

 

  Serial.println("CJM-LC READY");

  Serial.println("Send command like F50000");

}

 

void loop() {

  if (Serial.available()) {

    String cmd = Serial.readStringUntil('\n');

    cmd.trim();

 

    if (cmd.length() > 1 && cmd.charAt(0) == 'F') {

      float freq = cmd.substring(1).toFloat();

 

      setupTimer1(freq);

 

      Serial.print("OK ");

      Serial.println(freq, 2);

    } else {

      Serial.println("ERR");

    }

  }

}

 

 

pip install pyserial

 

Beginner note: pip is Python’s package installer. The command pip install pyserial downloads and installs the serial communication library needed by this experiment. Without pyserial, the Python script can still be read, but it will not be able to connect to the Arduino over USB.

 

 

"""

CJM Manifesto 1/3

LC Structural Alignment Pilot v0.05-beta

 

Simple 3SAT USB Trial Runner

 

Purpose:

    1. Detect Arduino-compatible serial port.

    2. Send trial frequencies near LC resonance.

    3. Export CSV submission template.

 

Important:

    Upload the provided Arduino sketch first.

    This Python script does not read oscilloscope data.

    Participants fill observation fields after checking CH1/CH2 manually.

"""

 

import csv

import math

import time

from itertools import product

 

import serial

from serial.tools import list_ports

 

 

# ------------------------------------------------------------

# LC setup

# ------------------------------------------------------------

L_HENRY = 100e-6

C_FARAD = 0.1e-6

F0_HZ = 1.0 / (2.0 * math.pi * math.sqrt(L_HENRY * C_FARAD))

 

 

# ------------------------------------------------------------

# Toy 3SAT formula

# ------------------------------------------------------------

CLAUSES = [

    (+1, +2, -3),

    (-1, +2, +3),

    (+1, -2, +3),

]

 

 

def eval_literal(literal, assignment):

    var = abs(literal)

    value = assignment[var]

    return value if literal > 0 else not value

 

 

def eval_clause(clause, assignment):

    return any(eval_literal(lit, assignment) for lit in clause)

 

 

def eval_formula(clauses, assignment):

    results = [eval_clause(clause, assignment) for clause in clauses]

    satisfied_count = sum(results)

    sat_ratio = satisfied_count / len(clauses)

    is_satisfying = all(results)

    return is_satisfying, sat_ratio

 

 

def assignment_to_frequency(assignment):

    """

    Convert assignment into a small frequency offset around LC resonance.

 

    This is only a repeatable trial schedule.

    It is not a proof mapping.

    """

    bits = [assignment[1], assignment[2], assignment[3]]

    code = sum((1 << i) for i, bit in enumerate(bits) if bit)

 

    # 8 assignments -> offsets from -350 Hz to +350 Hz

    offset_hz = (code - 3.5) * 100.0

 

    return F0_HZ + offset_hz

 

 

# ------------------------------------------------------------

# Serial detection

# ------------------------------------------------------------

def find_arduino_port():

    ports = list(list_ports.comports())

 

    if not ports:

        raise RuntimeError("No serial ports found. Is the Arduino connected by USB?")

 

    keywords = [

        "arduino",

        "uno",

        "ch340",

        "wch",

        "usb serial",

        "usb-serial",

        "cp210",

    ]

 

    for port in ports:

        desc = f"{port.description} {port.manufacturer or ''}".lower()

        if any(k in desc for k in keywords):

            return port.device

 

    # Fallback: if only one serial device exists, use it.

    if len(ports) == 1:

        return ports[0].device

 

    print("Multiple serial ports found:")

    for i, port in enumerate(ports, start=1):

        print(f"{i}. {port.device} | {port.description}")

 

    choice = int(input("Select port number: "))

    return ports[choice - 1].device

 

 

def connect_arduino(port, baudrate=115200):

    ser = serial.Serial(port, baudrate=baudrate, timeout=2)

 

    # Arduino resets when serial opens.

    time.sleep(2.5)

 

    # Read any startup text.

    while ser.in_waiting:

        line = ser.readline().decode(errors="ignore").strip()

        if line:

            print("Arduino:", line)

 

    return ser

 

 

def send_frequency(ser, frequency_hz):

    cmd = f"F{frequency_hz:.2f}\n"

    ser.write(cmd.encode("utf-8"))

    ser.flush()

 

    reply = ser.readline().decode(errors="ignore").strip()

    return reply

 

 

# ------------------------------------------------------------

# Main

# ------------------------------------------------------------

def main():

    output_file = "cjm_3sat_lc_trials_usb.csv"

 

    print("CJM Manifesto 1/3 | LC Structural Alignment Pilot v0.05-beta")

    print(f"Nominal LC resonance: {F0_HZ:.2f} Hz")

    print()

 

    port = find_arduino_port()

    print(f"Detected serial port: {port}")

 

    ser = connect_arduino(port)

 

    rows = []

 

    try:

        for trial_id, values in enumerate(product([False, True], repeat=3), start=1):

            assignment = {

                1: values[0],

                2: values[1],

                3: values[2],

            }

 

            is_satisfying, sat_ratio = eval_formula(CLAUSES, assignment)

            target_frequency = assignment_to_frequency(assignment)

            assignment_bits = "".join("1" if assignment[i] else "0" for i in [1, 2, 3])

 

            print()

            print(f"Trial {trial_id}")

            print(f"Assignment x1x2x3: {assignment_bits}")

            print(f"Target frequency: {target_frequency:.2f} Hz")

 

            reply = send_frequency(ser, target_frequency)

            print(f"Arduino reply: {reply}")

 

            input("Observe oscilloscope CH1/CH2, save screenshot if needed, then press Enter...")

 

            rows.append({

                "trial_id": trial_id,

                "assignment_bits_x1x2x3": assignment_bits,

                "x1": int(assignment[1]),

                "x2": int(assignment[2]),

                "x3": int(assignment[3]),

                "assignment_satisfies_toy_3sat": int(is_satisfying),

                "assignment_clause_satisfaction_ratio": round(sat_ratio, 4),

                "lc_L_uH": 100,

                "lc_C_uF": 0.1,

                "nominal_f0_hz": round(F0_HZ, 2),

                "target_frequency_hz": round(target_frequency, 2),

                "serial_port": port,

                "arduino_reply": reply,

 

                # Participant-filled fields

               "observed_response": "", # alignment_observed / not_observed / inconclusive / possible_artifact

                "alignment_strength_0_to_5": "",

                "ch1_setting": "",

                "ch2_setting": "",

                "timebase": "",

                "scope_model": "",

                "screenshot_filename": "",

                "csv_waveform_filename": "",

                "notes": "",

            })

 

    finally:

        ser.close()

 

    with open(output_file, "w", newline="", encoding="utf-8") as f:

        writer = csv.DictWriter(f, fieldnames=rows[0].keys())

        writer.writeheader()

        writer.writerows(rows)

 

    print()

    print(f"CSV generated: {output_file}")

    print("Fill observation fields and submit the completed CSV with screenshots or waveform files.")

 

 

if __name__ == "__main__":

    main()

 

 

This Python script is intended to be used together with the accompanying Arduino serial-control sketch. Before running the Python script, participants must first upload the Arduino sketch to an Arduino Uno R3 or compatible microcontroller board. The Arduino sketch enables the board to receive frequency commands over the USB serial connection and generate a corresponding output signal on the selected PWM/timer output pin.

After the Arduino is connected to the computer by USB, the Python script attempts to detect the correct serial port automatically. If multiple serial devices are connected, the script may ask the participant to select the appropriate port manually. Once the connection is established, the script generates a small set of trial conditions derived from a toy 3SAT instance. These trial conditions are not intended to prove or solve 3SAT physically. They are used only as a simple, repeatable structural input schedule for testing the LC alignment pilot.

For each trial, the Python script sends a target frequency near the nominal LC resonance frequency of the 100 µH and 0.1 µF circuit pair. The Arduino then updates its timer output so that the participant can observe the LC response on the oscilloscope. The recommended setup is to connect CH1 to the LC node or across the LC section, connect CH2 to the input signal, and trigger the oscilloscope on CH2. After each frequency is sent, the script pauses and waits for the participant to inspect the oscilloscope display, save a screenshot if desired, and optionally export waveform data from the oscilloscope.

The script does not automatically read oscilloscope data. It only controls the Arduino trial sequence and creates a CSV file for submission. Participants should manually record their observations in the generated CSV file, including whether alignment-like behavior was observed, not observed, or uncertain. When possible, participants should also attach oscilloscope screenshots or raw waveform CSV files and reference those filenames in the submission CSV.

The purpose of this script is to make the pilot experiment repeatable and easy to document. It provides a common trial structure, common target frequencies, and a common data format so that results from different participants and different experimental environments can later be compared. Positive, negative, and uncertain observations are all valuable, provided that the circuit conditions, measurement settings, and data files are clearly recorded.

 

 

 

 

 

 

REPLICATION REPORT FORM

CJM Manifesto 1/3  •  LC Structural Alignment Pilot v0.05-beta
Use this form to submit a positive, negative, uncertain, or artifact-related replication result.