Update app.js

app.js

@@ -160,11 +160,11 @@ ASSUME <relationship> HOLDS
 Hard constraint on a field or relationship.
 Nothing outside a BOUND can exist in this scope.
 
-BOUND <field> WITHIN[<min>, <max>]
+BOUND <field> WITHIN [<min>, <max>]
 BOUND <field> ABOVE <value>
 BOUND <field> BELOW <value>
 BOUND <field> EQUALS <value>          # exact, no freedom
-BOUND <entity> COUNT WITHIN[<min>, <max>]
+BOUND <entity> COUNT WITHIN [<min>, <max>]
 BOUND <a> FORBIDS <b>                 # mutual exclusion
 
 ---
@@ -187,7 +187,7 @@ Hard optimization target. Unlike TEND, this must be satisfied
 for the scope to be considered resolved.
 
 OBJECTIVE <name>
-  OPTIMIZE <field> [MIN | MAX | EQUAL <value>]
+  OPTIMIZE <field>[MIN | MAX | EQUAL <value>]
   SUBJECT TO <constraint_list>
 END OBJECTIVE
 
@@ -276,7 +276,7 @@ physics, biology, and logic lives.
 
 CONTRADICT <statement_a> WITH <statement_b>
   AT SCOPE <level>
-  BOUNDARY_TYPE [SCALE | SPEED | INFORMATION | ENERGY]
+  BOUNDARY_TYPE[SCALE | SPEED | INFORMATION | ENERGY]
 
 ---
 
@@ -360,8 +360,625 @@ SAMPLE <id>
   OUTPUT <observed_value>
   STEP <n>
 END SAMPLE
