File size: 14,400 Bytes
0364757
 
 
 
 
 
 
2719bf4
 
 
0364757
 
2719bf4
 
 
 
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2719bf4
 
 
 
 
 
 
0364757
 
2719bf4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
from dataclasses import replace
from functools import lru_cache
from itertools import permutations
import random
from .domain import WorldSpec, RecordRevision, ArchiveSpec, ARCHIVE_WORKLOADS


def candidate(seed, ruleset='campaign', generation_version=2, archive_workload='standard', notebook_bytes=768, memory_profile='static'):
    if memory_profile not in ('static', 'commissioning') or (memory_profile == 'commissioning' and generation_version != 3):
        raise ValueError('Unsupported memory profile or generation.')
    if type(seed) is not int:
        raise ValueError('seed must be an integer')
    if generation_version == 3:
        return causal_candidate(seed, ruleset, archive_workload, notebook_bytes, memory_profile)
    if notebook_bytes != 768:
        raise ValueError('Custom byte capacity requires generation three.')
    if ruleset not in ('campaign', 'pilot') or generation_version != 2 or archive_workload not in ARCHIVE_WORKLOADS:
        raise ValueError('unsupported ruleset, generation version, or Archive workload')
    rng = random.Random(seed // 2)
    order = list(('alpha', 'beta', 'gamma')); rng.shuffle(order)
    witness = rng.choice(('Iris', 'Juno', 'Kade'))
    seal = rng.choice(('amber', 'cobalt', 'silver'))
    track = rng.randrange(3)
    ids = list(range(10, 40)); rng.shuffle(ids)
    rng.randrange(3)
    series_order = list(range(6)); rng.shuffle(series_order)
    doctrine, rotation = rng.choice(('guard', 'raid')), rng.randrange(4)
    if ruleset == 'pilot':
        witness, seal, track = 'Iris', 'amber', 0
    facts = [('restoration', '>'.join(order)), ('authorization', witness+'/'+seal), ('egress', str(track))]
    options = dict(restoration=['>'.join(p) for p in permutations(('alpha','beta','gamma'))],
                   authorization=[w+'/'+s for w in ('Iris','Juno','Kade') for s in ('amber','cobalt','silver')], egress=['0','1','2'])
    history = random.Random((seed // 2) * 104729 + 880301)
    endpoints = {}
    for subject, _ in facts:
        start = history.randrange(1000, 9000)
        endpoints[subject] = (start + 6000, start + 20000)
    scrolls = []
    for series in series_order:
        subject, statement = facts[series//2]
        current = bool(series % 2)
        rid = 'r'+str(ids[series])
        predecessor = 'r'+str(ids[series-1]) if current else None
        endpoint = endpoints[subject][int(current)]
        issues = [endpoint-4000, endpoint-2000, endpoint]
        if history.randrange(2):
            issues[1], issues[2] = issues[2], issues[1]
        endpoint_statement = statement if current else next(value for value in options[subject] if value != statement)
        pages = []
        for issue in issues:
            anchor_statement = endpoint_statement if issue == endpoint else history.choice([value for value in options[subject] if value != endpoint_statement])
            anchor = RecordRevision(rid, subject, anchor_statement, issue, predecessor, 'civic', True)
            filler_issues = history.sample(range(issue-900, issue), 63)
            fillers = [RecordRevision(rid, subject, history.choice(options[subject]), number, predecessor, 'civic', True) for number in filler_issues]
            relative = history.random()
            count = ARCHIVE_WORKLOADS[archive_workload]
            packet = fillers[:count-1]
            packet.insert(round(relative*(count-1)), anchor)
            pages.append(tuple(packet))
        scrolls.append(tuple(pages))
    archive = ArchiveSpec(archive_workload, tuple(scrolls))
    return WorldSpec(2, ruleset, seed, seed % 2, doctrine, rotation, archive, tuple(order), witness, seal, track, 1000, 0)


@lru_cache(maxsize=512)
def _admission(seed, ruleset):
    from .engine import Campaign
    from borderland_verify.reference import execute_reference
    costs = []
    for workload in ARCHIVE_WORKLOADS:
        world = candidate(seed, ruleset, archive_workload=workload)
        result = execute_reference(Campaign(world), record=False)
        if result['outcome'] != 'escaped':
            raise RuntimeError('legal admission failed: '+str(result.get('failure', result['outcome'])))
        costs.append(1000-result['charge'])
    budget = 113 if ruleset == 'campaign' else 38
    if len(set(costs)) != 1 or max(costs) > budget:
        raise RuntimeError('matched cohort admission exceeds its fixed charge budget or differs across tiers')
    return costs[0], budget


def generate(seed, ruleset='campaign', generation_version=2, archive_workload='standard', notebook_bytes=768, memory_profile='static'):
    world = candidate(seed, ruleset, generation_version, archive_workload, notebook_bytes, memory_profile)
    if generation_version == 3:
        receipt = admit_causal(world)
        if receipt['status'] != 'admitted':
            raise RuntimeError('generation-three admission ' + str(receipt))
        return replace(world, reference_cost=receipt['cost'])
    cost, budget = _admission(seed, ruleset)
    return replace(world, initial_charge=budget, reference_cost=cost)


def world_from_infrastructure(seed, workload, infrastructure, archive=None, reference_cost=0, notebook_bytes=768):
    from .plant import Charter, BUDGETS, circuit_order, permit_decision, exit_decision
    p = infrastructure
    if archive is None:
        archive = Charter(workload, tuple(tuple((r,) for r in sorted((r for r in p.revisions if r.service == service), key=lambda r: r.issued_at)) for service in p.services))
    witness, seal = permit_decision(p)
    return WorldSpec(3, 'campaign', seed, p.calibrations[0].sensor_xor, p.opponent.kind,
                     p.calibrations[0].phase_offset, archive, circuit_order(p), witness, seal,
                     exit_decision(p)[0], BUDGETS[workload], reference_cost, p, notebook_bytes,
                     'commissioning' if p.load_schedule is not None else 'static')


def causal_candidate(seed, ruleset='campaign', archive_workload='standard', notebook_bytes=768, memory_profile='static'):
    from .plant import (WIDTHS, Calibration, Transit, CircuitClause, DeliveryClause,
                        PermitClause, EgressClause, CharterRevision, OpponentLaw,
                        Infrastructure, Charter, LoadSchedule, LoadRating, CircuitTests, LoadTest)
    if type(seed) is not int or memory_profile not in ('static', 'commissioning'):
        raise ValueError('Invalid seed or memory profile.')
    if ruleset != 'campaign' or archive_workload not in WIDTHS:
        raise ValueError('Generation three supports campaign and compact/standard/extended service profiles.')
    rng = random.Random(seed // 2 + 3000017)
    labels = rng.sample(range(10, 99), WIDTHS[archive_workload] * 4 + 2)
    channels = tuple(Calibration('k' + str(labels.pop()), seed % 2 if i == 0 else rng.randrange(2), rng.randrange(4)) for i in range(2))
    transit = Transit(rng.choice(('west', 'east')), rng.randrange(4), rng.randrange(4), rng.randrange(2))
    services = ['s' + str(labels.pop()) for _ in range(WIDTHS[archive_workload])]
    circuit_ids = services[3:]
    revisions = []
    for index, service in enumerate(services):
        channel = channels[index % 2].id
        applicability = channels[(index + 1) % 2].id
        base_id, left_id, right_id = ('r' + str(labels.pop()) for _ in range(3))
        if index == 0:
            lane = rng.randrange(2)
            bodies = [DeliveryClause(channel, ('west','east')[bit]) for bit in (1-lane, lane, 1-lane)]
        elif index == 1:
            witness, seal = rng.randrange(3), rng.randrange(3)
            bodies = [PermitClause(channel, ('Iris', 'Juno', 'Kade')[(witness + shift) % 3], ('amber', 'cobalt', 'silver')[(seal + shift) % 3]) for shift in (2, 0, 1)]
        elif index == 2:
            delta = rng.randrange(3)
            bodies = [EgressClause(channel, (delta + shift) % 3, shift % 2) for shift in (2, 0, 1)]
        else:
            position = index - 3
            predecessors = [()] if position == 0 else [(circuit_ids[rng.randrange(position)],) for _ in range(2)]
            if position == 0: predecessors *= 2
            shift = rng.randrange(2)
            bodies = [CircuitClause(channel, predecessors[0], 1-shift),
                      CircuitClause(channel, predecessors[0], shift),
                      CircuitClause(channel, predecessors[1], 1-shift)]
        revisions.extend((CharterRevision(base_id, service, 1, None, None, None, bodies[0]),
                          CharterRevision(left_id, service, 2, base_id, applicability, 0, bodies[1]),
                          CharterRevision(right_id, service, 3, base_id, applicability, 1, bodies[2])))
    law = OpponentLaw(('tracker', 'denier', 'ambusher')[(seed // 2) % 3], rng.choice((2, 3)), rng.choice((1, 2)), rng.choice((2, 3)), rng.randrange(2))
    schedule = None
    if memory_profile == 'commissioning':
        ratings_rng = random.Random('borderland/commissioning/ratings/v1/' + str(seed // 2))
        loads_rng = random.Random('borderland/commissioning/loads/v1/' + str(seed // 2))
        schedule = LoadSchedule(
            tuple(LoadRating(r.id, tuple(ratings_rng.randrange(4) for _ in range(8))) for r in revisions if isinstance(r.body, CircuitClause)),
            tuple(CircuitTests(cid, tuple(LoadTest(loads_rng.randrange(8), loads_rng.randrange(3)) for _ in range(3))) for cid in circuit_ids))
    plant = Infrastructure(channels, transit, tuple(revisions), law, schedule)
    scrolls = [tuple((r,) for r in sorted((r for r in revisions if r.service == service), key=lambda r: r.issued_at)) for service in services]
    rng.shuffle(scrolls)
    return world_from_infrastructure(seed, archive_workload, plant, Charter(archive_workload, tuple(scrolls)), notebook_bytes=notebook_bytes)


def curve_twins(world):
    """Return thresholds 0 and 3 at the first circuit's first applicable band."""
    if not isinstance(world, WorldSpec) or world.generation_version != 3 or world.memory_profile != 'commissioning':
        raise ValueError('Curve twins require a generation-three commissioning WorldSpec.')
    plant = world.infrastructure
    schedule = plant.load_schedule
    first = schedule.circuits[0]
    revision = plant.current(first.service).id
    band = first.tests[0].band
    twins = []
    for threshold in (0, 3):
        ratings = tuple(replace(rating, thresholds=tuple(
            threshold if index == band else value for index, value in enumerate(rating.thresholds)))
            if rating.revision == revision else rating for rating in schedule.ratings)
        twins.append(replace(world, infrastructure=replace(plant, load_schedule=replace(schedule, ratings=ratings))))
    return tuple(twins)


def coherent_twin(world, channel_id=None, sensor_xor=None, phase_offset=None, transit=None):
    if world.generation_version != 3:
        raise ValueError('Coherent interventions require generation three.')
    p = world.infrastructure
    channel_id = channel_id or p.calibrations[0].id
    if channel_id not in {c.id for c in p.calibrations}:
        raise ValueError('Unknown calibration channel.')
    channels = tuple(replace(c, sensor_xor=c.sensor_xor if sensor_xor is None else sensor_xor,
                             phase_offset=c.phase_offset if phase_offset is None else phase_offset)
                     if c.id == channel_id else c for c in p.calibrations)
    return world_from_infrastructure(world.private_seed, world.archive.workload,
                                     replace(p, calibrations=channels, transit=p.transit if transit is None else transit), world.archive, notebook_bytes=world.notebook_bytes)


def permute_identifiers(world, mapping):
    from .plant import CircuitClause, Charter
    if world.generation_version != 3:
        raise ValueError('Identifier permutations require generation three.')
    p = world.infrastructure
    domain = {c.id for c in p.calibrations} | set(p.services) | {r.id for r in p.revisions}
    if set(mapping) != domain or len(set(mapping.values())) != len(domain) or any(type(v) is not str or not 0 < len(v) <= 64 for v in mapping.values()):
        raise ValueError('Provide a complete bijection of public generated identifiers.')
    records = []
    for r in p.revisions:
        body = replace(r.body, channel=mapping[r.body.channel])
        if isinstance(body, CircuitClause):
            body = replace(body, predecessors=tuple(mapping[s] for s in body.predecessors))
        records.append(replace(r, id=mapping[r.id], service=mapping[r.service],
                               supersedes=mapping.get(r.supersedes), applies_channel=mapping.get(r.applies_channel), body=body))
    schedule = p.load_schedule
    if schedule is not None:
        schedule = replace(schedule, ratings=tuple(replace(r, revision=mapping[r.revision]) for r in schedule.ratings),
                           circuits=tuple(replace(c, service=mapping[c.service]) for c in schedule.circuits))
    renamed = replace(p, load_schedule=schedule, calibrations=tuple(replace(c, id=mapping[c.id]) for c in p.calibrations), revisions=tuple(records))
    by_id = {r.id: r for r in records}
    archive = Charter(world.archive.workload, tuple(tuple(tuple(by_id[mapping[r.id]] for r in page) for page in scroll) for scroll in world.archive.pages))
    return world_from_infrastructure(world.private_seed, world.archive.workload, renamed, archive, notebook_bytes=world.notebook_bytes)


def admit_causal(world):
    from .engine import Campaign
    from borderland_verify.reference import execute_reference
    try:
        result = execute_reference(Campaign(world), record=False)
    except (RuntimeError, ValueError) as error:
        return dict(status='solver-unverified', reason=str(error), root=world.private_seed)
    if result['outcome'] != 'escaped':
        status='solver-unverified' if result['failure'] is not None or result['outcome']=='running' else 'rejected'
        return dict(status=status, root=world.private_seed, outcome=result['outcome'], reason=result['failure'] or 'Bounded public reference did not escape.', steps=result['steps'])
    return dict(status='admitted', root=world.private_seed, cost=world.initial_charge-result['charge'],
                charge=result['charge'], survivors=result['survivors'], available_teammates=result['available_teammates'], boarded_teammates=result['boarded_teammates'], steps=result['steps'], controller_resets=result['controller_resets'])