

STATIC CONSTRAINT PROFILE -- problem claustro-topo
generated by tech/constraint-profile.lisp -- NEVER HAND-EDITED


MC  MECHANIC COVERAGE  [grade 1]
--------------------------------------------------------------

  public technologies spliced (12): 12 covered, 0 UNCOVERED
    beam-direct       COVERED    contract (also RC NH H3)
    box               COVERED    extractors S2 S5
    elevation         COVERED    infrastructure -- authors levels; read by S5
    gate              COVERED    extractors S1 S3 S4
    jammer            COVERED    contract (also S1)
    jump              COVERED    contract (also S3 S5)
    ladder            COVERED    contract (also S3)
    plate             COVERED    extractors S1 S2 T6
    reachability      COVERED    infrastructure -- reach relations; read by S4
    stairs            COVERED    contract (also S3)
    visibility        COVERED    infrastructure -- line of sight; read by S6
    walkability       COVERED    infrastructure -- derives walk-kind facts; read by S3

  UNCOVERED (0):
    READING: UNCOVERED means no static contract is declared for that technology.  The coverage gate (Problem-Solving Guide, Phase 0 step 2) requires a hand contract in the Briefing, or a component, before going on.  COVERED by extractors or infrastructure means the named components carry its static consequences; it is not a contract.

  contract beam-direct
    controls  receiver activation from a chroma-matching direct coupling with a clear corridor and no BEAM-CUT; repeaters additionally depend on upstream lighting
    moves     nothing; fixed oriented links are COUPLED pairs, independent of connector placements
    requires  BEAM-VIA present; recorded walls/edges/boundaries and closed gates clear at interpolated endpoint heights; unrecorded authored gates open; authored location occupants not spanning beam height. Views may differ; other beam mechanisms can activate the receiver

  fixed beam corridors (1), staged physical view
    transmitter1 -> receiver1: BEAM-VIA present; authored (gate1 location2); recorded ((:gate gate1 49/128 16 5 16 10))
      gate candidates (gate1); occupancy locations (location2); chromas blue/blue; corridor clear now NIL
    Recorded barriers use finite spans and interpolated beam height; authored gates without geometry require open. Locations block only when an occupant spans that height.
    Corridor clearance is not receiver activation: matching chromas, BEAM-CUT and upstream repeater lighting also matter. Other beam routes, recording views, stability and reachability are not established.

  contract jammer
    controls  a placed jam overrides a gate open, a blower drive stopped or a gun safe; picking up the jammer removes its jam and support
    moves     carried cargo; PUT-JAMMER places inertly, JAM-TARGET places and jams; placement on a pressure plate can also supply weight
    requires  holding a jammer, reachable placement, no directional JAM-DISALLOWED> exclusion, legal placement/support/view and target sightline from the placed jammer's top. Ground/plate/box sightline rows are candidates only; gate bits are hypotheses
    Survey: ground, fixed plates, staged box tops; physical view, all gates forced open without propagation. No moved/stacked supports, trays or fans surveyed.
    jammer1 -> gate1: visible sites (location support required-open gates) ((location1 ground nil) (location2 ground nil)
                                                                            (location3 ground (gate2 gate3)) (location4 box1 (gate2 gate3))
                                                                            (location4 ground (gate2 gate3))
                                                                            (location4 plate1 (gate2 gate3))
                                                                            (location5 ground (gate2 gate3))
                                                                            (location5 plate2 (gate2 gate3))
                                                                            (location6 ground (gate2 gate3))
                                                                            (location6 plate3 (gate2 gate3)) (location7 ground nil))
    jammer1 -> gate2: visible sites (location support required-open gates) ((location1 ground nil)
                                                                            (location10 box2 (gate3 gate5 gate6 gate7))
                                                                            (location10 ground (gate3 gate5 gate6 gate7))
                                                                            (location12 ground (gate3 gate5 gate6 gate7))
                                                                            (location13 ground (gate3 gate5 gate6 gate7 gate8 gate9))
                                                                            (location2 ground nil) (location3 ground (gate3))
                                                                            (location4 box1 (gate3)) (location4 ground (gate3))
                                                                            (location4 plate1 (gate3)) (location5 ground (gate3))
                                                                            (location5 plate2 (gate3)) (location6 ground (gate3))
                                                                            (location6 plate3 (gate3)) (location9 ground (gate3 gate5)))
    jammer1 -> gate3: visible sites (location support required-open gates) ((location1 ground (gate2))
                                                                            (location10 box2 (gate5 gate6 gate7))
                                                                            (location10 ground (gate5 gate6 gate7))
                                                                            (location12 ground (gate5 gate6 gate7))
                                                                            (location13 ground (gate5 gate6 gate7 gate8 gate9))
                                                                            (location2 ground (gate2)) (location3 ground nil)
                                                                            (location4 box1 nil) (location4 ground nil)
                                                                            (location4 plate1 nil) (location5 ground nil)
                                                                            (location5 plate2 nil) (location6 ground nil)
                                                                            (location6 plate3 nil) (location9 ground (gate5)))
    jammer1 -> gate4: visible sites (location support required-open gates) ((location1 ground nil) (location10 box2 (gate5 gate6 gate7))
                                                                            (location10 ground (gate5 gate6 gate7))
                                                                            (location12 ground (gate5 gate6 gate7))
                                                                            (location13 ground (gate5 gate6 gate7 gate8 gate9))
                                                                            (location3 ground nil) (location4 box1 nil)
                                                                            (location4 ground nil) (location4 plate1 nil)
                                                                            (location5 ground nil) (location5 plate2 nil)
                                                                            (location6 ground nil) (location6 plate3 nil)
                                                                            (location7 ground nil) (location8 ground nil)
                                                                            (location9 ground (gate5)))
    jammer1 -> gate5: visible sites (location support required-open gates) ((location1 ground (gate2 gate3))
                                                                            (location10 box2 (gate6 gate7))
                                                                            (location10 ground (gate6 gate7))
                                                                            (location12 ground (gate6 gate7))
                                                                            (location13 ground (gate6 gate7 gate8 gate9))
                                                                            (location2 ground (gate2 gate3)) (location3 ground nil)
                                                                            (location4 box1 nil) (location4 ground nil)
                                                                            (location4 plate1 nil) (location5 ground nil)
                                                                            (location5 plate2 nil) (location6 ground nil)
                                                                            (location6 plate3 nil) (location8 ground (gate4))
                                                                            (location9 ground nil))
    jammer1 -> gate6: visible sites (location support required-open gates) ((location10 box2 (gate7)) (location10 ground (gate7))
                                                                            (location11 ground (gate7)) (location12 ground (gate7))
                                                                            (location13 ground (gate7 gate8 gate9))
                                                                            (location2 ground (gate2 gate3 gate5))
                                                                            (location3 ground (gate5)) (location4 box1 (gate5))
                                                                            (location4 ground (gate5)) (location4 plate1 (gate5))
                                                                            (location5 ground (gate5)) (location5 plate2 (gate5))
                                                                            (location6 ground (gate5)) (location6 plate3 (gate5))
                                                                            (location8 ground (gate4 gate5)) (location9 ground nil))
    jammer1 -> gate7: visible sites (location support required-open gates) ((location10 box2 nil) (location10 ground nil)
                                                                            (location11 ground nil) (location12 ground nil)
                                                                            (location13 ground (gate8 gate9))
                                                                            (location2 ground (gate2 gate3 gate5 gate6))
                                                                            (location3 ground (gate5 gate6)) (location4 box1 (gate5 gate6))
                                                                            (location4 ground (gate5 gate6))
                                                                            (location4 plate1 (gate5 gate6))
                                                                            (location5 ground (gate5 gate6))
                                                                            (location5 plate2 (gate5 gate6))
                                                                            (location6 ground (gate5 gate6))
                                                                            (location6 plate3 (gate5 gate6))
                                                                            (location8 ground (gate4 gate5 gate6))
                                                                            (location9 ground (gate6)))
    jammer1 -> gate8: visible sites (location support required-open gates) ((location10 box2 nil) (location10 ground nil)
                                                                            (location11 ground (gate9)) (location12 ground nil)
                                                                            (location13 ground (gate9))
                                                                            (location2 ground (gate2 gate3 gate5 gate6 gate7))
                                                                            (location3 ground (gate5 gate6 gate7))
                                                                            (location4 box1 (gate5 gate6 gate7))
                                                                            (location4 ground (gate5 gate6 gate7))
                                                                            (location4 plate1 (gate5 gate6 gate7))
                                                                            (location5 ground (gate5 gate6 gate7))
                                                                            (location5 plate2 (gate5 gate6 gate7))
                                                                            (location6 ground (gate5 gate6 gate7))
                                                                            (location6 plate3 (gate5 gate6 gate7))
                                                                            (location8 ground (gate4 gate5 gate6 gate7))
                                                                            (location9 ground (gate6 gate7)))
    jammer1 -> gate9: visible sites (location support required-open gates) ((location10 box2 (gate8)) (location10 ground (gate8))
                                                                            (location11 ground nil) (location12 ground (gate8))
                                                                            (location13 ground nil)
                                                                            (location2 ground (gate2 gate3 gate5 gate6 gate7 gate8))
                                                                            (location3 ground (gate5 gate6 gate7 gate8))
                                                                            (location4 box1 (gate5 gate6 gate7 gate8))
                                                                            (location4 ground (gate5 gate6 gate7 gate8))
                                                                            (location4 plate1 (gate5 gate6 gate7 gate8))
                                                                            (location5 ground (gate5 gate6 gate7 gate8))
                                                                            (location5 plate2 (gate5 gate6 gate7 gate8))
                                                                            (location6 ground (gate5 gate6 gate7 gate8))
                                                                            (location6 plate3 (gate5 gate6 gate7 gate8))
                                                                            (location8 ground (gate4 gate5 gate6 gate7 gate8))
                                                                            (location9 ground (gate6 gate7 gate8)))
    jammer2 -> gate1: visible sites (location support required-open gates) ((location1 ground nil) (location2 ground nil)
                                                                            (location3 ground (gate2 gate3)) (location4 box1 (gate2 gate3))
                                                                            (location4 ground (gate2 gate3))
                                                                            (location4 plate1 (gate2 gate3))
                                                                            (location5 ground (gate2 gate3))
                                                                            (location5 plate2 (gate2 gate3))
                                                                            (location6 ground (gate2 gate3))
                                                                            (location6 plate3 (gate2 gate3)) (location7 ground nil))
    jammer2 -> gate2: visible sites (location support required-open gates) ((location1 ground nil)
                                                                            (location10 box2 (gate3 gate5 gate6 gate7))
                                                                            (location10 ground (gate3 gate5 gate6 gate7))
                                                                            (location12 ground (gate3 gate5 gate6 gate7))
                                                                            (location13 ground (gate3 gate5 gate6 gate7 gate8 gate9))
                                                                            (location2 ground nil) (location3 ground (gate3))
                                                                            (location4 box1 (gate3)) (location4 ground (gate3))
                                                                            (location4 plate1 (gate3)) (location5 ground (gate3))
                                                                            (location5 plate2 (gate3)) (location6 ground (gate3))
                                                                            (location6 plate3 (gate3)) (location9 ground (gate3 gate5)))
    jammer2 -> gate3: visible sites (location support required-open gates) ((location1 ground (gate2))
                                                                            (location10 box2 (gate5 gate6 gate7))
                                                                            (location10 ground (gate5 gate6 gate7))
                                                                            (location12 ground (gate5 gate6 gate7))
                                                                            (location13 ground (gate5 gate6 gate7 gate8 gate9))
                                                                            (location2 ground (gate2)) (location3 ground nil)
                                                                            (location4 box1 nil) (location4 ground nil)
                                                                            (location4 plate1 nil) (location5 ground nil)
                                                                            (location5 plate2 nil) (location6 ground nil)
                                                                            (location6 plate3 nil) (location9 ground (gate5)))
    jammer2 -> gate4: visible sites (location support required-open gates) ((location1 ground nil) (location10 box2 (gate5 gate6 gate7))
                                                                            (location10 ground (gate5 gate6 gate7))
                                                                            (location12 ground (gate5 gate6 gate7))
                                                                            (location13 ground (gate5 gate6 gate7 gate8 gate9))
                                                                            (location3 ground nil) (location4 box1 nil)
                                                                            (location4 ground nil) (location4 plate1 nil)
                                                                            (location5 ground nil) (location5 plate2 nil)
                                                                            (location6 ground nil) (location6 plate3 nil)
                                                                            (location7 ground nil) (location8 ground nil)
                                                                            (location9 ground (gate5)))
    jammer2 -> gate5: visible sites (location support required-open gates) ((location1 ground (gate2 gate3))
                                                                            (location10 box2 (gate6 gate7))
                                                                            (location10 ground (gate6 gate7))
                                                                            (location12 ground (gate6 gate7))
                                                                            (location13 ground (gate6 gate7 gate8 gate9))
                                                                            (location2 ground (gate2 gate3)) (location3 ground nil)
                                                                            (location4 box1 nil) (location4 ground nil)
                                                                            (location4 plate1 nil) (location5 ground nil)
                                                                            (location5 plate2 nil) (location6 ground nil)
                                                                            (location6 plate3 nil) (location8 ground (gate4))
                                                                            (location9 ground nil))
    jammer2 -> gate6: visible sites (location support required-open gates) ((location10 box2 (gate7)) (location10 ground (gate7))
                                                                            (location11 ground (gate7)) (location12 ground (gate7))
                                                                            (location13 ground (gate7 gate8 gate9))
                                                                            (location2 ground (gate2 gate3 gate5))
                                                                            (location3 ground (gate5)) (location4 box1 (gate5))
                                                                            (location4 ground (gate5)) (location4 plate1 (gate5))
                                                                            (location5 ground (gate5)) (location5 plate2 (gate5))
                                                                            (location6 ground (gate5)) (location6 plate3 (gate5))
                                                                            (location8 ground (gate4 gate5)) (location9 ground nil))
    jammer2 -> gate7: visible sites (location support required-open gates) ((location10 box2 nil) (location10 ground nil)
                                                                            (location11 ground nil) (location12 ground nil)
                                                                            (location13 ground (gate8 gate9))
                                                                            (location2 ground (gate2 gate3 gate5 gate6))
                                                                            (location3 ground (gate5 gate6)) (location4 box1 (gate5 gate6))
                                                                            (location4 ground (gate5 gate6))
                                                                            (location4 plate1 (gate5 gate6))
                                                                            (location5 ground (gate5 gate6))
                                                                            (location5 plate2 (gate5 gate6))
                                                                            (location6 ground (gate5 gate6))
                                                                            (location6 plate3 (gate5 gate6))
                                                                            (location8 ground (gate4 gate5 gate6))
                                                                            (location9 ground (gate6)))
    jammer2 -> gate8: visible sites (location support required-open gates) ((location10 box2 nil) (location10 ground nil)
                                                                            (location11 ground (gate9)) (location12 ground nil)
                                                                            (location13 ground (gate9))
                                                                            (location2 ground (gate2 gate3 gate5 gate6 gate7))
                                                                            (location3 ground (gate5 gate6 gate7))
                                                                            (location4 box1 (gate5 gate6 gate7))
                                                                            (location4 ground (gate5 gate6 gate7))
                                                                            (location4 plate1 (gate5 gate6 gate7))
                                                                            (location5 ground (gate5 gate6 gate7))
                                                                            (location5 plate2 (gate5 gate6 gate7))
                                                                            (location6 ground (gate5 gate6 gate7))
                                                                            (location6 plate3 (gate5 gate6 gate7))
                                                                            (location8 ground (gate4 gate5 gate6 gate7))
                                                                            (location9 ground (gate6 gate7)))
    jammer2 -> gate9: visible sites (location support required-open gates) ((location10 box2 (gate8)) (location10 ground (gate8))
                                                                            (location11 ground nil) (location12 ground (gate8))
                                                                            (location13 ground nil)
                                                                            (location2 ground (gate2 gate3 gate5 gate6 gate7 gate8))
                                                                            (location3 ground (gate5 gate6 gate7 gate8))
                                                                            (location4 box1 (gate5 gate6 gate7 gate8))
                                                                            (location4 ground (gate5 gate6 gate7 gate8))
                                                                            (location4 plate1 (gate5 gate6 gate7 gate8))
                                                                            (location5 ground (gate5 gate6 gate7 gate8))
                                                                            (location5 plate2 (gate5 gate6 gate7 gate8))
                                                                            (location6 ground (gate5 gate6 gate7 gate8))
                                                                            (location6 plate3 (gate5 gate6 gate7 gate8))
                                                                            (location8 ground (gate4 gate5 gate6 gate7 gate8))
                                                                            (location9 ground (gate6 gate7 gate8)))
    JAM-DISALLOWED> (agent-location placement-location target):
      (location1 location7 gate1)
      (location7 location1 gate4)
    A sightline is not an applicable action: exclusions, reach, support use, occupancy, availability and actual view remain to be checked.

  contract jump
    controls  nothing; a jump has no CONTROLS entry and no state
    moves     an agent across a jump-kind clause -- one naming an edge, a wall or a floor drive, or in a bare-level problem naming none across a level difference -- (symmetric, or one way when directed), landing on the floor or on a box or held-tray top at the far end; locally, onto a box or held-tray top at its own location, and down from one
    requires  the landing at most *vertical-reach-limit* above the launch elevation (the floor, or the top of the support the agent stands on); edges and floor drives are static and always passable; every other clause member a gate, screen or wall, and each one not passable (a closed gate, a non-passable screen, every wall) with its top at most that limit above the launch; a safe destination.  Downward and level landings are unrestricted; a grounded tray is no landing, nor the agent's own held tray
    reach limit 1 (*vertical-reach-limit*); a raise is the least launch elevation above the source floor, reached by standing on a support (S5 tops)
    location10 -> location12  clause ()  level 0 -> 3/2
      no feature  raise 1/2 above the floor
    location12 -> location10  clause ()  level 3/2 -> 0
      no feature  from the floor

  contract ladder
    controls  nothing; a ladder has no CONTROLS entry and no state
    moves     an agent across a climb-kind clause (one naming a ladder) from its fact's source to its destination, one way (traverse-via>); a supported agent at the source lands on the ground at the destination
    requires  a ladder named in the arc's clause positioned at its source (ladder-init-check), every other means in the clause clear, and a safe destination
    ladder1  at location7
      climb  location7 --> location1  family ((ladder1))  ladder at source: yes

  contract stairs
    controls  nothing; a staircase has no state
    moves     an agent across a stairs-kind clause (one naming a staircase), in its fact's permitted direction, through a MOVE stairs segment
    requires  all means of one alternative clause (the clause without its staircase) passable for the mover and a safe destination; no elevation-difference or elevation-equality limit. Empty hands only when a clause's means require them
    location11 <-> location13; family nil


