Spaces:
Running
Running
Download python/borderland_verify/reference.py from FatUnc6969/borderland-rl: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/spaces/FatUnc6969/borderland-rl/resolve/main/python/borderland_verify/reference.py
- Command line
-
hf download hf://spaces/FatUnc6969/borderland-rl/python/borderland_verify/reference.py
-
curl -L -o reference.py https://huggingface.co/spaces/FatUnc6969/borderland-rl/resolve/main/python/borderland_verify/reference.py
11.9 kB
| from __future__ import annotations | |
| import json | |
| from borderland import Action, Campaign | |
| class LegalReference: | |
| """History-aware scripted controller. Its only input is public transitions.""" | |
| def __init__(self): | |
| self.facts = {} | |
| self.records = {} | |
| self.seen_pages = set() | |
| self.compared = set() | |
| self.rule_stage = 0 | |
| self.osmosis_stage = 0 | |
| self.route = None | |
| self.observed_reactions = [] | |
| self._last_observation = None | |
| def _ingest(self,t): | |
| o=t.observation.to_dict(); b=o['board'] | |
| if self._last_observation==o: | |
| return o,b | |
| self._last_observation=o | |
| if o['phase']==1 and b['fixture']=='sensor' and b['live_sensor'] is not None: | |
| bit=b['live_sensor']^(b['latch']&1) | |
| self.facts['bus']=('west','east')[bit] | |
| self.facts['valve']=('west','east')[bit] | |
| if o['phase']==3 and b.get('records'): | |
| self.seen_pages.add((b['slot'],b['page'])) | |
| for rec in b['records']: | |
| previous=self.records.get(rec['id']) | |
| if rec['authenticated'] and (previous is None or rec['issued_at']>previous['issued_at']): | |
| self.records[rec['id']]=rec | |
| for subject in ('restoration','authorization','egress'): | |
| choices=[record for record in self.records.values() if record['subject']==subject] | |
| if not choices: continue | |
| rec=max(choices,key=lambda record:record['issued_at']) | |
| self.facts['record_'+subject]=rec['id'] | |
| if subject=='restoration': self.facts['order']=rec['statement'].split('>') | |
| elif subject=='authorization': self.facts['witness'],self.facts['seal']=rec['statement'].split('/') | |
| else: self.facts['track']=int(rec['statement']) | |
| if o['phase']==4: | |
| self.observed_reactions.append(b['reaction']) | |
| note=o['notebook']['text'] | |
| if t.context_reset and note: | |
| self.facts=json.loads(note) | |
| return o,b | |
| def notebook(self,t): | |
| self._ingest(t) | |
| text=json.dumps(self.facts,sort_keys=True,separators=(',',':')) | |
| return text if text!=t.observation.notebook['text'] else None | |
| def choose(self,t): | |
| o,b=self._ingest(t) | |
| phase=o['phase'] | |
| def a(tag,**args): return Action(tag,args) | |
| if phase==1: | |
| sequence=[a('set_latch',value=0),a('pulse',fixture='sensor'),a('observe_sensor'),a('set_latch',value=1),a('pulse',fixture='sensor'),a('observe_sensor')] | |
| if self.rule_stage<len(sequence): | |
| result=sequence[self.rule_stage]; self.rule_stage+=1; return result | |
| sequence2=[a('set_latch',value=2+(self.facts['bus']=='east')),a('pulse',fixture='relay'),a('pulse',fixture='gate'),a('lock_chamber')] | |
| result=sequence2[self.rule_stage-len(sequence)]; self.rule_stage+=1; return result | |
| if phase==2: | |
| target=2 if 'bridge_rig' not in o['inventory'] and 'relay_cell' not in o['inventory'] and b['rotation']%2==0 else 4 if 'bridge_rig' not in o['inventory'] and 'relay_cell' not in o['inventory'] else 8 | |
| if b['cell']==target: | |
| return a('leave_maze') if target==8 else a('collect') | |
| if not b['scanned']: return a('scan') | |
| cell=b['cell'] | |
| route = [0,1,2,5,8] if target==2 or 'bridge_rig' in o['inventory'] else [0,1,4,5,8] | |
| if target in (2,4): route=route[:route.index(target)+1] | |
| destination=route[route.index(cell)+1] | |
| direction={1:'east',3:'south',-1:'west',-3:'north'}[destination-cell] | |
| if a('walk',direction=direction) not in t.legal_actions: return a('wait') | |
| return a('walk',direction=direction) | |
| if phase==3: | |
| for slot in range(6): | |
| if (slot,0) not in self.seen_pages: return a('open_scroll',slot=slot) | |
| if b['slot']==slot and b['page']+1<b['page_count']: return a('advance_page') | |
| for subject in ('restoration','authorization','egress'): | |
| new=self.records[self.facts['record_'+subject]] | |
| if subject not in self.compared: | |
| self.compared.add(subject) | |
| return a('compare_seal',left_id=new['supersedes'],right_id=new['id']) | |
| return a('bind_docket',record_ids=[self.facts['record_'+x] for x in ('restoration','authorization','egress')]) | |
| if phase==4: | |
| if b['contest_over']: return a('end_osmosis') | |
| runner=next(x for x in b['allies'] if x['actor']=='Ada') | |
| if self.route is None: self.route='bridge' if b['bridge_available'] else 'relay' | |
| if self.osmosis_stage==0: | |
| self.osmosis_stage=1 | |
| return a('feint',actor='Bo',lane='east') | |
| if 'opponent_pattern' not in self.facts: | |
| guard=next(x for x in b['enemies'] if x['actor']=='guard') | |
| self.facts['opponent_pattern']='majority' if guard['node']=='east' else 'minority' | |
| desired='west' if self.route=='bridge' else 'east' | |
| if self.osmosis_stage==1: | |
| lane=next(x for x in b['enemies'] if x['actor']=='guard')['node'] | |
| stable=(b['east_commitments']>=2 if desired=='west' and self.facts['opponent_pattern']=='majority' else b['west_commitments']>=2 if desired=='west' else b['west_commitments']>=6 if self.facts['opponent_pattern']=='majority' else b['east_commitments']>=3) | |
| if lane==desired or not stable: | |
| feint_lane=('east' if desired=='west' else 'west') if self.facts['opponent_pattern']=='majority' else desired | |
| return a('feint',actor='Bo',lane=feint_lane) | |
| self.osmosis_stage=2 | |
| if self.route=='bridge': | |
| if runner['node']=='home': return a('bank',actor='Ada') if runner['flag'] else a('deploy',actor='Ada',neighbor='west') | |
| if b['base_captured']: return a('deploy',actor='Ada',neighbor='home') | |
| keeper=next(x for x in b['enemies'] if x['actor']=='keeper') | |
| if keeper['node']=='enemy': return a('challenge',actor='Ada',target='keeper') | |
| return a('deploy',actor='Ada',neighbor='enemy') | |
| if runner['node']=='home': return a('bank',actor='Ada') if runner['flag'] else a('deploy',actor='Ada',neighbor='east') | |
| if runner['node']=='east': return a('deploy',actor='Ada',neighbor='home' if runner['flag'] else 'relay') | |
| if runner['node']=='relay': return a('deploy',actor='Ada',neighbor='east') | |
| if phase==5: | |
| witness=self.facts['witness']; cell={'Iris':1,'Juno':2,'Kade':3}[witness] | |
| if b['player_cell']!=cell: return a('visit',cell=cell) | |
| if not b['claim'] or b['claim']['witness']!=witness: return a('interview',witness=witness) | |
| if not any(x['status']=='verified' and x['claim']==b['claim']['id'] for x in b['checks']): return a('cross_check',claim_id=b['claim']['id'],record_id=self.facts['record_authorization']) | |
| if b['checkpoint_test']!=self.facts['seal']: return a('test_checkpoint',seal_id=self.facts['seal']) | |
| return a('escort',witness=witness,neighbor=4) | |
| if phase==6: | |
| circuits={c['id']:c for c in b['circuits']} | |
| for cid in self.facts['order']: | |
| c=circuits[cid] | |
| if c['status']=='live': continue | |
| if c['status']=='tripped': return a('isolate',circuit=cid) | |
| if c['bus']!=self.facts['bus'] or c['status']=='isolated': return a('connect',circuit=cid,bus=self.facts['bus']) | |
| return a('energize',circuit=cid) | |
| return a('restore') | |
| if phase==7: | |
| for item,socket in [('coupler','coupler'),('exit_power','power')]: | |
| if b['installed'].get(socket)!=item: return a('install',item=item,socket=socket) | |
| if b['track']!=self.facts.get('track',0): return a('align_track',position=self.facts.get('track',0)) | |
| if len(b['boarded'])<2: return a('board',actor=next(x['id'] for x in o['team'] if x['id'] not in b['boarded'] and x['available'])) | |
| if b['armed_with']!=self.facts.get('seal','amber'): return a('arm_exit',seal_id=self.facts.get('seal','amber')) | |
| if b['valve'] is None: return a('open_valve',side=self.facts['valve']) | |
| return a('launch') | |
| raise RuntimeError('No legal-reference action for public state') | |
| def public_reference(initial_transition): | |
| if 'capacity_bytes' in initial_transition.observation.notebook: | |
| from .causal_reference import CausalReference | |
| return CausalReference() | |
| return LegalReference() | |
| def execute_reference(campaign,record=True,stop_before_valve=False): | |
| t=campaign.reset() | |
| causal='channels' in t.observation.board | |
| policy=public_reference(t); factory=type(policy) | |
| trace=[]; notes=[]; failure=None; steps=0; controller_resets=0; reactions=[]; route=None | |
| for _ in range(240): | |
| if t.done: break | |
| try: | |
| text=policy.notebook(t) | |
| if text is not None: | |
| t=campaign.replace_notebook(text,expected_revision=t.revision) | |
| if record: notes.append(dict(revision=t.revision,text=text)) | |
| action=policy.choose(t) | |
| if stop_before_valve and action.tag=='open_valve': break | |
| t=campaign.step(action,expected_revision=t.revision); steps+=1 | |
| if record: trace.append(dict(action=action.to_dict(),transition=t.to_dict())) | |
| if causal and t.context_reset: | |
| reactions=list(policy.observed_reactions); route=policy.route | |
| policy=factory(); controller_resets+=1 | |
| if t.error: | |
| failure=t.error.to_dict(); break | |
| except (KeyError,IndexError,ValueError,RuntimeError) as error: | |
| failure=repr(error); break | |
| boarded=list(t.observation.board.get('boarded',[])) | |
| return dict(outcome=t.outcome,reward=t.reward,steps=steps,charge=t.observation.charge,trace=trace,notebook_trace=notes,failure=failure,route=route or policy.route,observed_reactions=reactions or policy.observed_reactions,survivors=len(boarded) if t.outcome=='escaped' else 0,available_teammates=sum(m['available'] for m in t.observation.team),boarded_teammates=boarded,controller_resets=controller_resets) | |
| def run_reference(seed,ruleset='campaign'): | |
| return execute_reference(Campaign.generated(seed,ruleset)) | |
| class PerfectInformationReference(LegalReference): | |
| """Operator-only diagnostic controller; hidden facts are deliberately injected.""" | |
| def __init__(self, world): | |
| super().__init__() | |
| self.facts=dict(bus=('west','east')[world.polarity],valve=('west','east')[world.polarity],order=list(world.restoration_order),witness=world.current_witness,seal=world.current_seal,track=world.correct_track) | |
| self.rule_stage=6 | |
| def run_privileged_reference(seed,ruleset='campaign'): | |
| env=Campaign.generated(seed,ruleset) | |
| controller=PerfectInformationReference(env._world) | |
| t=env.reset();trace=[];notes=[];failure=None | |
| for _ in range(240): | |
| if t.done: break | |
| text=controller.notebook(t) | |
| if text is not None: | |
| t=env.replace_notebook(text);notes.append(dict(revision=t.revision,text=text)) | |
| try: | |
| action=controller.choose(t) | |
| t=env.step(action) | |
| trace.append(dict(action=action.to_dict(),transition=t.to_dict())) | |
| if t.error: failure=t.error.to_dict();break | |
| except (KeyError,IndexError,ValueError,RuntimeError) as error: | |
| failure=repr(error);break | |
| return dict(outcome=t.outcome,reward=t.reward,steps=len(trace),charge=t.observation.charge,trace=trace,notebook_trace=notes,failure=failure,reference='perfect-information diagnostic; not an optimality or fair-admission proof') | |