logos/tools/test_logic_gates.py

#!/usr/bin/env python
"""
LOGIC GATES TEST: OR (LCM), AND (GCD), NOT (Steering)

The Complete Tensor Logic Triad:
- OR  = Superposition (LCM) - Creates unified manifold containing both
- AND = Intersection (GCD) - Finds common factor between both
- NOT = Navigation (Steering) - Selects path based on pattern match
"""
from logos.mtl.interpreter import MTLInterpreter

mtl = MTLInterpreter()

print('=' * 60)
print('   LOGOS TENSOR LOGIC GATES: OR, AND, NOT')
print('=' * 60)

# === OR GATE (LCM) ===
print('\n[OR GATE] Superposition / Unified Manifold (LCM)')
print('-' * 40)

# O(2, 3) = 6 ("Red OR Blue = Purple")
result = mtl.execute('(or [2] [3])')
print(f'   (or [2] [3]) = {result}  (Mechanism OR Result = Flip)')
assert result == 6, f'Expected 6, got {result}'
print('   ✅ PASS')

# O(4, 6) = 12 ("Previous OR Flip = ?")
result = mtl.execute('(or [4] [6])')
print(f'   (or [4] [6]) = {result}  (LCM of 4,6 = 12 = Thought)')
assert result == 12, f'Expected 12, got {result}'
print('   ✅ PASS')

# O(6, 10) = 30 (All three: Mechanism, Result, Choice)
result = mtl.execute('(or [6] [10])')
print(f'   (or [6] [10]) = {result}  (Flip OR Around = 2*3*5 = 30)')
assert result == 30, f'Expected 30, got {result}'
print('   ✅ PASS')

# === AND GATE (GCD) ===
print('\n[AND GATE] Intersection / Common Factor (GCD)')
print('-' * 40)

# A(6, 10) = 2 ("What do Flip and Around share? Mechanism.")
result = mtl.execute('(and [6] [10])')
print(f'   (and [6] [10]) = {result}  (Flip AND Around = Mechanism)')
assert result == 2, f'Expected 2, got {result}'
print('   ✅ PASS')

# A(12, 18) = 6
result = mtl.execute('(and [12] [18])')
print(f'   (and [12] [18]) = {result}  (Thought AND 18 = Flip)')
assert result == 6, f'Expected 6, got {result}'
print('   ✅ PASS')

# A(7, 14) = 7 (Persist)
result = mtl.execute('(and [7] [14])')
print(f'   (and [7] [14]) = {result}  (Persist AND Hold = Persist)')
assert result == 7, f'Expected 7, got {result}'
print('   ✅ PASS')

# === NOT GATE (Steering) ===
print('\n[NOT GATE] Navigation / Structural Steering')
print('-' * 40)

# N(A)[A,B] -> B
result = mtl.execute('(not [2] [2] [3])')
print(f'   (not [2] [2] [3]) = {result}  (If Mechanism, go to Result)')
assert result == 3, f'Expected 3, got {result}'
print('   ✅ PASS')

# N(A)[X,B] -> X (No match)
result = mtl.execute('(not [2] [5] [3])')
print(f'   (not [2] [5] [3]) = {result}  (No match, stay at Choice)')
assert result == 5, f'Expected 5, got {result}'
print('   ✅ PASS')

# === COMBINED LOGIC ===
print('\n[COMBINED] Complex Tensor Navigation')
print('-' * 40)

# Create a superposition, then navigate it
# Step 1: O(2,3) = 6 (Create unified space)
# Step 2: N(6)[6, 42] = 42 (If key=6 matches first arg=6, return second=42)
unified = mtl.execute('(or [2] [3])')
print(f'   Unified = (or [2] [3]) = {unified}')

# Now use unified (which is 6) as the key to navigate
# (not 6 6 42) -> Key matches first, return second -> 42
result = mtl.execute(f'(not {unified} {unified} 42)')
print(f'   (not {unified} {unified} 42) = {result}  (Navigate to Deep Storage)')
assert result == 42, f'Expected 42, got {result}'
print('   ✅ PASS')

# === SUMMARY ===
print('\n' + '=' * 60)
print('✅ ALL LOGIC GATES VERIFIED')
print('=' * 60)
print('''
The Complete Tensor Logic Triad:

  | Gate | Math       | LOGOS Meaning           |
  |------|------------|-------------------------|
  | OR   | LCM(A,B)   | Superposition/Unify     |
  | AND  | GCD(A,B)   | Intersection/Common     |
  | NOT  | N(A)[...]  | Navigation/Steering     |

Key Insight:
  - OR(2,3) = 6  → "Both Mechanism AND Result exist here"
  - AND(6,10) = 2 → "Flip and Around share Mechanism"
  - NOT(6)[6,42] → "If at Flip, navigate to Deep Storage"
''')