S0  TYPE EXTENT CENSUS  [grade 1]
--------------------------------------------------------------

  type extents (57 types)
    agent  1  authored  SINGLETON
    angled-blower  0  optional  EMPTY
    angled-blower+angled-gears+floor-blower+floor-gears+wall-blower+wall-gears  0  synthesized  EMPTY  components floor-gears wall-gears angled-gears floor-blower wall-blower angled-blower
    angled-blower+floor-blower  0  synthesized  EMPTY  components floor-blower angled-blower
    angled-gears  0  optional  EMPTY
    beam-blocker  5  authored  components agent box jammer connector
    beam-node  15  authored  components transmitter receiver floor-repeater wall-repeater location
    blower  0  authored  EMPTY  components floor-blower wall-blower angled-blower
    box  2  authored
    cargo  4  authored  components box jammer connector fan tray
    connector  0  optional  EMPTY
    edge  1  authored  SINGLETON
    edge+wall  4  synthesized  components wall edge
    elevated-object  29  authored  components location gate screen wall edge transmitter receiver gun switch wall-gears wall-blower floor-repeater wall-repeater
    fan  0  optional  EMPTY
    fixed-beam-sink  1  authored  SINGLETON  components floor-repeater wall-repeater receiver
    fixed-beam-source  1  authored  SINGLETON  components transmitter floor-repeater wall-repeater
    fixed-position-object  4  authored  components pressure-plate toggle-plate ladder floor-gears wall-gears angled-gears floor-blower wall-blower angled-blower recorder
    floor-blower  0  optional  EMPTY
    floor-gears  0  optional  EMPTY
    floor-repeater  0  optional  EMPTY
    gate  9  authored
    gate+screen  10  synthesized  components gate screen
    gears  0  authored  EMPTY  components floor-gears wall-gears angled-gears
    gun  0  optional  EMPTY
    heighted-object  19  authored  components box gate agent screen wall edge jammer connector floor-repeater wall-repeater
    hue  1  authored  SINGLETON
    jammer  2  authored
    jump-landing-support  2  authored  components box tray
    ladder  1  authored  SINGLETON
    location  13  authored
    los-endpoint  15  authored  components transmitter receiver floor-repeater wall-repeater gun location
    mobile-object  5  authored  components agent box jammer connector fan tray
    mode  2  authored
    plate  3  authored  components pressure-plate toggle-plate
    pressure-plate  3  authored
    reach-target  13  authored  components location switch
    receiver  1  authored  SINGLETON
    repeater  0  authored  EMPTY  components floor-repeater wall-repeater
    screen  1  authored  SINGLETON
    staircase  1  authored  SINGLETON
    support  5  authored  components pressure-plate toggle-plate box fan tray floor-blower angled-blower
    support-occupant  5  authored  components agent box jammer connector fan tray
    switch  0  optional  EMPTY
    target  9  authored  components gate floor-gears wall-gears floor-blower wall-blower gun
    threat  0  authored  EMPTY  components gun
    toggle-plate  0  optional  EMPTY
    transmitter  1  authored  SINGLETON
    tray  0  optional  EMPTY
    vaultable-object  13  authored  components gate screen wall
    vertical-object  37  authored  components location agent box connector jammer tray fan gate screen wall edge floor-repeater wall-repeater transmitter receiver gun switch pressure-plate toggle-plate floor-blower angled-blower
    visibility-object  24  authored  components gate transmitter receiver floor-repeater wall-repeater gun location
    wall  3  authored
    wall-blower  0  optional  EMPTY
    wall-gears  0  optional  EMPTY
    wall-repeater  0  optional  EMPTY
    window  1  authored  SINGLETON

  empty types (20)
    angled-blower  optional
    angled-blower+angled-gears+floor-blower+floor-gears+wall-blower+wall-gears  synthesized  alias over floor-gears wall-gears angled-gears floor-blower wall-blower angled-blower
    angled-blower+floor-blower  synthesized  alias over floor-blower angled-blower
    angled-gears  optional
    blower  authored  alias over floor-blower wall-blower angled-blower
    connector  optional
    fan  optional
    floor-blower  optional
    floor-gears  optional
    floor-repeater  optional
    gears  authored  alias over floor-gears wall-gears angled-gears
    gun  optional
    repeater  authored  alias over floor-repeater wall-repeater
    switch  optional
    threat  authored  alias over gun
    toggle-plate  optional
    tray  optional
    wall-blower  optional
    wall-gears  optional
    wall-repeater  optional

  singleton types (11)
    agent == agent1  authored
    edge == edge1  authored
    fixed-beam-sink == receiver1  authored
    fixed-beam-source == transmitter1  authored
    hue == blue  authored
    ladder == ladder1  authored
    receiver == receiver1  authored
    screen == screen1  authored
    staircase == staircase1  authored
    transmitter == transmitter1  authored
    window == window1  authored

  relations over an empty type (8 relations, 9 positions)
    blowing  dynamic  position 1 of ((either angled-blower fan floor-blower wall-blower))  empty types (angled-blower fan floor-blower
                                                                                                        wall-blower)
    latched  dynamic  position 1 of (toggle-plate)  empty type (toggle-plate)
    lethal  dynamic  position 1 of (threat)  empty type (threat)
    mounted-on  dynamic  position 2 of (fan gears)  empty type (gears)
    mounted-on  dynamic  position 1 of (fan gears)  empty type (fan)
    switched-on  dynamic  position 1 of (switch)  empty type (switch)
    turning  dynamic  position 1 of ((either angled-blower angled-gears floor-blower floor-gears wall-blower wall-gears))  empty types (angled-blower
                                                                                                                                        angled-gears
                                                                                                                                        floor-blower
                                                                                                                                        floor-gears
                                                                                                                                        wall-blower
                                                                                                                                        wall-gears)
    aimed-at  static  position 1 of ((either angled-blower angled-gears floor-blower floor-gears wall-blower wall-gears) location)  empty types (angled-blower
                                                                                                                                                 angled-gears
                                                                                                                                                 floor-blower
                                                                                                                                                 floor-gears
                                                                                                                                                 wall-blower
                                                                                                                                                 wall-gears)
    threatens  static  position 1 of (threat location)  empty type (threat)

  constant quantifier sites (9)
    blower-present  exists (?fan fan)  ->  false
    physical-supports-at  doall (?fan fan)  ->  true
    physical-supports-at  doall (?fixed (either floor-blower angled-blower))  ->  true
    physical-supports-at  doall (?tray tray)  ->  true
    reachability-coordinates-target-points  doall (?switch switch)  ->  true
    safe  exists (?t threat)  ->  false
    update-blower-status!  doall (?drive (either floor-gears wall-gears angled-gears floor-blower wall-blower angled-blower))  ->  true
    update-blower-status!  doall (?f fan)  ->  true
    update-blower-status!  doall (?fixed blower)  ->  true

  constant predicates (3)
    blower-active-for-object == false
    blower-present == false
    safe == true