+
+
+---
+
+## PART II — GRAMMAR RULES
+
+program         := scope_block+
+scope_block     := SCOPE name [level] body END SCOPE
+body            := statement*
+statement       := assume | entity | bound | tend | objective
+                 | derive | transform | observe | unknown
+                 | collapse | expand | contradict | emerges
+                 | composes | step | candidate | conserves
+                 | sample | unless
+
+condition       := field op value | entity EXISTS | state ACTIVE
+                 | condition AND condition | condition OR condition
+                 | NOT condition
+
+range           := [min, max] | {discrete_set}
+direction       := MIN | MAX | STABLE | TOWARD value | FOLLOW field
+type            := REAL | INTEGER | BOOLEAN | SYMBOLIC | VECTOR
+op              := EQUALS | ABOVE | BELOW | WITHIN | FORBIDS
+
+---
+
+## PART III — DEMONSTRATIONS
+
+---
+
+### DEMONSTRATION 1: THE ATOM
+#### Encoding atomic structure from quantum scope upward
+
+axl:
+# ════════════════════════════════════════════════════
+# ATOM SYSTEM
+# Starting assumption: energy exists and is quantized
+# ════════════════════════════════════════════════════
+
+SCOPE quantum[level: 0]
+
+  ASSUME energy EXISTS
+  ASSUME energy DISCRETE                    # quantization axiom
+  ASSUME charge EXISTS
+  CONSERVES charge ACROSS ALL_TRANSFORMS
+  CONSERVES energy ACROSS ALL_TRANSFORMS UNLESS transform EQUALS radiation
+
+  ENTITY quark
+    FIELD charge: REAL BOUND [-1, 1] DISCRETE VALUES {-2/3, -1/3, 1/3, 2/3}
+    FIELD color: SYMBOLIC DISCRETE VALUES {red, green, blue, antired, antigreen, antiblue}
+    FIELD mass: REAL BOUND [0.002, 4.5] # GeV
+    STATE free: REQUIRES energy ABOVE confinement_threshold
+    STATE confined: REQUIRES energy BELOW confinement_threshold
+    TENDS state TOWARD confined                # quarks want to be bound
+  END ENTITY
+
+  ENTITY gluon
+    FIELD charge: BOUND [0, 0] CONSERVES
+    FIELD color: SYMBOLIC                      # carries color charge
+    TENDS quark_binding MAX                    # gluons maximize binding
+  END ENTITY
+
+  BOUND quark COLOR_NEUTRAL IN any_free_composite  # color confinement
+
+END SCOPE
+
+
+SCOPE hadron [level: 1]
+
+  ASSUME quantum SCOPE HOLDS                  # inherit all quantum rules
+
+  COMPOSES proton
+    FROM quark COUNT EQUALS 3
+    CONFIGURATION {up, up, down}              # charge = 2/3+2/3-1/3 = +1
+    CONSERVING charge
+    BOUND total_charge EQUALS 1
+    BOUND color EQUALS neutral                # must be colorless
+  END COMPOSES
+
+  COMPOSES neutron
+    FROM quark COUNT EQUALS 3
+    CONFIGURATION {up, down, down}            # charge = 2/3-1/3-1/3 = 0
+    CONSERVING charge
+    BOUND total_charge EQUALS 0
+    BOUND color EQUALS neutral
+  END COMPOSES
+
+  EMERGES stability
+    FROM COMPOSITION OF {proton, neutron}
+    AT SCOPE hadron
+    NOT PRESENT AT SCOPE quantum
+    # individual quarks don't have nuclear stability — it emerges here
+
+END SCOPE
+
+
+SCOPE nucleus [level: 2]
+
+  ASSUME hadron SCOPE HOLDS
+
+  COMPOSES nucleus
+    FROM {proton, neutron}
+    BOUND proton_count WITHIN [1, 118]        # known elements
+    BOUND neutron_count WITHIN [0, 177]
+    TEND binding_energy MAX                   # nucleus maximizes binding
+    TEND neutron_to_proton_ratio TOWARD 1.0   # stability tendency
+  END COMPOSES
+
+  ENTITY strong_force
+    FIELD range: BOUND[0, 3e-15]             # femtometers — very short range
+    FIELD strength: REAL
+    TENDS nucleon_separation MIN              # pulls nucleons together
+  END ENTITY
+
+  ENTITY weak_force
+    TRANSFORMS neutron INTO proton
+    WHEN neutron_to_proton_ratio ABOVE stable_ratio
+    PRODUCES {proton, electron, antineutrino}  # beta decay
+    CONSERVING charge
+    CONSERVING lepton_number
+  END ENTITY
+
+  EMERGES atomic_number
+    FROM proton COUNT
+    AT SCOPE nucleus
+    # proton count alone determines element identity — pure emergence
+
+END SCOPE
+
+
+SCOPE atom [level: 3]
+
+  ASSUME nucleus SCOPE HOLDS
+
+  ENTITY electron
+    FIELD charge: BOUND [-1, -1] CONSERVES
+    FIELD mass: BOUND[9.109e-31, 9.109e-31] CONSERVES
+    FIELD spin: DISCRETE VALUES {-0.5, 0.5}
+    FIELD orbital: DISCRETE VALUES {s, p, d, f}
+    FIELD energy_level: INTEGER BOUND [1, 7]
+    TENDS energy MIN                          # electrons seek lowest energy
+    BOUND same_orbital_same_spin FORBIDS      # Pauli exclusion principle
+  END ENTITY
+
+  COMPOSES atom
+    FROM {nucleus, electron}
+    BOUND electron_count EQUALS proton_count  # neutral atom
+    TEND electron ORBITAL_FILL lowest_energy_first  # Aufbau principle
+  END COMPOSES
+
+  EMERGES chemical_behavior
+    FROM valence_electron_configuration
+    AT SCOPE atom
+    NOT PRESENT AT SCOPE nucleus
+    # chemistry is purely a scope 3 emergence — nucleus knows nothing of it
+
+  EMERGES periodic_properties
+    FROM atomic_number MODULO orbital_filling_pattern
+    AT SCOPE atom
+
+END SCOPE
+
+
+# ══ COLLAPSE EXAMPLE: Given observed spectral lines, find element ══
+
+OBSERVE spectral_emission EQUALS {656nm, 486nm, 434nm, 410nm}
+
+UNKNOWN element: SYMBOLIC WITHIN periodic_table
+UNKNOWN atomic_number: INTEGER BOUND [1, 118]
+UNKNOWN electron_configuration: VECTOR
+
+COLLAPSE atom
+  GIVEN {spectral_emission}
+  FIND {element, atomic_number, electron_configuration}
+  CONFIDENCE 0.95
+END COLLAPSE
+
+# Answer the system should derive: Hydrogen (Z=1)
+
+
+---
+
+### DEMONSTRATION 2: SHA-256 MINING
+#### Encoding the constraint and the intelligent nonce search
+
+axl:
+# ════════════════════════════════════════════════════
+# SHA-256 BITCOIN MINING SYSTEM
+# Objective: find nonce such that hash < target
+# The system does not know what SHA-256 is.
+# It knows: there is a transform, it has an output,
+# the output must satisfy a bound.
+# ════════════════════════════════════════════════════
+
+SCOPE bitfield [level: 0]
+
+  ASSUME bit EXISTS
+  ASSUME bit DISCRETE VALUES {0, 1}
+  ENTITY bit_array
+    FIELD length: INTEGER
+    FIELD value: VECTOR of bit
+    BOUND value COUNT EQUALS length
+  END ENTITY
+
+END SCOPE
+
+
+SCOPE sha256_internals [level: 1]
+
+  ASSUME bitfield SCOPE HOLDS
+
+  ENTITY message_schedule
+    FIELD W: VECTOR COUNT EQUALS 64        # 64 32-bit words
+    DERIVES FROM input_block
+    BY expansion_transform
+  END ENTITY
+
+  TRANSFORM round_function
+    INPUT {working_vars: VECTOR COUNT 8, W_i: bit_array}
+    OUTPUT {working_vars_next: VECTOR COUNT 8}
+    CONSERVES bit_count
+    CHANGES working_vars
+    # 64 applications of this = full SHA-256
+    # Each application: sigma, choice, majority, mod add
+    # AXL does not encode the arithmetic — that's the domain encoder's job
+    # AXL encodes only: this is a deterministic transform with known structure
+  END TRANSFORM
+
+  CONTRADICT input_a WITH input_b
+    AT SCOPE sha256_internals
+    BOUNDARY_TYPE INFORMATION
+    # Two different inputs CAN produce same output (collision)
+    # But finding one is computationally infeasible
+    # This contradiction is the security boundary
+
+  TRANSFORM sha256
+    INPUT {message: bit_array BOUND length WITHIN [0, 2^64]}
+    OUTPUT {digest: bit_array BOUND length EQUALS 256}
+    CONSERVES nothing                       # one-way: no conservation
+    CHANGES everything                      # avalanche: all output bits affected
+    REQUIRES input EXISTS
+    PRODUCES digest PSEUDO_RANDOM_FROM input
+    # PSEUDO_RANDOM_FROM is the key declaration:
+    # output is deterministic but statistically independent of input structure
+  END TRANSFORM
+
+END SCOPE
+
+
+SCOPE block_header [level: 2]
+
+  ASSUME sha256_internals SCOPE HOLDS
+
+  ENTITY block_header
+    FIELD version: INTEGER BOUND [1, 4]
+    FIELD prev_hash: bit_array BOUND length EQUALS 256   # GIVEN, fixed
+    FIELD merkle_root: bit_array BOUND length EQUALS 256 # GIVEN, fixed
+    FIELD timestamp: INTEGER                              # GIVEN, approximately fixed
+    FIELD bits: INTEGER                                   # GIVEN, encodes target
+    FIELD nonce: INTEGER BOUND [0, 4294967295]           # UNKNOWN — 32 bits of freedom
+  END ENTITY
+
+  DERIVE target
+    FROM bits
+    BY difficulty_decode_transform
+    # target = a 256-bit number. Valid hash must be below it.
+    # More leading zeros in target = harder problem
+
+END SCOPE
+
+
+SCOPE mining [level: 3]
+
+  ASSUME block_header SCOPE HOLDS
+
+  TRANSFORM double_sha256
+    INPUT {block_header}
+    OUTPUT {hash: bit_array BOUND length EQUALS 256}
+    BY {sha256 APPLIED_TWICE}
+  END TRANSFORM
+
+  OBJECTIVE valid_block
+    OPTIMIZE hash MIN                        # minimize hash value numerically
+    SUBJECT TO hash BELOW target             # hard bound — must be satisfied
+    SUBJECT TO nonce WITHIN [0, 4294967295]
+  END OBJECTIVE
+
+  # ══ HERE IS THE INTELLIGENCE LAYER ══
+  # The nonce space has NO smooth gradient (SHA-256 destroys it)
+  # But the SEARCH SPACE has learnable structure:
+  # - which regions have been explored (coverage)
+  # - step count gives sequence context
+  # - candidate scoring gives relative ranking
+  # This is what the UCE learns — not the hash, but the search
+
+  UNKNOWN nonce: INTEGER BOUND[0, 4294967295]
+
+  STEP 0
+    STATE {nonce_space: unexplored}
+    CANDIDATE 0
+      nonce: SAMPLE uniform
+      SCORE: UNKNOWN
+      CONFIDENCE: 0.0
+    END CANDIDATE
+  END STEP
+
+  STEP N
+    STATE {
+      explored_regions: VECTOR,              # coverage map
+      best_hash_so_far: bit_array,
+      distance_to_target: INTEGER,
+      step_count: N
+    }
+    CANDIDATE 0..50                          # 50 parallel candidates
+      nonce: DERIVES FROM {
+        explored_regions,
+        step_count,
+        best_hash_so_far
+      }
+      # The system learns: given search history,
+      # what nonce regions have NOT been tried
+      # and which historically neighboring regions
+      # produced closer hashes (within this block's structure)
+      SCORE: distance_to_target MIN
+      CONFIDENCE: LEARNS
+    END CANDIDATE
+  END STEP
+
+  OBSERVE hash BELOW target                  # this is the termination condition
+
+  COLLAPSE mining
+    GIVEN {block_header_fixed_fields, target, search_history}
+    FIND {nonce}
+    CONFIDENCE 0.99
+  END COLLAPSE
+
+  # ══ WHAT THE SYSTEM LEARNS ══
+  # Not: how to reverse SHA-256
+  # But: how to cover the nonce space intelligently
+  # avoiding redundant regions, clustering search
+  # around previously productive neighborhoods
+  # The intelligence is in the search, not the hash
+
+END SCOPE
+
+
+---
+
+### DEMONSTRATION 3: CELL DIVISION (MITOSIS)
+#### Encoding life as constraint satisfaction
+
+axl:
+# ════════════════════════════════════════════════════
+# CELL DIVISION SYSTEM
+# Life as constraints on information replication
+# with error correction and state machines
+# ════════════════════════════════════════════════════
+
+SCOPE molecular [level: 0]
+
+  ASSUME molecule EXISTS
+  ASSUME information CAN BE ENCODED IN molecule
+  ASSUME chemical_bond EXISTS
+  CONSERVES atom_count ACROSS chemical_reactions
+  CONSERVES charge ACROSS chemical_reactions
+
+  ENTITY nucleotide
+    FIELD base: SYMBOLIC DISCRETE VALUES {adenine, thymine, guanine, cytosine}
+    FIELD sugar: SYMBOLIC EQUALS deoxyribose
+    FIELD phosphate: BOOLEAN
+    BOUND adenine PAIRS_WITH thymine ONLY      # base pairing rule
+    BOUND guanine PAIRS_WITH cytosine ONLY
+  END ENTITY
+
+  ENTITY dna_strand
+    FIELD sequence: VECTOR of nucleotide
+    FIELD length: INTEGER BOUND [1, 3e9]       # up to 3 billion base pairs
+    FIELD direction: SYMBOLIC DISCRETE VALUES {5_to_3, 3_to_5}
+    CONSERVES sequence UNLESS transform EQUALS mutation
+    TENDS base_pair_bonds STABLE               # double helix stability
+  END ENTITY
+
+  TRANSFORM base_pairing
+    INPUT {strand_a: dna_strand, strand_b: dna_strand}
+    OUTPUT {double_helix}
+    REQUIRES strand_a.direction FORBIDS strand_b.direction  # antiparallel
+    REQUIRES each_base PAIRS_WITH complement
+    CONSERVES sequence_information
+  END TRANSFORM
+
+END SCOPE
+
+
+SCOPE genome [level: 1]
+
+  ASSUME molecular SCOPE HOLDS
+
+  ENTITY chromosome
+    FIELD dna: dna_strand
+    FIELD histone_proteins: VECTOR
+    FIELD centromere_position: INTEGER
+    FIELD telomere_length: INTEGER BOUND [0, 15000]  # erosion limit
+    TENDS compaction MAX WHEN cell_dividing EQUALS true
+    TENDS compaction MIN WHEN cell_active EQUALS true
+  END ENTITY
+
+  ENTITY genome
+    FIELD chromosomes: VECTOR of chromosome
+    BOUND chromosome_count EQUALS 46          # human diploid — pairs of 23
+    CONSERVES chromosome_count UNLESS transform EQUALS meiosis
+    TENDS integrity MAX                       # genome resists damage
+  END ENTITY
+
+  ENTITY dna_polymerase
+    FIELD error_rate: REAL BOUND [1e-9, 1e-9] # one error per billion bases
+    TENDS accuracy MAX
+    TRANSFORMS dna_strand INTO dna_strand_copy
+    CONSERVES sequence UNLESS error_rate TRIGGERS
+  END ENTITY
+
+  EMERGES genetic_code
+    FROM nucleotide_triplet_sequence
+    AT SCOPE genome
+    NOT PRESENT AT SCOPE molecular
+    # individual nucleotides have no meaning — codons emerge at this level
+
+END SCOPE
+
+
+SCOPE cell[level: 2]
+
+  ASSUME genome SCOPE HOLDS
+
+  ENTITY cell
+    FIELD genome: genome
+    FIELD membrane: BOOLEAN EQUALS true        # boundary condition
+    FIELD atp_level: REAL BOUND[0, 1]         # energy state
+    FIELD size: REAL BOUND[minimum_viable, maximum_before_division]
+    FIELD age: INTEGER                         # division counter
+    FIELD state: SYMBOLIC DISCRETE VALUES {
+      G1,                                      # growth phase 1
+      S,                                       # synthesis (DNA replication)
+      G2,                                      # growth phase 2
+      M,                                       # mitosis (division)
+      G0,                                      # quiescent (resting)
+      apoptosis                                # programmed death
+    }
+    TENDS atp_level MAX                        # cells maximize energy
+    TENDS genome_integrity MAX                 # cells protect DNA
+    BOUND age BELOW hayflick_limit             # telomere erosion limit
+  END ENTITY
+
+  ENTITY checkpoint_protein
+    FIELD name: SYMBOLIC DISCRETE VALUES {p53, rb, cyclin_B, cdk1}
+    FIELD active: BOOLEAN
+    TENDS genome_damage OBSERVE                # monitors DNA integrity
+    TRANSFORMS cell.state INTO apoptosis
+      WHEN genome_damage ABOVE repair_threshold
+    # p53 is the key constraint enforcer — if damage is too great, die
+  END ENTITY
+
+END SCOPE
+
+
+SCOPE mitosis [level: 3]
+
+  ASSUME cell SCOPE HOLDS
+
+  # ══ TRIGGER CONDITIONS ══
+  # Cell division is itself a constraint satisfaction problem:
+  # divide WHEN AND ONLY WHEN all conditions hold
+
+  OBJECTIVE division_trigger
+    OPTIMIZE cell.state EQUAL M
+    SUBJECT TO {
+      cell.size ABOVE division_threshold,
+      cell.atp_level ABOVE 0.7,
+      dna_replication EQUALS complete,
+      checkpoint_all EQUALS passed,
+      external_growth_signal EQUALS present,
+      cell.age BELOW hayflick_limit
+    }
+    # ALL conditions must hold — AND logic, not OR
+    # This is why cancer is a constraint violation:
+    # it occurs when checkpoint constraints are BROKEN
+  END OBJECTIVE
+
+  TRANSFORM prophase
+    INPUT {cell: STATE G2}
+    OUTPUT {cell: chromosomes_condensed, spindle_forming}
+    REQUIRES division_trigger EQUALS satisfied
+    CONSERVES chromosome_count
+    CONSERVES genome_content
+  END TRANSFORM
+
+  TRANSFORM metaphase
+    INPUT {cell: chromosomes_condensed}
+    OUTPUT {cell: chromosomes_aligned_at_plate}
+    REQUIRES spindle_attached_to EQUALS all_chromosomes
+    # Checkpoint: spindle assembly checkpoint
+    # If any chromosome unattached — PAUSE here
+    BOUND unattached_chromosomes EQUALS 0
+      UNLESS OVERRIDE apoptosis
+  END TRANSFORM
+
+  TRANSFORM anaphase
+    INPUT {cell: chromosomes_aligned}
+    OUTPUT {sister_chromatids: separating}
+    CONSERVES chromosome_count_total
+    CHANGES chromosome_location
+    PRODUCES two_sets OF 46_chromosomes
+  END TRANSFORM
+
+  TRANSFORM telophase_and_cytokinesis
+    INPUT {cell: chromatids_separated}
+    OUTPUT {daughter_cell_1, daughter_cell_2}
+    CONSERVES genome_content IN each_daughter
+    CONSERVES organelle_distribution APPROXIMATELY
+    PRODUCES {
+      daughter_cell_1: IDENTICAL_GENOME_TO parent,
+      daughter_cell_2: IDENTICAL_GENOME_TO parent
+    }
+  END TRANSFORM
+
+  EMERGES tissue
+    FROM COMPOSITION OF {cell COUNT ABOVE 1}
+    AT SCOPE mitosis
+    NOT PRESENT AT SCOPE cell
+    # individual cells have no tissue identity — it emerges from composition
+
+  EMERGES cancer
+    FROM checkpoint_protein.active EQUALS false
+      AND division_trigger SATISFIED_WITHOUT all_conditions
+    AT SCOPE mitosis
+    # Cancer is not a new thing — it is constraint violation
+    # The cell divides when it should not because the objective
+    # function has been corrupted
+    CONTRADICT cancer WITH normal_division
+      AT SCOPE mitosis
+      BOUNDARY_TYPE INFORMATION           # corrupted information in genome
+
+  # ══ COLLAPSE EXAMPLE: Cancer diagnosis ══
+
+  OBSERVE {
+    cell.division_rate ABOVE normal_range,
+    checkpoint_protein.p53 EQUALS inactive,
+    cell.age ABOVE hayflick_limit
+  }
+
+  UNKNOWN {
+    mutation_site: dna_strand LOCATION,
+    checkpoint_broken: SYMBOLIC,
+    division_trigger_violated: OBJECTIVE_CLAUSE
+  }
+
+  COLLAPSE mitosis
+    GIVEN {abnormal_observations}
+    FIND {mutation_site, checkpoint_broken, division_trigger_violated}
+    CONFIDENCE 0.90
+  END COLLAPSE
+
+END SCOPE
+
+
+# ════════════════════════════════════════════════════
+# META: THE LANGUAGE DESCRIBING ITSELF
+# AXL encoding its own structure
+# ════════════════════════════════════════════════════
+
+SCOPE axl_meta [level: 0]
+
+  ASSUME symbol EXISTS
+  ASSUME symbol CAN CARRY meaning
+  ASSUME meaning IS RELATIVE TO scope
+
+  ENTITY keyword
+    FIELD token: SYMBOLIC
+    FIELD semantic: SYMBOLIC
+    FIELD abstraction_direction: DISCRETE VALUES {up, down, both, none}
+    FIELD arity: INTEGER                      # how many arguments it takes
+  END ENTITY
+
+  ENTITY statement
+    FIELD keywords: VECTOR of keyword
+    FIELD scope_level: INTEGER
+    DERIVES meaning FROM {keywords, scope_level, context}
+    # Same token, different scope = different meaning
+    # BOUND in scope 0 (physics) ≠ BOUND in scope 3 (biology)
+  END ENTITY
+
+  EMERGES program_meaning
+    FROM COMPOSITION OF {statement COUNT ABOVE 1}
+    AT SCOPE axl_meta
+    NOT PRESENT AT SCOPE symbol
+    # Individual symbols have no program meaning
+    # Meaning emerges from composition and scope
+
+  TEND expressiveness MAX
+  TEND ambiguity MIN
+  CONTRADICT expressiveness WITH ambiguity
+    AT SCOPE axl_meta
+    BOUNDARY_TYPE INFORMATION
+    # All languages face this — AXL resolves it via scope tagging
+
+END SCOPE
+
+---
+
+## PART IV — DESIGN NOTES
+**On contradictions:**
+Every CONTRADICT in these examples marks a real scientific boundary:
+- quantum/classical = scale boundary
+- cancer/normal = information boundary
+- expressiveness/ambiguity = the language's own limit
+
 `;
 
+
+
 const SYSTEM_PROMPT_HEADER = `You are a dataset generator for the Universal Constraint Engine (UCE),
 a domain-agnostic constraint satisfaction and optimization system.
 The UCE is trained on AXL (Abstraction eXchange Language) programs.