Revolution

Revolution#

+ Expand
  • What makes for a suitable problem for AI (Demis Hassabis, Nobel Lecture)?
    • Space: Massive combinatorial search space
    • Function: Clear objective function (metric) to optimize against
    • Time: Either lots of data and/or an accurate and efficient simulator
  • Guess what else fits the bill (Yours truly, amateur philosopher)?
    • Space
      1. Intestines/villi
      2. Lungs/bronchioles
      3. Capillary trees
      4. Network of lymphatics
      5. Dendrites in neurons
      6. Tree branches
    • Function
      1. Energy
      2. Aerobic respiration
      3. Delivery to "last mile" (minimize distance)
      4. Response time (minimize)
      5. Information
      6. Exposure to sunlight for photosynthesis
    • Time
      1. Nourishment
      2. Gaseous exchange
      3. Oxygen & Nutrients (Carbon dioxide & "Waste")
      4. Surveillance for antigens
      5. Coherence of functions
      6. Water and nutrients from soil

-- Nobel Prize in Chemistry, 2024

Eco-Green QR Code

King Lear. The senile bequest motive at the outset makes it an endearing classic. but the plot gets messy. what do folks thing about it? Perhaps reality is that messy, with orthogonal plots unfolding to determine the outcome?

Dismiss your vows, your feigned tears, your flatt’ry; For where a heart is hard they make no batt’ry.” Source: Venus & Adonis

Hide code cell source
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx

# Define the neural network layers with Shakespeare's plays
def define_layers():
    return {
        'Suis': ['Macbeth', 'Othello', 'King Lear', 'Richard III', 'The Tempest', 'Romeo and Juliet'],
        'Voir': ['A Midsummer Night’s Dream'],  
        'Choisis': ['Henry V', 'Julius Caesar'],  
        'Deviens': ['Hamlet', 'Measure for Measure', 'The Winter’s Tale'],  
        "M'èléve": ['Antony and Cleopatra', 'Coriolanus', 'Titus Andronicus', 'As You Like It', 'Twelfth Night']  
    }

# Assign colors to nodes (retained from original for consistency)
def assign_colors():
    color_map = {
        'yellow': ['A Midsummer Night’s Dream'],  
        'paleturquoise': ['Romeo and Juliet', 'Julius Caesar', 'The Winter’s Tale', 'Twelfth Night'],  
        'lightgreen': ['The Tempest', 'Measure for Measure', 'Coriolanus', 'As You Like It', 'Titus Andronicus'],  
        'lightsalmon': ['King Lear', 'Richard III', 'Henry V', 'Hamlet', 'Antony and Cleopatra'],
    }
    return {node: color for color, nodes in color_map.items() for node in nodes}

# Define edge weights (unchanged from original)
def define_edges():
    return {
        ('Macbeth', 'A Midsummer Night’s Dream'): '1/99',
        ('Othello', 'A Midsummer Night’s Dream'): '5/95',
        ('King Lear', 'A Midsummer Night’s Dream'): '20/80',
        ('Richard III', 'A Midsummer Night’s Dream'): '51/49',
        ('The Tempest', 'A Midsummer Night’s Dream'): '80/20',
        ('Romeo and Juliet', 'A Midsummer Night’s Dream'): '95/5',
        ('A Midsummer Night’s Dream', 'Henry V'): '20/80',
        ('A Midsummer Night’s Dream', 'Julius Caesar'): '80/20',
        ('Henry V', 'Hamlet'): '49/51',
        ('Henry V', 'Measure for Measure'): '80/20',
        ('Henry V', 'The Winter’s Tale'): '95/5',
        ('Julius Caesar', 'Hamlet'): '5/95',
        ('Julius Caesar', 'Measure for Measure'): '20/80',
        ('Julius Caesar', 'The Winter’s Tale'): '51/49',
        ('Hamlet', 'Antony and Cleopatra'): '80/20',
        ('Hamlet', 'Coriolanus'): '85/15',
        ('Hamlet', 'Titus Andronicus'): '90/10',
        ('Hamlet', 'As You Like It'): '95/5',
        ('Hamlet', 'Twelfth Night'): '99/1',
        ('Measure for Measure', 'Antony and Cleopatra'): '1/9',
        ('Measure for Measure', 'Coriolanus'): '1/8',
        ('Measure for Measure', 'Titus Andronicus'): '1/7',
        ('Measure for Measure', 'As You Like It'): '1/6',
        ('Measure for Measure', 'Twelfth Night'): '1/5',
        ('The Winter’s Tale', 'Antony and Cleopatra'): '1/99',
        ('The Winter’s Tale', 'Coriolanus'): '5/95',
        ('The Winter’s Tale', 'Titus Andronicus'): '10/90',
        ('The Winter’s Tale', 'As You Like It'): '15/85',
        ('The Winter’s Tale', 'Twelfth Night'): '20/80'
    }

# Define edges to be highlighted in black (unchanged logic)
def define_black_edges():
    return {
        ('Macbeth', 'A Midsummer Night’s Dream'): '1/99',
        ('Othello', 'A Midsummer Night’s Dream'): '5/95',
    }

# Calculate node positions (unchanged)
def calculate_positions(layer, x_offset):
    y_positions = np.linspace(-len(layer) / 2, len(layer) / 2, len(layer))
    return [(x_offset, y) for y in y_positions]

# Create and visualize the neural network graph (unchanged logic)
def visualize_nn():
    layers = define_layers()
    colors = assign_colors()
    edges = define_edges()
    black_edges = define_black_edges()
    
    G = nx.DiGraph()
    pos = {}
    node_colors = []
    
    mapping = {}
    counter = 1
    for layer in layers.values():
        for node in layer:
            mapping[node] = f"{counter}. {node}"
            counter += 1
            
    for i, (layer_name, nodes) in enumerate(layers.items()):
        positions = calculate_positions(nodes, x_offset=i * 2)
        for node, position in zip(nodes, positions):
            new_node = mapping[node]
            G.add_node(new_node, layer=layer_name)
            pos[new_node] = position
            node_colors.append(colors.get(node, 'lightgray'))
    
    edge_colors = []
    for (source, target), weight in edges.items():
        if source in mapping and target in mapping:
            new_source = mapping[source]
            new_target = mapping[target]
            G.add_edge(new_source, new_target, weight=weight)
            edge_colors.append('black' if (source, target) in black_edges else 'lightgrey')
    
    plt.figure(figsize=(12, 8))
    edges_labels = {(u, v): d["weight"] for u, v, d in G.edges(data=True)}
    
    nx.draw(
        G, pos, with_labels=True, node_color=node_colors, edge_color=edge_colors,
        node_size=3000, font_size=9, connectionstyle="arc3,rad=0.2"
    )
    nx.draw_networkx_edge_labels(G, pos, edge_labels=edges_labels, font_size=8)
    plt.title("OPRAH™: Pericentral - Shakespeare Edition. Grok-3", fontsize=18)
    plt.show()

visualize_nn()
../../_images/42ed4b1478cef0c65bd1ed7fe57170eaa7ad5cfd26a71b7ce52d2822e9de6216.png
https://www.ledr.com/colours/white.jpg

Fig. 19 Fractal Scaling. So we have CG-BEST cosmogeology, biology, ecology, symbiotology, teleology. This maps onto tragedy, history, epic, drama, and comedy. It’s provocative!#