S1  CONTROL ALGEBRA  [grade 1]
--------------------------------------------------------------

  control table (7 entries)
    gate2 == receiver1
    gate3 == receiver1
    gate4 == (not receiver1)
    gate6 == receiver1
    gate7 == receiver1
    gate8 == (and plate1 plate2 plate3)
    gate9 == (and plate1 plate2 plate3)

  device state axioms (1)
    open asserted by update-gate-status!
      condition  (or (exists (?j jammer) (jamming ?j ?gate)) (control-on ?gate nil))
      aggregate  (control-on ?gate nil)
      reading    state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it

  exclusion pairs (4)
    {gate2, gate4}  on ((receiver1))
    {gate3, gate4}  on ((receiver1))
    {gate4, gate6}  on ((receiver1))
    {gate4, gate7}  on ((receiver1))

  equivalence pairs (7)
    {gate2, gate3}  on ((receiver1))
    {gate2, gate6}  on ((receiver1))
    {gate2, gate7}  on ((receiver1))
    {gate3, gate6}  on ((receiver1))
    {gate3, gate7}  on ((receiver1))
    {gate6, gate7}  on ((receiver1))
    {gate8, gate9}  on ((plate1 plate2 plate3))

  pair qualification
    CONDITIONAL.  1 of 1 state axioms keep a live override open; the pairs hold only where those overrides are inactive.

  primitive controllers (4)
    plate1  ground  status relation depressed
    plate2  ground  status relation depressed
    plate3  ground  status relation depressed
    receiver1  device-mediated  status relation active

  device depth
    gate2  depth 2
    gate3  depth 2
    gate4  depth 2
    gate6  depth 2
    gate7  depth 2
    gate8  depth 1
    gate9  depth 1

  cycles: none

  notes
    receiver1 is device-mediated through its status relation active, which an update derives from another device's derived output.  The extra level is recorded; the identity of the supplying device is not decidable from the control algebra and is deferred to the sightline extractor.


S2  FUNCTIONAL-RELATION CENSUS  [grade 1 -> 2]
--------------------------------------------------------------

  functional relations (26: 5 dynamic, 21 static)
    2 bijective index relations excluded, as S0 excludes them
    aimed-at  static  key (1)  value (2)  signature ((either angled-blower angled-gears floor-blower floor-gears wall-blower wall-gears) location)
    apparatus-coords>  static  key (1)  value (2 3 4)  signature ((either floor-repeater gun receiver switch transmitter wall-repeater) rational rational rational)
    beam-via  static  key (1 3)  value (2)  signature (fixed-beam-source list fixed-beam-sink)
    boundary-wall  static  key none -- keyless global fluent  value (1)  signature (list)
    controls  static  key (2)  value (1 3)  signature (list (either angled-blower angled-gears floor-blower floor-gears gate gun wall-blower wall-gears) mode)
    edge-segment>  static  key (1)  value (2 3 4 5 6)  signature (edge rational rational rational rational rational)
    gate-segment>  static  key (1)  value (2 3 4 5 6)  signature (gate rational rational rational rational rational)
    has-chroma  static  key (1)  value (2)  signature ((either receiver transmitter) hue)
    has-elevation  static  key (1)  value (2)  signature (elevated-object rational)
    has-height  static  key (1)  value (2)  signature (heighted-object rational)
    has-location  dynamic  key (1)  value (2)  signature (mobile-object location)
    has-position  static  key (1)  value (2)  signature (fixed-position-object location)
    holding  dynamic  key none -- bijective, functional both ways  value (1 2)  signature (agent cargo)
    jamming  dynamic  key (1)  value (2)  signature (jammer target)
    location-coords>  static  key (1)  value (2 3 4)  signature (location rational rational rational)
    los-barrier-crossings>  static  key (1 3)  value (2)  signature (los-endpoint list visibility-object)
    los-via  static  key (1 3)  value (2)  signature (visibility-object list visibility-object)
    mounted-on  dynamic  key (1)  value (2)  signature (fan gears)
    on  dynamic  key (1)  value (2)  signature (support-occupant support)
    reach-via  static  key (1 3)  value (2)  signature (reach-target list reach-target)
    reach-via>  static  key (1 3)  value (2)  signature (location list reach-target)
    screen-segment>  static  key (1)  value (2 3 4 5 6)  signature (screen rational rational rational rational rational)
    traverse-via  static  key (1 3)  value (2)  signature (location list location)
    traverse-via>  static  key (1 3)  value (2)  signature (location list location)
    wall-segment>  static  key (1)  value (2 3 4 5 6)  signature (wall rational rational rational rational rational)
    window-segment>  static  key (1)  value (2 3 4 5 6)  signature (window rational rational rational rational rational)

  occupancy pools (7 placement relations; 0 layer pairs)
    aimed-at  static  (either angled-blower angled-gears floor-blower floor-gears wall-blower wall-gears) at 1  ->  location at 2
        key   pool (either angled-blower angled-gears floor-blower floor-gears wall-blower wall-gears) (0): 0 live, 0 ghost, 0 unpaired
        value pool location (13): 0 live, 0 ghost, 13 unpaired
              location1[unpaired] location10[unpaired] location11[unpaired] location12[unpaired] location13[unpaired] location2[unpaired] location3[unpaired] location4[unpaired] location5[unpaired] location6[unpaired] location7[unpaired] location8[unpaired] location9[unpaired]
    has-chroma  static  (either receiver transmitter) at 1  ->  hue at 2
        key   pool (either receiver transmitter) (2): 0 live, 0 ghost, 2 unpaired
              receiver1[unpaired] transmitter1[unpaired]
        value pool hue (1): 0 live, 0 ghost, 1 unpaired
              blue[unpaired]
    has-location  dynamic  mobile-object at 1  ->  location at 2
        key   pool mobile-object (5): 0 live, 0 ghost, 5 unpaired
              agent1[unpaired] box1[unpaired] box2[unpaired] jammer1[unpaired] jammer2[unpaired]
        value pool location (13): 0 live, 0 ghost, 13 unpaired
              members listed above
    has-position  static  fixed-position-object at 1  ->  location at 2
        key   pool fixed-position-object (4): 0 live, 0 ghost, 4 unpaired
              ladder1[unpaired] plate1[unpaired] plate2[unpaired] plate3[unpaired]
        value pool location (13): 0 live, 0 ghost, 13 unpaired
              members listed above
    jamming  dynamic  jammer at 1  ->  target at 2
        key   pool jammer (2): 0 live, 0 ghost, 2 unpaired
              jammer1[unpaired] jammer2[unpaired]
        value pool target (9): 0 live, 0 ghost, 9 unpaired
              gate1[unpaired] gate2[unpaired] gate3[unpaired] gate4[unpaired] gate5[unpaired] gate6[unpaired] gate7[unpaired] gate8[unpaired] gate9[unpaired]
    mounted-on  dynamic  fan at 1  ->  gears at 2
        key   pool fan (0): 0 live, 0 ghost, 0 unpaired
        value pool gears (0): 0 live, 0 ghost, 0 unpaired
    on  dynamic  support-occupant at 1  ->  support at 2
        key   pool support-occupant (5): 0 live, 0 ghost, 5 unpaired
              agent1[unpaired] box1[unpaired] box2[unpaired] jammer1[unpaired] jammer2[unpaired]
        value pool support (5): 0 live, 0 ghost, 5 unpaired
              box1[unpaired] box2[unpaired] plate1[unpaired] plate2[unpaired] plate3[unpaired]
        in both pools (2): box1 box2

  cardinality bounds  [grade 2: the keying is structural, so no action moves it]
    has-location: mobile-object -> location
      |occupied location| <= 5 - |unavailable mobile-object|
      injective: the relation is keyed by its mobile-object argument, so two distinct occupied values need two distinct witnesses
      BODIES by layer, not yet a claim about any predicate: live + unpaired 5, ghost + unpaired 5, total 5
      consumers (1 relation): the bound each one actually reads
        active [derived]  asserted by update-receiver-status!  via beam-reaches-receiver
          site in beam-blocker-occludes-location: OTHER -- restricted by something that is not a layer by (beam-blocker-spans-elevation ?blocker ?beam-elevation)
          site in base: NONE -- layer-blind, it reads every occupant
          site in beam-blocker-occludes-location-for-object: OTHER -- restricted by something that is not a layer by (recording-shadow-object-present ?blocker), (beam-blocker-spans-elevation ?blocker ?beam-elevation)
          witnesses it reads: 5 -- the whole pool
      NOTE: assertion side only.  A query used in an action's precondition is not listed here.
      NOTE: the switch walk descends AND, OR, NOT, IF and the queries those call.  A switch inside any other form is not found, so "no switch found" is weaker than "no switch".
      *start-state* reading, NOT the bound: 5 of 5 keys assigned, 4 distinct values occupied
    jamming: jammer -> target
      |occupied target| <= 2 - |unavailable jammer|
      injective: the relation is keyed by its jammer argument, so two distinct occupied values need two distinct witnesses
      BODIES by layer, not yet a claim about any predicate: live + unpaired 2, ghost + unpaired 2, total 2
      consumers (0 relations): the bound each one actually reads
        none: no update asserts anything under a test reading this relation
      NOTE: assertion side only.  A query used in an action's precondition is not listed here.
      NOTE: the switch walk descends AND, OR, NOT, IF and the queries those call.  A switch inside any other form is not found, so "no switch found" is weaker than "no switch".
      *start-state* reading, NOT the bound: 0 of 2 keys assigned, 0 distinct values occupied
    mounted-on: fan -> gears
      |occupied gears| <= 0 - |unavailable fan|
      injective: the relation is keyed by its fan argument, so two distinct occupied values need two distinct witnesses
      BODIES by layer, not yet a claim about any predicate: live + unpaired 0, ghost + unpaired 0, total 0
      consumers (0 relations): the bound each one actually reads
        none: no update asserts anything under a test reading this relation
      NOTE: assertion side only.  A query used in an action's precondition is not listed here.
      NOTE: the switch walk descends AND, OR, NOT, IF and the queries those call.  A switch inside any other form is not found, so "no switch found" is weaker than "no switch".
      *start-state* reading, NOT the bound: 0 of 0 keys assigned, 0 distinct values occupied
    on: support-occupant -> support
      |occupied support| <= 5 - |unavailable support-occupant|
      injective: the relation is keyed by its support-occupant argument, so two distinct occupied values need two distinct witnesses
      BODIES by layer, not yet a claim about any predicate: live + unpaired 5, ghost + unpaired 5, total 5
      consumers (3 relations): the bound each one actually reads
        active [derived]  asserted by update-receiver-status!  via beam-reaches-receiver
          site in base: NONE -- layer-blind, it reads every occupant
          witnesses it reads: 5 -- the whole pool
        depressed [derived]  asserted by update-plate-status!  via support-occupied
          site in support-occupied: NONE -- layer-blind, it reads every occupant
          witnesses it reads: 5 -- the whole pool
        latched [not derived]  asserted by update-plate-status!  via support-occupied
          site in support-occupied: NONE -- layer-blind, it reads every occupant
          witnesses it reads: 5 -- the whole pool
      NOTE: assertion side only.  A query used in an action's precondition is not listed here.
      NOTE: the switch walk descends AND, OR, NOT, IF and the queries those call.  A switch inside any other form is not found, so "no switch found" is weaker than "no switch".
      *start-state* reading, NOT the bound: 1 of 5 keys assigned, 1 distinct value occupied


T6  MECHANIZED BUDGET ARITHMETIC  [grade 1 -> 2]
--------------------------------------------------------------
  {gate8, gate9}: one shared control demand of 3 plate keepers; S1 mode/override qualifications apply.

  AM2 [grade 1 -> 2; S1 controls, S2 ON pool, goal form]: The goal actor occupies 1 of 5 bodies in the full occupant pool and its destination has no pressure plate.

  AM3a [grade 1 -> 2; S1 controls, S2 live ON pool]: Outside a cycle, 4 bodies remain for supports; demand is 3, so at least 0 support cost must close.

  AM3b [grade 1 -> 2; S1 controls, S2 full ON pool]: Inside a cycle, 4 bodies remain for supports; demand is 3, so at least 0 support cost must close.

  NOTE: these are control-demand budgets, not action-sequence proofs. No shortage follows from this pooled count.


S5  HEIGHT AND REACH LATTICE  [grade 2]
--------------------------------------------------------------
  type heights (21 types; 0 authored overrides)
    location  height 0  axis NONE  base 0
    agent  height 3/2  axis VERTICAL  base 0
    box  height 1  axis VERTICAL  base 0
    connector  height 1  axis VERTICAL  base 0
    jammer  height 1  axis VERTICAL  base 0
    tray  height 0  axis VERTICAL  base 0
    fan  height 0  axis VERTICAL  base 0
    pressure-plate  height 0  axis VERTICAL  base 0
    toggle-plate  height 0  axis VERTICAL  base 0
    floor-blower  height 0  axis VERTICAL  base 0
    angled-blower  height 0  axis VERTICAL  base 0
    gate  height 4  axis VERTICAL  base 0
    screen  height 4  axis VERTICAL  base 0
    wall  height 4  axis VERTICAL  base 0
    edge  height 3/2  axis VERTICAL  base 0
    floor-repeater  height 1  axis VERTICAL  base 0
    wall-repeater  height 1  axis HORIZONTAL  base 1
    transmitter  height 0  axis NONE  base 1
    receiver  height 0  axis NONE  base 1
    switch  height 0  axis NONE  base 1
    gun  height 0  axis NONE  base 1

  location levels
    location1  0
    location2  0
    location3  0
    location4  0
    location5  0
    location6  0
    location7  0
    location8  0
    location9  0
    location10  0
    location11  0
    location12  3/2
    location13  3/2

  achievable carried-object tops
    box1  1, 2
    box2  1, 2
    jammer1  1, 2
    jammer2  1, 2

  placement legality matrix (agent base -> support top)
    agent1 0 -> box1 1  YES
    agent1 0 -> box2 1  YES
    agent1 0 -> ground 0  YES

  unreachable from ground (placement reach limit 1)
    none


S6  BEAM SIGHTLINE TABLE  [grade 2]
--------------------------------------------------------------
  direct gate subsets: 512; no propagation applied

  visibility rows

  location-occluder kill list
    none


RC  RELAY CHAIN TABLE  [grade 2]

  SUPPLIED RELAY SCENARIO (T33): CLEAR is conditional, not stable/reachable/validated.
    PHYSICAL UNRESOLVED: no explicit scenario supplied
    RECORDING UNRESOLVED: no explicit scenario supplied
--------------------------------------------------------------
  GEOMETRIC ENUMERATION SCOPE: physical view only; supplied scenario views are separate.  Hops are
  tested on start-state copies with gate OPEN bits forced and no propagation.  A
  hop's required gates are those whose closing alone blocks it (monotone reading).
  Stations are placements, not reachability claims.  Bodies count the connector and
  its riser (ground 0, held tray 2, other support 1); a station with a plate is
  counted as keeping it, so off-plate counts are least values within this enumeration.
  GEOMETRIC CANDIDATES: stable simultaneous occupancy and support motion UNRESOLVED.
  BOOTSTRAP/LATCH are geometric classes, not validated realizations. Connector height
  is that used by station enumeration; differing connector heights are not enumerated.
  connectors 0; fixed couplings 1 (corridors reported below; mixed chains not enumerated); exclusion pairs {gate2, gate4}, {gate3, gate4}, {gate4, gate6}, {gate4, gate7}

  fixed beam corridors (1), staged physical view
    transmitter1 -> receiver1: BEAM-VIA present; authored (gate1 location2); recorded ((:gate gate1 49/128 16 5 16 10))
      gate candidates (gate1); occupancy locations (location2); chromas blue/blue; corridor clear now NIL
    Recorded barriers use finite spans and interpolated beam height; authored gates without geometry require open. Locations block only when an occupant spans that height.
    Corridor clearance is not receiver activation: matching chromas, BEAM-CUT and upstream repeater lighting also matter. Other beam routes, recording views, stability and reachability are not established.

  stations (0): location, then top (supports) per achievable connector top
    location1
    location2
    location3
    location4
    location5
    location6
    location7
    location8
    location9
    location10
    location11
    location12
    location13

  station-to-endpoint hops (0 visible)

  station-to-station hops (0 visible, 0 groups): source -> target, source>target tops, gates required

  chains to receiver1 (0); LATCH needs a device this receiver controls

  summary for receiver1
    chains 0: bootstrap 0, latch 0, excluded 0, infeasible 0
    no geometric bootstrap candidate in RC scope; receiver activation outside this scope UNRESOLVED


S7  LANDMARK GRAPH AND ORDERINGS  [grade 4]
--------------------------------------------------------------
  relaxation: delete relaxation; achieved landmarks persist.
  no simultaneous-role, keeper-return, segment, or route claim is emitted.

  explicit goal landmarks
    (has-location agent1 location11)  movement/query landmark; S1 expansion unavailable.

  S1 controller expansions
    none: the explicit goal has no controlled-device condition.

  greedy-necessary orderings
    none: route/order extraction needs a separately stated movement relaxation.


S3  GATE-LABELLED REGION QUOTIENT  [grade 2]
--------------------------------------------------------------

  traversal arcs read (49)
    48 symmetric (traverse-via), 1 directed (traverse-via>)
    kind climb: 1 arc, 0 with an empty family
    kind jump: 1 arc, 1 with an empty family
    kind stairs: 1 arc, 1 with an empty family
    kind walk: 46 arcs, 8 with an empty family

  contraction rule: two endpoints share a region when an arc of traverse-via joins them with an EMPTY door family.  Static separators -- staircases, edges, floor drives -- are not doors.  Arcs of traverse-via> are never contracted, whatever their family.
  NOTE: a region is a set of endpoints NO DOOR separates.  Each kind carries its own predicate -- a jump's reach limit, a ladder's position -- which this extractor does not evaluate, having no state to evaluate it in.  Two endpoints in one region therefore need not be mutually reachable.

  regions (6 over 13 endpoints of type location)
    R1  (2): location1 location2
    R2  (2): location10 location12
    R3  (2): location11 location13
    R4  (4): location3 location4 location5 location6
    R5  (2): location7 location8
    R6  (1): location9

  region crossings (12 rows: 12 spine, 0 composed)
    NOTE: these rows are the transitive CLOSURE, one minimal door-set per location pair. The spine preserves reachability; it is not a physical doorway count.
    R1 <-> R2  kind walk  family ((gate1 gate5 gate6 gate7) (gate2 gate5 gate6 gate7))  2 location arcs  SPINE
    R1 <-> R4  kind walk  family ((gate1 gate3) (gate1 gate5) (gate2 gate3) (gate2 gate5))  8 location arcs  SPINE
    R1 <-> R5  kind walk  family ((gate1 gate3 gate4 screen1) (gate1 gate4 gate5 screen1) (gate2 gate3 gate4 screen1) (gate2 gate4 gate5 screen1))  4 location arcs  SPINE
    R1 <-> R6  kind walk  family ((gate1 gate5) (gate2 gate5))  2 location arcs  SPINE
    R2 <-> R3  kind walk  family ((gate8 gate9))  1 location arc  SPINE
    R2 <-> R4  kind walk  family ((gate5 gate6 gate7))  4 location arcs  SPINE
    R2 <-> R5  kind walk  family ((gate4 gate5 gate6 gate7 screen1))  2 location arcs  SPINE
    R2 <-> R6  kind walk  family ((gate6 gate7))  1 location arc  SPINE
    R4 <-> R5  kind walk  family ((gate4 screen1))  8 location arcs  SPINE
    R4 <-> R6  kind walk  family ((gate5))  4 location arcs  SPINE
    R5 --> R1  kind climb  family ((ladder1))  1 location arc  SPINE
    R5 <-> R6  kind walk  family ((gate4 gate5 screen1))  2 location arcs  SPINE

  adjacency spine (12)
    R1 <-> R2  kind walk  family ((gate1 gate5 gate6 gate7) (gate2 gate5 gate6 gate7))
    R1 <-> R4  kind walk  family ((gate1 gate3) (gate1 gate5) (gate2 gate3) (gate2 gate5))
    R1 <-> R5  kind walk  family ((gate1 gate3 gate4 screen1) (gate1 gate4 gate5 screen1) (gate2 gate3 gate4 screen1) (gate2 gate4 gate5 screen1))
    R1 <-> R6  kind walk  family ((gate1 gate5) (gate2 gate5))
    R2 <-> R3  kind walk  family ((gate8 gate9))
    R2 <-> R4  kind walk  family ((gate5 gate6 gate7))
    R2 <-> R5  kind walk  family ((gate4 gate5 gate6 gate7 screen1))
    R2 <-> R6  kind walk  family ((gate6 gate7))
    R4 <-> R5  kind walk  family ((gate4 screen1))
    R4 <-> R6  kind walk  family ((gate5))
    R5 --> R1  kind climb  family ((ladder1))
    R5 <-> R6  kind walk  family ((gate4 gate5 screen1))

  doors on arcs (11)
    gate1 gate2 gate3 gate4 gate5 gate6 gate7 gate8 gate9 ladder1 screen1

  controlled devices labelling NO traversal arc (0 of 7)
    none: every controlled device gates some crossing
    READING: such a device is movement-irrelevant, meaning that no traversal clause names it.  It is NOT a claim that the device is inert -- a device may act on objects rather than on passage -- and it is NOT a claim about reaching, which a separate relation carries and this extractor does not read.

  doors that are NOT controlled devices (4)
    gate1 gate5 ladder1 screen1
    these are obstacles with no CONTROLS entry, so no plate or switch opens them and S1's algebra says nothing about them.


S4  CUT-KEEPER TABLE  [conditional bounds; graph candidates]
--------------------------------------------------------------
  SCOPE: graph reachability relaxes all other doors, elevation and cargo conditions.
  It omits non-traversal relocation, support transitions and recorder lifecycle.
  Graph cuts and approach-only regions therefore do NOT prove concrete stranding.
  Pressure counts require ON's functional key and the relevant view's occupancy semantics.
  Device-state conclusions additionally require the printed S1 axiom premises.

  controlled devices (7); spine rows (12); spine check :VERIFIED-AGAINST-QUOTIENT
  alternative door families: using the unreduced quotient; any clause avoiding the forbidden device permits a row.

    gate2 == receiver1
      state open: state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it; empty-type premises nil
      controller receiver1: RECEIVER; position unresolved; region UNRESOLVED
        beam dependency unresolved; requires sightline analysis.
      positive pressure alternatives (nil); individually mandatory nil
      conditional shortage: available eligible ON witnesses < 0 implies
        this normal aggregate cannot activate (minimum simultaneous plate demand).
      spine kind walk, family ((gate1 gate5 gate6 gate7) (gate2 gate5 gate6 gate7))
        R1 -> R2, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
        R2 -> R1, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
      spine kind walk, family ((gate1 gate3) (gate1 gate5) (gate2 gate3) (gate2 gate5))
        R1 -> R4, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
        R4 -> R1, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
      spine kind walk, family ((gate1 gate3 gate4 screen1) (gate1 gate4 gate5 screen1) (gate2 gate3 gate4 screen1) (gate2 gate4 gate5 screen1))
        R1 -> R5, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
        R5 -> R1, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
      spine kind walk, family ((gate1 gate5) (gate2 gate5))
        R1 -> R6, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
        R6 -> R1, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists

    gate3 == receiver1
      state open: state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it; empty-type premises nil
      controller receiver1: RECEIVER; position unresolved; region UNRESOLVED
        beam dependency unresolved; requires sightline analysis.
      positive pressure alternatives (nil); individually mandatory nil
      conditional shortage: available eligible ON witnesses < 0 implies
        this normal aggregate cannot activate (minimum simultaneous plate demand).
      spine kind walk, family ((gate1 gate3) (gate1 gate5) (gate2 gate3) (gate2 gate5))
        R1 -> R4, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
        R4 -> R1, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
      spine kind walk, family ((gate1 gate3 gate4 screen1) (gate1 gate4 gate5 screen1) (gate2 gate3 gate4 screen1) (gate2 gate4 gate5 screen1))
        R1 -> R5, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists
        R5 -> R1, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: NO, bypass exists

    gate4 == (not receiver1)
      state open: state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it; empty-type premises nil
      controller receiver1: RECEIVER; position unresolved; region UNRESOLVED
        beam dependency unresolved; requires sightline analysis.
      positive pressure alternatives nil; individually mandatory nil
      inverted aggregate: no positive keeper demand inferred.
      spine kind walk, family ((gate1 gate3 gate4 screen1) (gate1 gate4 gate5 screen1) (gate2 gate3 gate4 screen1) (gate2 gate4 gate5 screen1))
        R1 -> R5, device absent: source reaches ("R1" "R2" "R3" "R4" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: YES
        R5 -> R1, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R6")
          graph cut in this direction: NO, bypass exists
      spine kind walk, family ((gate4 gate5 gate6 gate7 screen1))
        R2 -> R5, device absent: source reaches ("R1" "R2" "R3" "R4" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: YES
        R5 -> R2, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R6")
          graph cut in this direction: NO, bypass exists
      spine kind walk, family ((gate4 screen1))
        R4 -> R5, device absent: source reaches ("R1" "R2" "R3" "R4" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: YES
        R5 -> R4, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R6")
          graph cut in this direction: NO, bypass exists
      spine kind walk, family ((gate4 gate5 screen1))
        R5 -> R6, device absent: source reaches ("R1" "R2" "R3" "R4" "R5" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R6")
          graph cut in this direction: NO, bypass exists
        R6 -> R5, device absent: source reaches ("R1" "R2" "R3" "R4" "R6"); destination reaches ("R1" "R2" "R3" "R4" "R5" "R6")
          graph cut in this direction: YES

    gate6 == receiver1
      state open: state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it; empty-type premises nil
      controller receiver1: RECEIVER; position unresolved; region UNRESOLVED
        beam dependency unresolved; requires sightline analysis.
      positive pressure alternatives (nil); individually mandatory nil
      conditional shortage: available eligible ON witnesses < 0 implies
        this normal aggregate cannot activate (minimum simultaneous plate demand).
      spine kind walk, family ((gate1 gate5 gate6 gate7) (gate2 gate5 gate6 gate7))
        R1 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES
        R2 -> R1, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
      spine kind walk, family ((gate5 gate6 gate7))
        R2 -> R4, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
        R4 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES
      spine kind walk, family ((gate4 gate5 gate6 gate7 screen1))
        R2 -> R5, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
        R5 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES
      spine kind walk, family ((gate6 gate7))
        R2 -> R6, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
        R6 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES

    gate7 == receiver1
      state open: state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it; empty-type premises nil
      controller receiver1: RECEIVER; position unresolved; region UNRESOLVED
        beam dependency unresolved; requires sightline analysis.
      positive pressure alternatives (nil); individually mandatory nil
      conditional shortage: available eligible ON witnesses < 0 implies
        this normal aggregate cannot activate (minimum simultaneous plate demand).
      spine kind walk, family ((gate1 gate5 gate6 gate7) (gate2 gate5 gate6 gate7))
        R1 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES
        R2 -> R1, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
      spine kind walk, family ((gate5 gate6 gate7))
        R2 -> R4, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
        R4 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES
      spine kind walk, family ((gate4 gate5 gate6 gate7 screen1))
        R2 -> R5, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
        R5 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES
      spine kind walk, family ((gate6 gate7))
        R2 -> R6, device absent: source reaches ("R2" "R3"); destination reaches ("R1" "R4" "R5" "R6")
          graph cut in this direction: YES
        R6 -> R2, device absent: source reaches ("R1" "R4" "R5" "R6"); destination reaches ("R2" "R3")
          graph cut in this direction: YES

    gate8 == (and plate1 plate2 plate3)
      state open: state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it; empty-type premises nil
      controller plate1: PRESSURE; position location4; region R4
      controller plate2: PRESSURE; position location5; region R4
      controller plate3: PRESSURE; position location6; region R4
      positive pressure alternatives ((plate1 plate2 plate3)); individually mandatory (plate1 plate2 plate3)
      conditional shortage: available eligible ON witnesses < 3 implies
        this normal aggregate cannot activate (minimum simultaneous plate demand).
      spine kind walk, family ((gate8 gate9))
        R2 -> R3, device absent: source reaches ("R1" "R2" "R4" "R5" "R6"); destination reaches ("R3")
          graph cut in this direction: YES
          mandatory pressure plate1 at R4: APPROACH-ONLY
            KEEPER-OBLIGATED candidate while device state requires this aggregate;
            permanent stranding UNRESOLVED (movement and lifecycle coverage).
          mandatory pressure plate2 at R4: APPROACH-ONLY
            KEEPER-OBLIGATED candidate while device state requires this aggregate;
            permanent stranding UNRESOLVED (movement and lifecycle coverage).
          mandatory pressure plate3 at R4: APPROACH-ONLY
            KEEPER-OBLIGATED candidate while device state requires this aggregate;
            permanent stranding UNRESOLVED (movement and lifecycle coverage).
        R3 -> R2, device absent: source reaches ("R3"); destination reaches ("R1" "R2" "R4" "R5" "R6")
          graph cut in this direction: YES
          mandatory pressure plate1 at R4: DEPARTURE-ONLY
          mandatory pressure plate2 at R4: DEPARTURE-ONLY
          mandatory pressure plate3 at R4: DEPARTURE-ONLY

    gate9 == (and plate1 plate2 plate3)
      state open: state == override OR aggregate -- OVERRIDE LIVE, every claim below is conditional on it; empty-type premises nil
      controller plate1: PRESSURE; position location4; region R4
      controller plate2: PRESSURE; position location5; region R4
      controller plate3: PRESSURE; position location6; region R4
      positive pressure alternatives ((plate1 plate2 plate3)); individually mandatory (plate1 plate2 plate3)
      conditional shortage: available eligible ON witnesses < 3 implies
        this normal aggregate cannot activate (minimum simultaneous plate demand).
      spine kind walk, family ((gate8 gate9))
        R2 -> R3, device absent: source reaches ("R1" "R2" "R4" "R5" "R6"); destination reaches ("R3")
          graph cut in this direction: YES
          mandatory pressure plate1 at R4: APPROACH-ONLY
            KEEPER-OBLIGATED candidate while device state requires this aggregate;
            permanent stranding UNRESOLVED (movement and lifecycle coverage).
          mandatory pressure plate2 at R4: APPROACH-ONLY
            KEEPER-OBLIGATED candidate while device state requires this aggregate;
            permanent stranding UNRESOLVED (movement and lifecycle coverage).
          mandatory pressure plate3 at R4: APPROACH-ONLY
            KEEPER-OBLIGATED candidate while device state requires this aggregate;
            permanent stranding UNRESOLVED (movement and lifecycle coverage).
        R3 -> R2, device absent: source reaches ("R3"); destination reaches ("R1" "R2" "R4" "R5" "R6")
          graph cut in this direction: YES
          mandatory pressure plate1 at R4: DEPARTURE-ONLY
          mandatory pressure plate2 at R4: DEPARTURE-ONLY
          mandatory pressure plate3 at R4: DEPARTURE-ONLY

  explicit goal destinations (1); goal form (has-location agent1 location11)
    agent1: location1 (R1) -> location11 (R3)
      GRAPH-REQUIRED candidates (gate6 gate7 gate8 gate9); concrete necessity UNRESOLVED.
    jammer1: initially location1; no explicit destination, crossings UNRESOLVED.
    jammer2: initially location9; no explicit destination, crossings UNRESOLVED.
    box1: initially location4; no explicit destination, crossings UNRESOLVED.
    box2: initially location10; no explicit destination, crossings UNRESOLVED.

  keeper supply from S2
    on: support-occupant -> support
      |occupied support| <= 5 - |unavailable support-occupant|
      injective: the relation is keyed by its support-occupant argument, so two distinct occupied values need two distinct witnesses
      BODIES by layer, not yet a claim about any predicate: live + unpaired 5, ghost + unpaired 5, total 5
      consumers (3 relations): the bound each one actually reads
        active [derived]  asserted by update-receiver-status!  via beam-reaches-receiver
          site in base: NONE -- layer-blind, it reads every occupant
          witnesses it reads: 5 -- the whole pool
        depressed [derived]  asserted by update-plate-status!  via support-occupied
          site in support-occupied: NONE -- layer-blind, it reads every occupant
          witnesses it reads: 5 -- the whole pool
        latched [not derived]  asserted by update-plate-status!  via support-occupied
          site in support-occupied: NONE -- layer-blind, it reads every occupant
          witnesses it reads: 5 -- the whole pool
      NOTE: assertion side only.  A query used in an action's precondition is not listed here.
      NOTE: the switch walk descends AND, OR, NOT, IF and the queries those call.  A switch inside any other form is not found, so "no switch found" is weaker than "no switch".
      *start-state* reading, NOT the bound: 1 of 5 keys assigned, 1 distinct value occupied
    Available eligible witnesses are a parameter for each view and segment.
    Total sequential crossers are NOT simultaneous body demand.

  UNCONDITIONAL STRANDING: unresolved; no verdict emitted.


CC  COUPLING CENSUS  [grade 1; occluder role grade 2]
--------------------------------------------------------------
  subsystems: route (barrier), beam (occluder, beam-driven), lift (lift), transport (horizontal-transport, transport), occupancy (support-controller)

  role table (11 objects)
    gate2  device  barrier  subsystems route
    gate3  device  barrier  subsystems route
    gate4  device  barrier  subsystems route
    gate6  device  barrier  subsystems route
    gate7  device  barrier  subsystems route
    gate8  device  barrier  subsystems route
    gate9  device  barrier  subsystems route
    plate1  primitive  support-controller  subsystems occupancy
    plate2  primitive  support-controller  subsystems occupancy
    plate3  primitive  support-controller  subsystems occupancy
    receiver1  primitive  beam-driven  subsystems beam

  K1 fan-out (4)
    plate1  subsystems route occupancy
      gate8 == (and plate1 plate2 plate3)  barrier
      gate9 == (and plate1 plate2 plate3)  barrier
      {gate8, gate9}  EQUIVALENCE
    plate2  subsystems route occupancy
      gate8 == (and plate1 plate2 plate3)  barrier
      gate9 == (and plate1 plate2 plate3)  barrier
      {gate8, gate9}  EQUIVALENCE
    plate3  subsystems route occupancy
      gate8 == (and plate1 plate2 plate3)  barrier
      gate9 == (and plate1 plate2 plate3)  barrier
      {gate8, gate9}  EQUIVALENCE
    receiver1  subsystems route beam
      gate2 == receiver1  barrier
      gate3 == receiver1  barrier
      gate4 == (not receiver1)  barrier
      gate6 == receiver1  barrier
      gate7 == receiver1  barrier
      {gate2, gate3}  EQUIVALENCE
      {gate2, gate4}  EXCLUSION
      {gate2, gate6}  EQUIVALENCE
      {gate2, gate7}  EQUIVALENCE
      {gate3, gate4}  EXCLUSION
      {gate3, gate6}  EQUIVALENCE
      {gate3, gate7}  EQUIVALENCE
      {gate4, gate6}  EXCLUSION
      {gate4, gate7}  EXCLUSION
      {gate6, gate7}  EQUIVALENCE

  K2 multi-role (0)
    none

  K3 beam feedback (1)
    receiver1  drives gate2 gate3 gate4 gate6 gate7
      no RC hops

  G15 lift-barrier couplings (0)
    none


NH  NECESSITY HINTS  [grade per hint]

  SUPPLIED RELAY SCENARIO (T33): CLEAR is conditional, not stable/reachable/validated.
    PHYSICAL UNRESOLVED: no explicit scenario supplied
    RECORDING UNRESOLVED: no explicit scenario supplied
--------------------------------------------------------------
  READING: a hint restates static limits as a candidate plan element for the Briefing (Problem-Solving Guide, Phase 1 step 3).  NECESSARY: every plan meets it, under the grade shown.  CANDIDATE: one way to meet a limit; others may exist.  A hint is not a plan, and a graph candidate is not a proof.

  hints (8): 6 NECESSARY, 2 CANDIDATE

  H1 body budget (0)
    none

  H2 keepers left behind (2)
    H2.1  NECESSARY  [grade 2, graph candidate; S4 S1]
      limit  crossing gate8 from R2 {location10 location12} to R3 {location11 location13} needs plate1, plate2, plate3 held; they lie on the R2 side only (approach-only)
      hint   before crossing gate8 into R3, leave 3 bodies other than the crosser on plate1, plate2, plate3 (goal route)
      note   coming back from R3 to R2 through gate8 needs the same plates held: the bodies stay until the crosser returns
    H2.2  NECESSARY  [grade 2, graph candidate; S4 S1]
      limit  crossing gate9 from R2 {location10 location12} to R3 {location11 location13} needs plate1, plate2, plate3 held; they lie on the R2 side only (approach-only)
      hint   before crossing gate9 into R3, leave 3 bodies other than the crosser on plate1, plate2, plate3 (goal route)
      note   coming back from R3 to R2 through gate9 needs the same plates held: the bodies stay until the crosser returns

  H3 beam-held devices (5)
    H3.1  NECESSARY  [grade 2; S1 RC]
      limit  gate2 == receiver1 holds only while receiver1 is active; within RC's enumerated physical geometric candidates, every chain to receiver1 (0 bootstrap, 0 latch) needs no common gate
      hint   while gate2 must hold, RC implies nothing further
      note   S1's receiver condition is necessary; RC gate/body bounds are conditional on its physical geometric enumeration, not all recording-view beams
      note   Recording sightlines, body/view assignment, forced transport and occupancy stability UNRESOLVED; geometric chains are not validated realizations
    H3.2  NECESSARY  [grade 2; S1 RC]
      limit  gate3 == receiver1 holds only while receiver1 is active; within RC's enumerated physical geometric candidates, every chain to receiver1 (0 bootstrap, 0 latch) needs no common gate
      hint   while gate3 must hold, RC implies nothing further
      note   S1's receiver condition is necessary; RC gate/body bounds are conditional on its physical geometric enumeration, not all recording-view beams
      note   Recording sightlines, body/view assignment, forced transport and occupancy stability UNRESOLVED; geometric chains are not validated realizations
    H3.3  NECESSARY  [grade 2; S1 RC]
      limit  gate6 == receiver1 holds only while receiver1 is active; within RC's enumerated physical geometric candidates, every chain to receiver1 (0 bootstrap, 0 latch) needs no common gate
      hint   while gate6 must hold, RC implies nothing further
      note   S1's receiver condition is necessary; RC gate/body bounds are conditional on its physical geometric enumeration, not all recording-view beams
      note   Recording sightlines, body/view assignment, forced transport and occupancy stability UNRESOLVED; geometric chains are not validated realizations
    H3.4  NECESSARY  [grade 2; S1 RC]
      limit  gate7 == receiver1 holds only while receiver1 is active; within RC's enumerated physical geometric candidates, every chain to receiver1 (0 bootstrap, 0 latch) needs no common gate
      hint   while gate7 must hold, RC implies nothing further
      note   S1's receiver condition is necessary; RC gate/body bounds are conditional on its physical geometric enumeration, not all recording-view beams
      note   Recording sightlines, body/view assignment, forced transport and occupancy stability UNRESOLVED; geometric chains are not validated realizations
    H3.5  CANDIDATE  [grade 1; fixed corridor, staged physical view]
      limit  fixed transmitter1 -> receiver1: gate candidates (gate1); occupancy locations (location2)
      hint   check the fixed corridor's recorded barriers and authored obstacles in RC before assigning connector roles
      note   Gates block only at the beam's height; location occupants must span it. Matching chromas, BEAM-CUT and upstream lighting also matter; other routes may activate the receiver. No reachability, recording-view or stability claim.

  H4 controllers off the goal route (0)
    none

  H5 lift landings (0)
    none

  H6 active at the start (1)
    H6.1  CANDIDATE  [grade 1; S1, start state]
      limit  gate4 == (not receiver1) holds at the start: receiver1 is not active
      hint   gate4 is free until receiver1 changes (off the goal route)

  H7 placement limits (0)
    none


SD  SERVICES AND SETUP DEPENDENCIES  [grade 2]
--------------------------------------------------------------
  SCOPE: a monotone premise closure over passage services (every gate; each drive a traversal clause names) and receiver literals.  Providers: S1 CONTROL options, MC jam sites (OVERRIDE), gears with no fan (EQUIPMENT), RC chains and fixed corridors to a receiver.  No ordering, simultaneity, bodies, reach, occupancy or view is checked.
  CLASSES: DIRECT no premise; SUPPORTED premises available without this service; NEEDS <service> FIRST: installing this provider needs the service it will provide (a setup dependency); UNSUPPORTED IN SCOPE.  A service with only NEEDS-FIRST options is a SETUP QUESTION, not an impossibility.  "Through standing providers" repeats the test with premises supplied only by CONTROL, chains, corridors and equipment, never another jam, and is printed when that exposes a setup dependency a further jammer would hide.

  goal actor agent1: start location1 (R1) -> goal location11 (R3)
    transit door sets (R1 -> R3, 2): (gate1 gate5 gate6 gate7 gate8 gate9) (gate2 gate5 gate6 gate7 gate8 gate9)
      necessary: gate5 gate6 gate7 gate8 gate9
    return door sets (R3 -> R1, 3): (gate1 gate5 gate6 gate7 gate8 gate9) (gate2 gate5 gate6 gate7 gate8 gate9) (gate4 gate5 gate6 gate7 gate8 gate9 ladder1 screen1)
      necessary: gate5 gate6 gate7 gate8 gate9
    final services: none (the goal names no receiver or controlled device)
    temporary services (in some transit set, not final): gate1, gate2 via receiver1, gate5, gate6 via receiver1, gate7 via receiver1, gate8 via plate1 plate2 plate3, gate9 via plate1 plate2 plate3
      READING: TEMPORARY means needed while crossing and expendable afterward, unless a return or a later crossing needs it again.

  access from R1 (minimal door sets to each region; kind predicates not evaluated)
    R1  ()
    R2  (gate1 gate5 gate6 gate7) (gate2 gate5 gate6 gate7)
    R3  (gate1 gate5 gate6 gate7 gate8 gate9) (gate2 gate5 gate6 gate7 gate8 gate9)
    R4  (gate1 gate3) (gate1 gate5) (gate2 gate3) (gate2 gate5)
    R5  (gate1 gate3 gate4 screen1) (gate1 gate4 gate5 screen1) (gate2 gate3 gate4 screen1) (gate2 gate4 gate5 screen1)
    R6  (gate1 gate5) (gate2 gate5)

  retrieval (start places of jammers, connectors and fans)
    jammer1  location1 (R1)
    jammer2  location9 (R6)

  services (10): 10 SUPPORTED, 0 SETUP QUESTION, 0 NO PROVIDER IN SCOPE
    gate1 open  start BLOCKED  verdict SUPPORTED  route TRANSIT alternative, RETURN alternative, TEMPORARY
      no controller: override or equipment only
      OVERRIDE DIRECT: no premise
        jam at location1 on ground (jammer1, jammer2)
        jam at location2 on ground (jammer1, jammer2); OCCUPIES location2 on transmitter1 -> receiver1's fixed corridor, which needs gate1
        jam at location7 on ground (jammer1, jammer2); JAM-DISALLOWED> from location1
      OVERRIDE SUPPORTED; through standing providers NEEDS gate1 open FIRST (path gate2 open -> receiver1 active -> gate1 open): gate2 open; gate3 open
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
    gate2 open  == receiver1  start BLOCKED  verdict SUPPORTED  route TRANSIT alternative, RETURN alternative, TEMPORARY
      CONTROL SUPPORTED: receiver1 active
      OVERRIDE DIRECT: no premise
        jam at location1 on ground (jammer1, jammer2)
        jam at location2 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate3 open; gate5 open; gate6 open; gate7 open
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate3 open; gate5 open; gate6 open; gate7 open; gate8 open; gate9 open
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate3 open
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate3 open; gate5 open
        jam at location9 on ground (jammer1, jammer2)
    gate3 open  == receiver1  start BLOCKED  verdict SUPPORTED
      CONTROL SUPPORTED: receiver1 active
      OVERRIDE SUPPORTED: gate2 open
        jam at location1 on ground (jammer1, jammer2)
        jam at location2 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open; gate6 open; gate7 open
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open; gate6 open; gate7 open; gate8 open; gate9 open
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE DIRECT: no premise
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open
        jam at location9 on ground (jammer1, jammer2)
    gate4 open  == (not receiver1)  start PASSABLE  verdict SUPPORTED  route RETURN alternative
      CONTROL DIRECT: receiver1 inactive
      OVERRIDE DIRECT: no premise
        jam at location1 on ground (jammer1, jammer2); JAM-DISALLOWED> from location7
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
        jam at location7 on ground (jammer1, jammer2)
        jam at location8 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open; gate6 open; gate7 open
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open; gate6 open; gate7 open; gate8 open; gate9 open
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open
        jam at location9 on ground (jammer1, jammer2)
    gate5 open  start BLOCKED  verdict SUPPORTED  route TRANSIT necessary, RETURN necessary, TEMPORARY
      no controller: override or equipment only
      OVERRIDE SUPPORTED: gate2 open; gate3 open
        jam at location1 on ground (jammer1, jammer2)
        jam at location2 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate6 open; gate7 open
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate6 open; gate7 open; gate8 open; gate9 open
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE DIRECT: no premise
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
        jam at location9 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate4 open
        jam at location8 on ground (jammer1, jammer2)
    gate6 open  == receiver1  start BLOCKED  verdict SUPPORTED  route TRANSIT necessary, RETURN necessary, TEMPORARY
      CONTROL SUPPORTED: receiver1 active
      OVERRIDE SUPPORTED: gate7 open
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location11 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate7 open; gate8 open; gate9 open
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate2 open; gate3 open; gate5 open
        jam at location2 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate4 open; gate5 open
        jam at location8 on ground (jammer1, jammer2)
      OVERRIDE DIRECT: no premise
        jam at location9 on ground (jammer1, jammer2)
    gate7 open  == receiver1  start BLOCKED  verdict SUPPORTED  route TRANSIT necessary, RETURN necessary, TEMPORARY
      CONTROL SUPPORTED: receiver1 active
      OVERRIDE DIRECT: no premise
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location11 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate8 open; gate9 open
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate2 open; gate3 open; gate5 open; gate6 open
        jam at location2 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open; gate6 open
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate4 open; gate5 open; gate6 open
        jam at location8 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate6 open
        jam at location9 on ground (jammer1, jammer2)
    gate8 open  == (and plate1 plate2 plate3)  start BLOCKED  verdict SUPPORTED  route TRANSIT necessary, RETURN necessary, TEMPORARY
      CONTROL DIRECT: a body on plate1 (T6); a body on plate2 (T6); a body on plate3 (T6)
      OVERRIDE DIRECT: no premise
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate9 open
        jam at location11 on ground (jammer1, jammer2)
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate2 open; gate3 open; gate5 open; gate6 open; gate7 open
        jam at location2 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open; gate6 open; gate7 open
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate4 open; gate5 open; gate6 open; gate7 open
        jam at location8 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate6 open; gate7 open
        jam at location9 on ground (jammer1, jammer2)
    gate9 open  == (and plate1 plate2 plate3)  start BLOCKED  verdict SUPPORTED  route TRANSIT necessary, RETURN necessary, TEMPORARY
      CONTROL DIRECT: a body on plate1 (T6); a body on plate2 (T6); a body on plate3 (T6)
      OVERRIDE SUPPORTED: gate8 open
        jam at location10 on box2 (jammer1, jammer2)
        jam at location10 on ground (jammer1, jammer2)
        jam at location12 on ground (jammer1, jammer2)
      OVERRIDE DIRECT: no premise
        jam at location11 on ground (jammer1, jammer2)
        jam at location13 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate2 open; gate3 open; gate5 open; gate6 open; gate7 open; gate8 open
        jam at location2 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate5 open; gate6 open; gate7 open; gate8 open
        jam at location3 on ground (jammer1, jammer2)
        jam at location4 on box1 (jammer1, jammer2)
        jam at location4 on ground (jammer1, jammer2)
        jam at location4 on plate1 (jammer1, jammer2)
        jam at location5 on ground (jammer1, jammer2)
        jam at location5 on plate2 (jammer1, jammer2)
        jam at location6 on ground (jammer1, jammer2)
        jam at location6 on plate3 (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate4 open; gate5 open; gate6 open; gate7 open; gate8 open
        jam at location8 on ground (jammer1, jammer2)
      OVERRIDE SUPPORTED: gate6 open; gate7 open; gate8 open
        jam at location9 on ground (jammer1, jammer2)
    receiver1 active  start INACTIVE  verdict SUPPORTED
      CORRIDOR SUPPORTED: fixed transmitter1 -> receiver1; gate1 open; location2 clear

  opposed controls (a primitive needed in both states by different services)
    receiver1: on for gate2, gate3, gate6, gate7; off for gate4

  setup dependencies (options whose premises lead back to their own service)
    gate1 open: 8 options, 0 even with further jams
    setup questions: none

  NOT CLAIMED: an order, simultaneous availability, a body or reach allocation, occupancy, view or a realized setup.  A premise-free provider still needs placing, and a NEEDS-FIRST provider needs another provider in force while it is installed (a handover).  Access is to a site's own region; placement or pickup from another location within reach is not modelled.  For concrete consequences use REPORT-SERVICE-TRANSITION on two settled states.
RO requires an explicit segment input and is not generated; call
REPORT-ROLE-OBLIGATIONS with a stated scenario.
